HiNC-2025-win-desktop-Deploy/App/wwwroot/HiAPI-docsite/index.json

{
  "anatomy/by-source/index.html": {
    "href": "anatomy/by-source/index.html",
    "title": "Anatomy by Source Directory | HiAPI-C# 2025",
    "summary": "Anatomy by Source Directory The rest of Anatomy is keyed on the shipped surface — a route, a Control-Tree branch, a reusable control. This layer is keyed on the source tree instead, and it is the entry point for the reader who knows which directory a change landed in but not which screen it shows up on. Ordered the way a request travels: the front end first, then the process that serves it. Directories Web Service SPA Source Tree — the Quasar front end under wwwroot-src/src: how components/ is grouped two ways at once, what the Control-Tree registry actually is, and why half the route table is redirects Web Service Backend Source Tree — the ASP.NET Core half: how to read a filename, why folder nesting does not predict a route, and which declared hub is never mapped What This Layer Is For A page in the rest of Anatomy answers what is this thing on my screen made of. Both of these answer the inverse: this directory changed — what does it show up as, and which page is now wrong. That makes them the first stop after a refactor, and the reason each directory entry names the pages that document it. They are directory indexes, not file listings. A file worth naming is named on the page that documents the surface it implements; what lives here is the shape of the tree, the conventions that hold across it, and the traps that survive a careful reading of any single file. What Is Not Indexed Here The HiAPI engine repositories are not given a directory document. Anatomy cites engine source where a shipped surface depends on it, but the engine's own structure is covered by the generated API Reference, which stays correct in a way a hand-written index could not. Neither is the outgoing Windows desktop client. It takes no new feature work, so a hand-written index of its tree drifts with every flagship change and is read by nobody; the same reasoning retired the page-by-page map of its files. See Also HiNC App Anatomy — the section index, and the surface-keyed way in Web Service SPA Source Tree — the flagship front end Web Service Backend Source Tree — the process that serves it Platform — the machinery under every screen, entered by mechanism rather than by directory"
  },
  "anatomy/by-source/webservice-backend/index.html": {
    "href": "anatomy/by-source/webservice-backend/index.html",
    "title": "Web Service Backend Source Tree | HiAPI-C# 2025",
    "summary": "Web Service Backend Source Tree The C# half of HiNC-2025-webservice is an ASP.NET Core process that serves the SPA, answers its REST calls, and pushes to it over SignalR. It is organised by the engine's domain vocabulary, not by web-framework artifact type: a controller, its hub, its DI service and its non-web scene objects sit together in one domain folder rather than in a Controllers / Hubs / Services split. Folders below are ordered by how much of the shipped surface they answer for. Reading a Filename The role of a file is told by its suffix and base type, and the convention holds throughout: Suffix What it is *Controller.cs a REST controller with a route attribute *Hub.cs a SignalR hub — but see the two traps below *Service.cs a singleton registered in Program.cs *Displayee.cs a scene-composition object handed to the engine; no HTTP surface at all *Dtos.cs, *Config.cs plain wire or settings types Two names deliberately break the reader's expectation. Controller/ControllerController.cs means CNC controller, not an MVC controller. And Mech/'s *DisplayController.cs files are ordinary REST controllers that attach a displayee to a rendering connection somebody else already owns — they are not hubs. Important Folder nesting does not predict the route. Mech/Topo/ and Mech/MechBuilder/ expose routes that carry no api/mech/ prefix at all, and even inside Mech/ two conventions coexist: the newer ports use kebab-case paths under api/mech/, while the older keyed-object editors use the controller-name default. Read the route attribute, never the path. Composition Root Program.cs is the only C# file at the repository root, and it is where the questions a reader usually has are actually answered: which services are singletons, which hubs are mapped, and what the middleware order is. Two facts about it are worth carrying: A declared hub is not a mapped hub. Program.cs maps eight hub endpoints. Anything not in that list is unreachable however complete its class looks — see the trap under Execution/ below. The tree is not self-contained. The project service types Program.cs leans on hardest live in the sibling HiNc engine repository, not here. Documented in Program and Hosting. Execution Execution/ is the run cockpit's whole backend: playback control, the strip and cycle-line charts, the NC-program branch index, run-output queries, and the real-time push layer. Execution/ExecutionController.cs — the playback surface. Execution/ExecutionChartsController.cs and Execution/ClStripController.cs — the chart data. Three separate classes share the case-insensitive api/execution prefix on purpose, one of them routed there rather than under Mission with a comment saying why. Execution/SessionSinkHub.cs — four mapped hubs declared in one file, one per message sink, so hub-per-file does not hold here. Each pairs with a broadcast service that Program.cs resolves eagerly, so it subscribes to its sink before the first client connects. Execution/ClStripHub.cs, Execution/ExecutionStatusHub.cs — the strip and status pushes. Warning Execution/ExecutionCanvasHub.cs declares a hub that Program.cs never maps and that nothing in the repository references. The Execution canvas rides Disp/RenderingHub.cs like every other canvas. A reader looking for “the hub behind the Execution page” by name will find this file first and be wrong. Documented in Execution Page, Program Branch, Selected-Step Info Panel, Strip Charts and Cycle-Line Charts. Mech Mech/ is the largest domain folder: the REST surfaces for the machine tool, the tool house and cutter editing, fixtures and workpieces, spindle capability, background and coolant, and the three runner suits. It also holds the display controllers that bind a mechanism scene onto a rendering connection. Mech/CutterDtoBuilder.cs is the shared read-side DTO shape two controllers reuse, and Mech/NcSuitUsage.cs is what lets the Control Tree show the CSV and CL runner branches only when the loaded project actually plays them. No SignalR hub lives here. Mech/MechBuilder/ — the standalone mechanism-building session, held by a process-wide singleton rather than per user. Documented in Mechanism Builder Page. Mech/Topo/ — one thin controller per transformer kind, each editing an instance held in the keyed object store. Documented in Transformer Select Panel. Mech/SoftNcRunnerController.cs — the one endpoint family behind the Controller branch, and the file whose snapshot decides which of that branch's nodes exist. Documented in Controller Branch, with Brand Matrix for the snapshot flags themselves. Mech/CsvRunnerController.cs and Mech/ClRunnerController.cs — the two resident non-brand runner suits, reached from tree branches the Preference menu hides by default. Documented in Preference Menu Dropdown until those branches have a page. Documented in General Setup Page and Tool House Page and the panels beneath them. Missions Missions/ is the mission command tree's backend. Two things here surprise readers: The folder is plural and the route is singular — and the SPA folder is singular too. Missions/NcOptOptionEndpoints.cs is not a minimal-API endpoint file despite the name. It is a second file of the same partial controller class, which is why its routes resolve under the mission prefix. Missions/MissionCommandCatalog.cs reflects over every session command carrying the catalog attribute once per process, replacing hand-maintained kind switches, and Missions/MissionCommandFields.cs does the same for annotated scalars — which is how a simple command gets an editor without a bespoke panel. Missions/ScriptCompletionService.cs and Missions/ScriptCompileCheckService.cs are the Roslyn pair behind the script editor; the compile check reuses the same options and globals type the script command uses at run time. Documented in Mission Root Panel and the command panels under it. Disp Disp/ is the rendering layer. Disp/RenderingHub.cs is the single transport surface for every 3D canvas in the application — canvas initialization, pointer, key and touch input, resize, view presets, cache clearing and snapshots — and the SPA's canvas component defaults to it, so all pages share one hub rather than one hub per page. Disp/RenderingService.cs owns the per-connection engines the hub resolves against. Disp/StlPreviewController.cs is the only other REST surface here. The *Displayee.cs files are scene-graph composition objects rather than web types, and each has a live instantiation site: the execution scene, the equipment-setup scene, the step-subtraction scene and the two coordinate-frame displayees the first two compose in. Documented in Rendering Canvas on Web Service, RenderingCanvas Tool Bar and — for Disp/StlPreviewController.cs and the per-connection slot behind it — STL Preview Pane. Environments Environments/ is session and environment scope: the project lifecycle, per-user preference persistence, the Execution page's division flags, and the shipped localized step-present catalog. It is also where the Log Viewer's data comes from — the log endpoints sit on the project controller beside status, new, load, save, reload, save-as and close. Documented in Main Panel, Session State, Preference Menu Dropdown, Internationalization, Log Viewer Page and Step Present Dialog. Common, Geom and Widget Common/ — cross-cutting infrastructure with no single domain owner: the optional login gate, the named-root file explorer, path guards, the daily file logger, and two pieces the whole application rests on. Common/IndexService.cs is the keyed object store behind the index a backend object, then edit it by key pattern every geometry, transformer and widget controller uses. Common/CleanupHub.cs is not a messaging hub, and it is not what bounds that store either. Its key registry is an ordinary instance property and SignalR builds a fresh hub instance for every invocation, so the entry Add records is discarded with the instance that received it and the disconnect handler always walks an empty registry. The bound comes from the browser instead: wwwroot-src/src/composables/useCleanupHub.ts posts the index-remove endpoint on Common/IndexController.cs for every key it holds when its host unmounts, and again whenever a key it registered is replaced. Documented in Dictionary Service Pattern, WebAPI Hub Cleanup Pattern, Login and Authentication and Log Viewer Page. Geom/ — one CRUD controller per geometry kind, on the same keyed-object pattern, and nothing else: no hubs, no services. Documented in Geometry Panels. Widget/ — the generic value and lifecycle controllers the reusable inputs post to: the 3D vector, the 4×4 matrix, and the object-management surface that handles file operations, XML editing and copy-paste for indexed objects. Documented in Object Management Menu Button, Vec3dControl Component and Mat4dControl Component. Controller and Demo Controller/ is the single-file surface behind the legacy controller page. It has a successor in Mech/SoftNcRunnerController.cs, whose own doc comment says so, but both are live — the legacy page has not been removed. Documented in Legacy Controller. Demo/ is customer-facing sample code — a custom colour guide and a per-step optimization sweep — compiled into the assembly with no call site in the running application. Read it as an example of how to extend the engine, not as part of the shipped behaviour. See Also Anatomy by Source Directory — the other two source trees, and how this layer is meant to be entered Web Service SPA Source Tree — the front end this process serves and answers"
  },
  "anatomy/by-source/webservice-spa/index.html": {
    "href": "anatomy/by-source/webservice-spa/index.html",
    "title": "Web Service SPA Source Tree | HiAPI-C# 2025",
    "summary": "Web Service SPA Source Tree HiNC-2025-webservice/wwwroot-src/src is the flagship front end: a Quasar CLI single-page application in Vue 3, TypeScript and Pinia, served by the same ASP.NET Core process that answers its REST calls. Every page in Anatomy documents something in this tree or in the backend beside it. Folders below follow the stock Quasar skeleton order, with the two places the skeleton breaks called out where they occur. The One Thing to Know First components/ is grouped both ways at the same level, and that is deliberate rather than untidy: Page-scoped — components/controller/, components/execution/ and half of components/mech/ are chrome for exactly one route. Domain-scoped — components/geom/, components/topo/, components/toolhouse/, components/spindle/, components/workpiece/ and components/mission/ are pulled in from wherever the domain surfaces, most often the Control Tree. Primitives — components/widgets/ and components/panels/ have no domain at all and are the most-imported folders in the application. So a component's folder does not tell a reader who mounts it. components/mission/ has no Mission page — /mission redirects into the Execution page's tree — and components/workpiece/ holds a single dropdown while the real workpiece editors are Control-Tree panels. The second break is history. The application has been re-architected repeatedly, and because Control-Tree node ids ride in ?tree= links they are a public surface: every regroup adds a migration hop rather than rewriting the last one. The residue is visible in wwwroot-src/src/router/routes.ts, where a large share of the table is redirects preserving URLs from earlier architectures — a route existing there does not mean a page exists for it. Root and Boot wwwroot-src/src/App.vue — not the shell. It is a bare router view plus the once-per-load wiring that subscribes the project store to the execution-status hub. The real shell is wwwroot-src/src/layouts/MainLayout.vue. Documented in Session State. wwwroot-src/src/boot/auth.ts, wwwroot-src/src/boot/i18n.ts, wwwroot-src/src/boot/routine-toast.ts — Quasar boot files, run once before mount and in a declared order. The auth boot file patches the global fetch and inspects every 401, which is why no API module carries its own 401 handling — but the redirect it can raise is conditional: it fires only while the auth store reports the login gate enabled, and not when the router is already on the login route, so on a build with the gate off a 401 redirects nowhere. The toast boot file patches the shared notify helper so every toast is mirrored into the footer history without touching a call site. Documented in Login and Authentication and Internationalization. wwwroot-src/src/layouts/MainLayout.vue — the shell: menu bar, the routed page container, footer. It also owns the mechanism every page depends on and no page implements: a project epoch, bumped when the loaded project changes, is the keep-alive key, so a project change destroys and rebuilds every cached page. Documented in Main Panel and Session State. The REST Edge wwwroot-src/src/api/ is one thin typed module per backend controller family — functions, DTO types and kind unions, no Vue code. This is the tightest correspondence between the two halves of the application: each module wraps one named controller almost one-to-one. wwwroot-src/src/api/http.ts — the shared response layer. Its own header names the modules that deliberately bypass it, so “every API module goes through it” would be wrong. wwwroot-src/src/api/index-service.ts — not a barrel file. It wraps the backend's keyed object store, which is where the key string threaded through the whole application comes from. Documented in Dictionary Service Pattern. Components wwwroot-src/src/components/ — the shared top level: wwwroot-src/src/components/AppMenuBar.vue, wwwroot-src/src/components/AppFooter.vue, wwwroot-src/src/components/RenderingCanvas.vue, wwwroot-src/src/components/FileExplorer.vue and wwwroot-src/src/components/StlPreviewPane.vue. The canvas does not render locally: it opens a SignalR connection and paints server-rendered frames, which is why several pages each own a canvas bound to a different backend scene. Documented in Rendering Canvas on Web Service, File Explorer and STL Preview Pane. wwwroot-src/src/components/controlTree/ — the largest folder in the SPA by a factor of two, and a registry-driven panel system rather than a folder of tree widgets. wwwroot-src/src/components/controlTree/itemTypes.ts and its domain siblings map an item-type string onto a panel component and a child-building function; wwwroot-src/src/components/controlTree/useControlTreeHost.ts is the state machine that builds the tree, gates a dirty selection switch, and syncs ?tree=; the many panel components are the editors the registry resolves. It serves three consumers, not one — the Execution and General Setup pages each instantiate their own scoped host, while the Tool House page reuses the identical panels and registry through a tab cascade and never touches the host. Documented in Control Tree — the folder's own page — with Execution Page, General Setup Page and Tool House Page for the three consumers, and Program Branch for the NC-program item types and panels that live in this folder. The nineteen SoftNc* panels and their registry are a wave of their own, documented under Controller Branch: which of them the tree mounts at all is decided by Brand Matrix, and what they share is Editing Contract. wwwroot-src/src/components/controlTree/toolhouse/ — the Tool House branch's panels. Easy to confuse with wwwroot-src/src/components/toolhouse/: these are the panels the registry mounts, that folder holds the content fragments those panels embed, and the dependency runs one way only. wwwroot-src/src/components/execution/ — the run cockpit's own panels, plus its charts/ sub-folder, the uPlot charting layer. Not purely page-local: wwwroot-src/src/components/execution/ExecutionToolBar.vue is mounted by the Control Tree's primary panel, and the spindle contours chart imports from the charts folder. Documented in Execution Page, Strip Charts and Cycle-Line Charts. wwwroot-src/src/components/geom/ and wwwroot-src/src/components/topo/ — structural twins: one editor per kind, the same modelKey prop and changed / error emits, and a single kind → editor map — wwwroot-src/src/components/geom/geometryEditors.ts and wwwroot-src/src/components/topo/transformerEditors.ts — that is the source of truth for both the switchboard and the Control Tree. A new kind must be registered there, not merely dropped in the folder. “topo” means coordinate transformers, not mesh topology. Documented in Geometry Panels and Transformer Select Panel. wwwroot-src/src/components/widgets/ — the reusable input library: numeric, vector and matrix inputs, the file-path input and picker, the CodeMirror text editor, the display-options and object-management menus. Documented in Widgets. wwwroot-src/src/components/panels/ — pure layout machinery with no domain: the collapsible expansion panel and the resizable stack whose registration contract produces the “rows collapse in place” behaviour the tree pages describe. Documented in Control Tree, whose dock rows are both expansion rows, and Session State for the keep-mounted flag that decides whether a collapse unmounts its content. wwwroot-src/src/components/mission/, .../toolhouse/, .../spindle/, .../preference/, .../mech/, .../workpiece/ and .../controller/ — the domain and page folders named above. The *Div.vue suffix inside the Tool House folder is a convention carried over from the legacy Blazor components: a Div is an embeddable content fragment with no panel chrome. State, Routing and Text wwwroot-src/src/composables/ — three different concerns in one folder: hub access, shared domain state, and UI mechanics. wwwroot-src/src/composables/useSharedHub.ts is the reference-counted connection manager behind every hub composable, so a hub opens only while something consumes it. wwwroot-src/src/composables/useToolHouse.ts and wwwroot-src/src/composables/useSpindleCapability.ts are module-level singletons, not per-component instances. wwwroot-src/src/composables/useViewPrefs.ts stores layout state in the browser only — it is neither in the project file nor in the server's user config. Documented in Session State. wwwroot-src/src/stores/ — four Pinia stores. wwwroot-src/src/stores/index.ts is not a barrel; it is the Quasar factory. Most shared state lives in composables/ instead. Documented in Session State. wwwroot-src/src/router/ — wwwroot-src/src/router/routes.ts is the table plus the legacy redirects, and wwwroot-src/src/router/treeRoutes.ts is the load-bearing file its name understates: it holds the accumulated chain of tree-id renames and the id → page resolver, plus the tab-name constants both the router and the tab composable consume. A route's meta.title holds an i18n key, not a title. Documented in Tree Ids and Routes. wwwroot-src/src/i18n/ — three locales shipped together, each a list of namespace files. English is the schema, not merely a locale: the two Chinese bundles are typed against it, so a key present in English and missing there is a build error. Keys are split by UI region rather than by source file, so there is no one-to-one mapping between an i18n file and a components folder. Documented in Internationalization and Translation Remarks. wwwroot-src/src/pages/ — one file per route, and page size is a poor guide to importance: the General Setup page is small because it delegates almost everything to the Control Tree dock and the equipment canvas, while the File Explorer page is a thin wrapper around a large shared component. wwwroot-src/src/utils/, wwwroot-src/src/directives/, wwwroot-src/src/css/ — small and mostly presentational. Two severity scales exist and must not be conflated: wwwroot-src/src/utils/messageSeverity.ts maps the engine's diagnostic scale, while the footer's routine severity is a separate, shorter toast scale. See Also Anatomy by Source Directory — the other two source trees, and how this layer is meant to be entered Web Service Backend Source Tree — the process that serves this application and answers its REST and hub traffic"
  },
  "anatomy/conventions/dictionary-service-pattern.html": {
    "href": "anatomy/conventions/dictionary-service-pattern.html",
    "title": "DictionaryService and DictionaryHub Pattern | HiAPI-C# 2025",
    "summary": "DictionaryService and DictionaryHub Pattern Overview A connection-scoped indexing pattern for referencing backend objects across hierarchical SignalR hub connections. Core Components DictionaryService: Manages connection-scoped index dictionaries First layer key: Hub connectionId (auto-generated by SignalR) Second layer key: LocalId (resource name) Value: References to backend objects (functions, getters/setters) DictionaryHub: Base hub that auto-cleans index entries on disconnect Architecture Root-Hub └── Child-Hub - has parent's connectionId └── Grandchild-Hub - has parent's connectionId Each hub gets a unique system-generated hub-connectionId. Child hubs receive parent's connectionId to access parent data. Key Patterns Parent ConnectionId Passing: Child hubs copy parent's function references via connectionId Frontend ConnectionId Chain: Components pass connectionId down the hierarchy Wrapper Function Pattern: Child hubs should create wrapper functions that dynamically retrieve and invoke parent functions at runtime, rather than directly copying references. This ensures type safety through runtime checking and supports dynamic function updates from the parent. Benefits Isolation: Each component has its own connection/index space Nesting Support: Same components can be nested without conflicts Auto-cleanup: Index entries cleaned on disconnect Data Inheritance: Access parent's backend objects via connectionId chain Best Practices Apply or inherit from DictionaryHub for auto-cleanup Use meaningful key names (e.g., “transformer-getter”) Always setup dictionary functions unconditionally during initialization - put condition checks inside the functions, not around the setup. This ensures child panels can access functions even when parent objects temporarily don't meet the conditions. Common Pitfalls Don't use child's connectionId to index parent's data"
  },
  "anatomy/conventions/gui-file-path-assignment.html": {
    "href": "anatomy/conventions/gui-file-path-assignment.html",
    "title": "GUI File Path Assignment | HiAPI-C# 2025",
    "summary": "GUI File Path Assignment See the remarks of MakeXmlSource(string, string, bool) to know the design pattern of file path treatment. if the assigned file path is descendent of the configuration directory, it is straight forward that set the baseDirectory to the configuration directory and apply relative path to relFile; if not, set baseDirectory to null and set relFile to absolute path. GUI that needs to assign file generally requires a code-behind BaseDirectory property as assistent model. The property is assigned by the parent model from the parent GUI. In most cases, the first BaseDirectory is the project directory if the project has assigned (created or loaded). Portability To maintain For the portability of project or the other folder-based unit, if the sub-item is loaded by absolute path outside the folder-based unit directory, redirect the saving path to the folder-based unit directory, i.e. the SubItemFile below. Note You have no need to do an additional action to create a duplicate in the folder-based unit directory. Since the file-writing pattern of MakeXmlSource(string, string, bool) create files when user call to save. In other perspective, if user does not call to save, the local duplicate should be created. The design pattern is usually saw in the HiAPI program, a object contains the properties: object SubItem; string SubItemFile; Then you should keep the Protability. File Path of Load Button and Save Button A Load or Save button opens the browser at one of three roots: Admin Directory Project Directory Resource Directory The Resource Directory and Project Directory are generally under the Admin Directory, and the admin directory is generally set in the appsettings.json file. The kinds of button are not exclusive — several may sit on the same tool bar — and a button that opens the Resource root has to say so in its label. If the selected file path is under the project directory, apply the relative path from the project: baseDirectory is the project directory and relFile is the relative path. Tip Always preserve an empty filter ( * . * ) for the browser. Typical Action if exhibitionOnly false On IMakeXmlSource.MakeXmlSource(string, string, bool) with exhibitionOnly false, the argument (baseDirectory and relFile) should be the same from object's host (if exist) XML output function."
  },
  "anatomy/conventions/index.html": {
    "href": "anatomy/conventions/index.html",
    "title": "Conventions | HiAPI-C# 2025",
    "summary": "Conventions The rules and shared contracts every Anatomy page assumes. A page in this folder describes something that is true across screens rather than something a reader can point at: how a message reaches the user, how a control behaves when its model is wrong, how a file path is stored, how a component releases what it indexed on the server. Ordered from the rules that bind every page in both applications, through the two shared UI contracts, down to the service patterns and the canvas transport beneath them. Rules That Bind Every Page Message and Exception Handling HiNC uses three independent message categories: Diagnostic (IProgress<object>), UI Notification (MessageBoardUtil), and App Log (ILogger). See Message Management for the full design pattern. For async exception handling, use CatchExceptions with a caller-provided handler: await task.CatchExceptions(ex => progress?.Report(ex)); The Bottom Message Bar displays UI-level notifications. The Session Message Panel displays session diagnostic messages. Loose Manner The Loose Manner pattern handles rapidly-called synchronous actions where only the last call needs to be effective. The LooseRunner class manages skippable rapid-calling synchronous actions. When an action is called rapidly, only the last call is executed while previous calls are safely skipped. The TryRun method is used to execute actions in this manner. The LooseRunner should be disposed when its owner is disposed to ensure proper resource cleanup. Loose Couple If the model of a UI component is null or mismatched, apply a status badge instead of throwing an exception, so the rest of the UI keeps working. Pages Translation Remarks — The terminology every translated UI label is held to, so the same concept keeps the same word across screens and languages GUI File Path Assignment — How a control stores a chosen file: relative to the configuration directory when it sits inside it, absolute when it does not Numeric Input/Output Utilities — Handling Infinity, -Infinity and NaN across the JavaScript / C# boundary, where plain JSON cannot carry them DictionaryService and DictionaryHub Pattern — Connection-scoped indexing that lets a hierarchical component reference a backend object across hub connections Webapi with Hub-Cleanup Assistance Pattern — Which component owns an index key and where it releases it, so a component never cleans a key it did not create Rendering Canvas on the Web Service — The SignalR transport that puts a server-rendered 3D canvas on a browser page See Also Platform — the other cross-screen folder: the machinery these rules are applied on top of, including the host process that starts HiAPI App Shell — the window frame these conventions are applied inside Widgets — the reusable controls that implement two of them"
  },
  "anatomy/conventions/numeric-io-utilities.html": {
    "href": "anatomy/conventions/numeric-io-utilities.html",
    "title": "Numeric Input/Output | HiAPI-C# 2025",
    "summary": "Numeric Input/Output NaN, Infinity and -Infinity are ordinary values in a geometry model and ordinary things for a user to type, but JSON has no encoding for any of them. This page describes how the web application carries them across the boundary in both directions. The Server Half One line of configuration does it. Program.cs sets options.JsonSerializerOptions.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals; so the ASP.NET Core serializer reads and writes the three values as the JSON string literals \"NaN\", \"Infinity\" and \"-Infinity\" instead of failing. It sits on the AddControllers JSON options, so every controller inherits it and no DTO, converter or endpoint has to opt in. Without it a double.NaN anywhere in a response throws during serialization, which is why the setting is load-bearing rather than a convenience. The reach stops at the controllers. Hub payloads are serialized by SignalR's own protocol options, and nothing configures them: AddSignalR() is registered bare and the service contains no AddJsonProtocol call, so the named literals are a controller-JSON contract rather than a service-wide one. The Client Half There is no shared numeric module. Each input widget formats and parses the special values itself, and the three that ship do not agree on all of it. The widgets are also not the only readers of this boundary: an API module that has to put a non-finite number on the wire converts it in place, as wwwroot-src/src/api/mission.ts does for the mission command fields. That conversion is not symmetric — it writes all three literals but recognises only the two infinity spellings on the way back — so a NaN returned by those endpoints resolves to the caller's supplied default instead. NumericInput.vue Vec3Input.vue Mat4Input.vue NaN displays as empty field NaN 0 Infinity / -Infinity display as literal text literal text literal text An empty field parses to null, under the default allowEmpty 0 0 Unparseable text on blur stays in the box under an error message reverts to the last valid value reverts to the last valid value All three accept the same spellings on the way in: infinity, -infinity and nan case-insensitively. The ∞ and -∞ glyphs are where they part: the single-value field and the three-axis editor take them, the matrix grid does not. All three commit on blur or Enter rather than per keystroke, but only the vector and matrix editors compare the parsed value against the model before emitting. The single-value field carries no such guard and emits on every accepted commit, so committing with Enter and then leaving the field writes the same value twice. The consequence worth knowing: NaN does not survive a round trip through the matrix editor. Mat4Input.vue renders it as 0, so re-committing a cell that held NaN writes a real zero. NumericInput.vue is the input the rest of the app reaches for: no other component in the client is embedded by anywhere near as many editors, so a new numeric field should embed it rather than repeat the parse. Its own props, bounds and validation messages are documented at Numeric Input. Source Code Path See HiNC App Anatomy for git repository links. Web Page Application Source Code Path wwwroot-src/src/components/widgets/NumericInput.vue — the shared single-value numeric field: local formatValue / parseValue, blur-and-Enter commit, and the rejected text left standing under an error message when a commit fails. wwwroot-src/src/components/widgets/Vec3Input.vue — the three-axis editor; carries its own copy of the same format and parse pair, plus a (x, y, z) text form. wwwroot-src/src/components/widgets/Mat4Input.vue — the sixteen-cell matrix grid; the same pair again without the glyph spellings, and with the NaN-to-zero behaviour above. wwwroot-src/src/api/mission.ts — a non-widget reader of the same boundary: numericToApiString writes all three literals for the mission command fields, parseMaybeInfiniteNumber reads only the two infinity spellings back. Program.cs — the AllowNamedFloatingPointLiterals setting on the controller JSON options that lets the three values cross as JSON at all, and the bare AddSignalR() registration that does not share it. See Also Vec3dControl Component — the three-axis editor, one of the three inputs that carries its own format and parse Mat4dControl Component — the sixteen-cell grid, the one input that renders NaN as zero Numeric Input — the single-value field, and the widget that carries this contract to the most callers"
  },
  "anatomy/conventions/rendering-canvas-web-service.html": {
    "href": "anatomy/conventions/rendering-canvas-web-service.html",
    "title": "Rendering Canvas on Web Service Application | HiAPI-C# 2025",
    "summary": "Rendering Canvas on Web Service Application Overview The web application's 3D canvas is rendered on the server and streamed to the browser over a SignalR hub connection at /renderingHub. Disp/RenderingHub.cs serves that hub, Program.cs maps it, and the singleton in Disp/RenderingService.cs owns one native display engine per hub connection. The browser paints the frames that arrive and forwards the user's input back. Core Component Location: wwwroot-src/src/components/RenderingCanvas.vue Purpose: owns one hub connection, forwards input to the server engine, and paints the frames the server streams back Its hubUrl prop defaults to /renderingHub, and it exposes connect, disconnect, the eight view commands and clearCache — the surface through which wwwroot-src/src/components/RenderingCanvasToolBar.vue drives the canvas instance it is bound to. Connection Management SignalR Hub Connection Each RenderingCanvas instance opens its own hub connection and therefore owns one connection ID; the server keeps one display engine per connection ID, so several canvases can be live at the same time. On initialization the hub sends the connection ID back to the caller as CanvasInitialized, and the component re-emits it as serverInitialized. It is re-emitted after every reconnect, because the server disposes the engine on disconnect and a reconnect gets a new ID — the parent page answers by registering its content against that new ID. The connection ID is the index for every canvas operation. Disp/RenderingService.cs keys the engine dictionary, the last-input time, the last lossless-frame hash and the negotiated frame format by it, and Disp/RenderingHub.cs keys its own sketch-view cache the same way. Engine Lifetime The engine's life is the connection's: GetOrCreateEngine creates it when the canvas initializes, and RemoveEngine — called from OnDisconnectedAsync — disposes it and raises EngineRemoved. An HTTP endpoint therefore resolves an engine through the non-creating GetEngine; creating one for an ID that has already disconnected would orphan an engine no disconnect can ever clean up. Disp/StlPreviewService.cs subscribes to EngineRemoved to release the per-connection native topology the engine itself does not own. Frame Encoding The frame encoding is negotiated at initialization. InitializeCanvasV2(width, height, formats) with jpeg in the accepted list selects SkiaSharp JPEG frames delivered on ImageUpdateV2 at an adaptive quality — interactive frames compress harder and a still frame refines once — and adding png lets that refine be encoded lossless. A browser without createImageBitmap, or a server that does not carry the V2 method, falls back to InitializeCanvas and the gzip-RGBA frames delivered on ImageUpdate. Connection ID Naming Convention One value carries two names on the frontend: renderingConnectionId — the parameter name used throughout the API wrappers under wwwroot-src/src/api, and the route-parameter name on most display controllers renderingConnId — how the Execution page holds it (wwwroot-src/src/pages/ExecutionPage.vue), filled from the canvas's @server-initialized and passed to the typed wrappers in wwwroot-src/src/api/execution.ts, whose parameter is renderingConnectionId Data Flow Architecture Frontend Responsibilities The component owns the connection and its reconnect schedule, forwards pointer, wheel, key, touch, resize and visibility events to the hub, and paints each frame as it arrives. A canvas the layout has hidden keeps its connection open and tells the engine to pause rendering instead, so a hidden canvas costs nothing while a simulation runs. Backend Integration Rendering and frame encoding happen on the server; a controller decides only what the engine shows, by resolving the engine from the connection ID and assigning its displayee. That is why any feature can put its own content on a canvas without touching the transport. Example: Execution Controller File: Execution/ExecutionController.cs Method: InitializeExecution (POST /api/Execution/initialize/{connectionId}) Purpose: resolves the engine with RenderingService.GetEngine(connectionId) and assigns the Execution displayee to it Six further controllers bind content the same way — the STL preview, the Tool House, the General Setup equipment, the machine tool, the Mech Builder general mechanism and the Controller page — each with its own route and its own displayee, all reaching the engine through the same connection ID. Key Points Every canvas data-stream operation is indexed by the connection ID. Rendering and frame encoding happen on the server; the frontend owns the connection, the input events and the painting of received frames. The engine is created and destroyed with the hub connection, so anything else that holds per-connection resources releases them from EngineRemoved. Source Code Path See HiNC App Anatomy for git repository links. Web Service Source Code Path Disp/RenderingHub.cs — the hub: creates the per-connection engine, encodes and pumps frames, handles mouse, wheel, key, touch, resize and visibility, and disposes the engine on disconnect. Disp/RenderingService.cs — the singleton holding the per-connection maps, the playback render throttle and the EngineRemoved event. Disp/StlPreviewService.cs — the EngineRemoved subscriber that frees the File Explorer preview's native topology. Program.cs — registers SignalR and maps the hub at /renderingHub. Execution/ExecutionController.cs — the worked example above: InitializeExecution assigns the Execution displayee to the engine named by the connection ID. Disp/StlPreviewController.cs — binds an STL preview to a canvas (api/stl-preview). Mech/ToolHouseDisplayController.cs — the Tool House canvas binding (api/mech/tool-house-display). Mech/EquipmentSetupDisplayController.cs — the General Setup canvas binding (api/mech/equipment-setup-display). Mech/MachineToolDisplayController.cs — the machine-tool canvas binding (api/mech/machine-tool/display). Mech/MechBuilder/GeneralMechanismDisplayController.cs — the Mech Builder canvas binding (api/general-mechanism/display). Controller/ControllerController.cs — the Controller page's canvas binding (initialize-display/{connectionId}). Web Page Application Source Code Path wwwroot-src/src/components/RenderingCanvas.vue — the client half: one hub connection per instance, encoding negotiation, frame painting, input forwarding and the reconnect loop. wwwroot-src/src/components/RenderingCanvasToolBar.vue — the view-control bar bound to one canvas instance through its exposed methods. wwwroot-src/src/pages/ExecutionPage.vue — mounts the main canvas, stores the ID as renderingConnId and initializes the Execution content from @server-initialized. wwwroot-src/src/api/execution.ts — the typed wrappers whose renderingConnectionId parameter addresses that canvas. wwwroot-src/src/components/execution/StepVolumePanel.vue — a second canvas on the Execution page, with its own connection and its own engine. wwwroot-src/src/components/mech/EquipmentSetupPanel.vue — the General Setup page's canvas column. wwwroot-src/src/components/toolhouse/ToolHouseSetupPanel.vue — the Tool House page's canvas column. wwwroot-src/src/components/StlPreviewPane.vue — the File Explorer STL preview canvas. See Also RenderingCanvas Tool Bar — the View menu that drives the hub, and the Scene menu beside it Program and Hosting — the host that maps this hub and registers the services behind it STL Preview Pane — the one caller that opens a rendering connection outside a project"
  },
  "anatomy/conventions/translation-remarks.html": {
    "href": "anatomy/conventions/translation-remarks.html",
    "title": "Translation Remarks | HiAPI-C# 2025",
    "summary": "Translation Remarks Terminology is a contract: one concept keeps one word on every screen and in every locale. Three locales ship together — en, zh-Hant and zh-Hans — and the English bundle is the schema the Chinese bundles are typed against, so a key missing from a Chinese locale is a build error. The readings below are the ones the zh-Hant bundle ships. Tool House and Mechanism Terms Anchor 錨點 Tool 刀具 Cutter 刀具本體 Insert-End Cutter 刀片式刀具本體 Holder 刀把 Cylindroid Holder 柱狀刀把 Freeform Holder 任意形刀把 Shank 刀柄 Fixture 夾具 Milling Cutter 銑刀 Freeform Remover 任意移除工具 Flute 刀刃 Flute Profile 刃包絡形 Flute Contours 刃雕 Baseline Contour 基準刃雕 Side Contour 側向刃雕 Bottom Contour 底部刃雕 Upper Beam 夾持柱 Integral Mode 刀頭形式 Solid End 一體式 Insert End 刀片式 Preset 預設 Datum Preset 基準點預設 General Config 一般組態 — the mission tree's label for the presetting command kind Meshed Geometry 網格幾何 Machining Resolution 加工解析度 Words That Carry More Than One Sense Contour is the sharpest case: in the cutter namespace it is 刃雕 (Flute Contours 刃雕, Baseline Contour 基準刃雕), and in the spindle-capability namespace it is 等值線 (Power Contours 功率等值線, Torque Contours 扭矩等值線). Each sense keeps its own entry rather than one compromise word. Fluting is a cutter's whole set of flute contours — one shared baseline or one per flute — and translates as 刃雕構型: Uniform Fluting 對稱刃雕構型, Free Fluting 自由刃雕構型. Program is the UI-layer word and does translate: 程式 in zh-Hant, 程序 in zh-Hans. Control in the frontend names the Control Tree UI, 控制樹, and never takes 程式. Never Translate HiNC · hincproj · SoftNc · MachiningStep · brand names (Fanuc, Heidenhain, Mazak, Siemens, Syntec) · NC codes (G54, M128, CYCLE800, TRAORI, RTCP, TCPM) · file extensions and MIME-ish strings (STL, *.hincproj) · units (mm, rpm, mm/min, N, Nm, kW, KB, MB, GB) · the keyboard shortcuts embedded in tooltip sentences · route names, enum keys, localStorage keys and series identifiers — anything a machine compares. Language self-names (English, 简体中文, 繁體中文) stay in their own language in every locale. The full list lives with the bundles, in the i18n folder's README. A Choice That Carries No Label The cutter's integral mode reaches the web application as the integralMode datum rather than as a named field: it decides whether the Tool House material section offers a separate shank material, and shows no label of its own. A term with no visible string is still part of the contract — it has to be settled before anything renders a value derived from it. Source Code Path See HiNC App Anatomy for git repository links. wwwroot-src/src/i18n/en/toolhouse.ts and wwwroot-src/src/i18n/zh-Hant/toolhouse.ts — the Tool House control-tree node names and editor labels: Cutter, Holder, Flute Profile, Flute Contours, Upper Beam, and the cutter and holder types. wwwroot-src/src/i18n/en/mech.ts and wwwroot-src/src/i18n/zh-Hant/mech.ts — the General Setup rendering flags and the anchor labels. wwwroot-src/src/i18n/en/tree.ts and wwwroot-src/src/i18n/zh-Hant/tree.ts — the shared control-tree node names and the mission command kinds. wwwroot-src/src/i18n/zh-Hant/mission.ts — the PreSetting command fields, including Machining Resolution and the meshed-geometry file picker. wwwroot-src/src/i18n/zh-Hant/controller.ts and wwwroot-src/src/i18n/zh-Hant/softNc.ts — the Datum Preset tab, its table, and the runner's datum-preset row. wwwroot-src/src/i18n/zh-Hant/execution.ts — the Execution rendering flags, where Meshed Geometry and Fixture appear together. wwwroot-src/src/i18n/index.ts — createI18n(), applyLocale() and SUPPORTED_LOCALES, the only place a locale switch happens. wwwroot-src/src/i18n/schema.ts — the English bundle as the schema that types the Chinese ones. wwwroot-src/src/i18n/glossary.yaml — generated data, never imported by the application: the harvested legacy corpus with an adjudicated head term per concept, used to settle a reading before it is written into a bundle. See Also Language Selection SubMenu — the sub-menu that switches the locale these terms are written for Internationalization — the bundle layout these terms are written into, and the lint that holds them to it"
  },
  "anatomy/conventions/webapi-hub-cleanup-pattern.html": {
    "href": "anatomy/conventions/webapi-hub-cleanup-pattern.html",
    "title": "Webapi with Hub-Cleanup Assistance Pattern | HiAPI-C# 2025",
    "summary": "Webapi with Hub-Cleanup Assistance Pattern any of the index key should be registerForCleanup. i.e. any of indexXxx should follow the registerForCleanup. clean the indexed key which indexed by the host component in beforeUnmount. And so that the component doesn't clean the key that doesn't create by the component itself. The hub is not a second, redundant path that would make this web-api cleanup a mere demonstration. Common/CleanupHub.cs keeps its key registry in an ordinary instance property, and SignalR builds a fresh hub instance for every invocation, so the entry Add records is discarded with the instance that received it and OnDisconnectedAsync always walks an empty registry. The index-remove calls wwwroot-src/src/composables/useCleanupHub.ts makes — on unmount and on every key replacement — are the only ones that actually free a key, which is why registering a key without releasing it there leaks it for the life of the process. Notice before current key modified, the previous key should be called this.cleanupKey. A twin key should be made from the outside key to keep the lifecycle maintained."
  },
  "anatomy/execution/cycle-line-charts.html": {
    "href": "anatomy/execution/cycle-line-charts.html",
    "title": "Cycle-Line Charts | HiAPI-C# 2025",
    "summary": "Cycle-Line Charts The cycle-line charts visualise a per-step, per-cycle detail view of force / moment signals around the currently-selected step. They are re-fetched whenever the step selection changes, so the operator can zoom into one spindle revolution (or the configured cycle window) while scrubbing through the mission timeline on the strip charts. They sit in the Step Info column of the Execution Page, below Step Properties and CWE. The anatomy covers four, all sharing BaseCycleLineChart.vue, in the order the column stacks them: Chart Source Data Cycle parameter Notes Sim Cutting Force Cycle MachiningStep.ForceToWorkpieceOnProgramCoordinate or ForceToToolOnToolRunningCoordinate spindle angle (deg) Header dropdown picks between the two flag values; swaps the fetcher prop so BaseCycleLineChart refetches. Sim Spindle Moment Cycle MachiningStep.MomentsToToolAboutObservationPointOnSpindleRotationCoordinate_Nm spindle angle (deg) Simulated moment from the physics model. Carries the locus (dartboard) mode. Sensor Cutting Force Cycle IForceShot via TimeMapping.GetShots(stepIndex) time (s) Dynamometer-measured force. Returns an empty shape when there is no dynamometer data. Sensor Spindle Moment Cycle IMomentShot via MachiningProject.TimeMapping.GetShots(stepIndex) time (s) Sensor-measured moment. Rendered as a sibling card to the sim chart rather than a twin overlay, which keeps the two uplot instances independent. Carries the locus (dartboard) mode. The parameter split is the reason the two pairs never share a cursor: a simulated cycle is indexed by phase, a measured one by clock. Key Model: MachiningProject.TimeMapping + the selected MachiningStep. Layout Each cycle-line chart is a collapsible panel: Header Row Title label. Flag picker (Sim Cutting Force chart only) — a <q-btn-dropdown> between ForceToWorkpieceOnProgramCoordinate (default) and ForceToToolOnToolRunningCoordinate. Mode picker (enableLocus charts only — the two spindle-moment charts) — Line / Dartboard. Value-boundary dropdown — Auto, or Fixed with a ± bound that pins the y range symmetrically so two steps can be compared without the axis moving. Its label reads the bound when one is set. Reload. Body — UplotChart.vue rendering three series (X / Y / Z channels) over the cycle parameter ts, or XyLocusChart.vue in dartboard mode, which plots the same samples as a locus in the plane. The line-mode legend width is shared by every line-mode cycle chart, as the strip charts share theirs; the locus view has no legend divider and is unaffected. Empty-state overlay — No step selected with nothing picked, Not ready before the payload arrives, No data for step when the step carries none. The underlying series still carry a shape-preserving ts=[0,360], xs/ys/zs=[NaN,NaN] payload so the canvas does not jump. The two sensor charts read No data for step for every step of a project with no TimeMapping shot data, which is the normal state of a project that has not been measured. Behavior Step-driven refetch. BaseCycleLineChart accepts a fetcher: () => Promise<CycleLineResponse> prop. The step-selection push arrives on /clStripHub as StepSelected; the fetcher is re-invoked and the chart re-renders. Server-resolved step. The cycle-line endpoints resolve “currently-selected step” from LocalProjectService.ClStrip.GetSelectedPos() rather than accepting stepIndex as a query parameter. This keeps the contract simple and matches the event-driven model used by the rest of the execution plumbing. Toolbar slot. The optional #toolbar slot lets callers embed per-chart controls (such as the force chart's flag picker) without subclassing. Shared cursor mark, in two groups. Clicking a point publishes that sample's cycle parameter — not its index — to a module-scoped mark shared by the group: sim for the two simulated charts (spindle angle), sensor for the two measured ones (seconds). Each chart draws the mark as a vertical line in line mode and a highlighted point in dartboard mode, and the mark survives both a mode switch and a change of selected step. The split is deliberate: a click on a simulated chart must not move a sensor-side cursor, because the two axes are not the same quantity. The sim mark reaches outside the chart family. The CWE panel of the Execution Page's Step Info column watches it and pushes the angle to its own displayee, so the flute overlay in the engagement view rotates to the phase clicked on a force or moment chart. The angle persists on that displayee across steps — the server re-applies it with each step's spin direction — so it is pushed only on (re)connect and on a new click. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/execution/charts/BaseCycleLineChart.vue — shared cycle-line skeleton. wwwroot-src/src/components/execution/charts/UplotChart.vue — uplot wrapper (shared with the strip charts). wwwroot-src/src/components/execution/charts/XyLocusChart.vue — the dartboard (locus) renderer used in place of the uplot chart in that mode. wwwroot-src/src/composables/useCycleSyncMark.ts — the two module-scoped cursor marks and their group keys. wwwroot-src/src/components/execution/StepVolumePanel.vue — the CWE panel that follows the sim mark to rotate its flute overlay. wwwroot-src/src/components/execution/charts/ForceCycleLineChart.vue — force cycle-line chart with the flag picker. wwwroot-src/src/components/execution/charts/SimSpindleMomentCycleLineChart.vue — simulated spindle moment. wwwroot-src/src/components/execution/charts/SensorSpindleMomentCycleLineChart.vue — sensor-measured spindle moment. wwwroot-src/src/components/execution/charts/DynamometerForceCycleLineChart.vue — dynamometer force. Execution/ExecutionChartsController.cs — cycle-line endpoints: GET /api/execution/cycle-line/force?flag=ForceToWorkpieceOnProgramCoordinate|ForceToToolOnToolRunningCoordinate GET /api/execution/cycle-line/sim-spindle-moment GET /api/execution/cycle-line/sensor-spindle-moment GET /api/execution/cycle-line/dynamometer-force All four endpoints return { hasData, ts, xs, ys, zs } flattened for direct uplot consumption. Empty payloads use a shape-preserving ts=[0,360], xs/ys/zs=[NaN,NaN] fill. See Also Execution Page — the page whose Step Info column hosts these charts Strip Charts — windowed mission-timeline charts that share the same uplot engine and drive step selection Inspecting a Step — the task these charts serve, with the two scales and the shared mark read as a procedure"
  },
  "anatomy/execution/execution-extended-renderingcanvas-tool-bar.html": {
    "href": "anatomy/execution/execution-extended-renderingcanvas-tool-bar.html",
    "title": "Execution Extended RenderingCanvas Tool Bar | HiAPI-C# 2025",
    "summary": "Execution Extended RenderingCanvas Tool Bar The run-specific half of the canvas header on the Execution Page: what the scene shows, and how the tool path is drawn. The generic view controls live next to it on the RenderingCanvas Tool Bar. The model of the tool bar is DispEngine, assigned from the RenderingCanvas of the Execution Page. The content of Displayee here is the project displayee, whose key content is MachiningProject. Layout Execution Extended RenderingCanvas Tool Bar Tool Path — shows or hides the CL strip. Path Points — the CL-strip dot markers. Editable only while ClStrip is set in the displayee's rendering-flag bit array. Scene ▾ — RenderingFlag-based checkboxes over that same bit array, in three groups: Solid — Machine, Tool, Workpiece, Fixture Coordinate — Program Zero, ISO Coordinate, Heidenhain Coordinate Display Aids — Dimension Bar, Color Scale Bar The ClStrip flag is not offered here; the Tool Path button owns it. Heidenhain Coordinate appears only when MachiningProject.NcEnv.CncBrand is Heidenhain. The menu is a shared component because other screens use it too — see the Legacy Controller Page. Meshed Geom ▾ — the workpiece's rendering cache and geometry-diff settings: the Graphic-Cache SubMenu and Diff Visual Radius, with a Diff badge when a difference is present. Fit View is not on this tool bar. It moved to the strip-chart group bar, which is where the whole-program time axis it fits against lives; see Strip Charts. Shipped Default Flags The displayee opens with four bits set — DimensionBar, WorkpieceGeom, Fixture and ClStrip — so a page that has just loaded draws the workpiece, the fixture, the dimension bar and the tool path, and draws neither the machine nor the tool until the operator ticks them. Mech is present in the initializer as a commented-out line rather than absent, so the default is a decision rather than an omission: a machine at its home view fills the frame and hides the cut. The flags live on the displayee, not in the project, so they are session state and every new rendering session starts from this set. Tip The checkboxes in the Scene ▾ menu are grouped by the category of RenderingFlag — follow the link for the categories. Behavior of the Tool-Path Buttons Apply the displayee's rendering-flag bit array to set the project rendering items. Tip Extract the MachiningProject from the project displayee and use it to drive the behaviors. Behavior of the Scene Menu See the DemoRenderingMachiningProcessAndStripPosSelection sample in the Hi.Sample.Wpf repository for code that completes the behavior of the buttons. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/execution/ExecutionExtendedToolBar.vue — the tool bar itself. wwwroot-src/src/components/widgets/DisplayOptionsMenu.vue — the shared Scene ▾ menu. wwwroot-src/src/components/preference/GraphicCacheMenu.vue — the Graphic Cache entry under Meshed Geom ▾. Execution/ExecutionController.cs — GET /api/Execution/cl-strip-dots and POST /api/Execution/update-cl-strip-dots. Common/RenderingFlagsController.cs — the rendering-flag reads and writes behind the Scene ▾ checkboxes. See Also Execution Page — the page whose canvas this tool bar decorates RenderingCanvas Tool Bar — the generic view controls beside it Strip Charts — where Fit View now lives Watching the Run — the task these controls serve, and what the canvas draws by default"
  },
  "anatomy/execution/execution-tool-bar.html": {
    "href": "anatomy/execution/execution-tool-bar.html",
    "title": "Execution Tool Bar | HiAPI-C# 2025",
    "summary": "Execution Tool Bar The transport controls for the run. In the web application they sit atop the Execution Page's primary editor panel, shown for the Execution root and every node under it, and this sole instance registers the F5–F8 shortcuts. Layout Execution Tool Bar Status Text Field Start Button (F5; Resume once the run is paused) Pause Button (F6) Run-One-Line Button (F7 — one NC line) Run-One-Step Button (F8 — one machining step) Stop Button Reset Button In the web application the status text moved out of the tool bar and onto the Execution tree item, which carries the run-state badge. The two single-advance buttons there share one skip_next icon and are separated by a letter drawn into the button's corner — L for the line button, S for the step button — rather than by colour; the tool-tips carry the key names. Behavior The webservice watches LocalProjectService events to track PacePlayer status changes. In the webservice, ExecutionStatusService subscribes to those events and broadcasts status changes over SignalR through ExecutionStatusHub. The frequently used buttons carry hotkeys: Start / Resume, Pause, Run One Line and Run One Step. The app's tool-tips are the only place those key bindings are written down. The background color of the Status Text Field follows the status: Warning style — Running Secondary style — Paused, No Project Success style — Finished, Ready The action of Reset Button is async, so the UI stays responsive while the session unwinds; the button shows a busy state for the duration, and the flag behind it is shared with the keyboard path so the two agree. Enable Rules Every button is disabled unless a project is loaded and the page has finished initializing its rendering connection — the web transport reads that readiness from the Execution page, so a dropped canvas connection greys the whole bar with a project still open. On top of that gate each button follows the status: Button Enabled for status Start / Resume Ready, Paused Pause Running Run-One-Line, Run-One-Step Ready, Paused Stop Running, Paused, Finished Reset any, while no reset is in flight Neither single-advance button is enabled while the run is Running — stepping is a Ready-or-Paused operation, so a moving run has to be paused before it can be stepped. The F5–F8 handler applies the same predicates before acting, and declines in two more cases: when the event target is an input, a textarea or a contenteditable element, and when the hosting page is deactivated. The second matters because the shell keep-alives the routed pages, so leaving the Execution route deactivates rather than unmounts this component; without the detach, F5 elsewhere in the app would drive the transport instead of reloading the browser. Every declined key falls through to the browser. Tip Use icons rather than text on the tool-bar buttons. Run One Line and Run One Step share an icon, so they need a second mark to tell them apart — this bar draws an L and an S in the button corner. The default colour is enough for the rest. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/execution/ExecutionToolBar.vue — the buttons. All state and handlers come from the shared useExecutionTransport composable, so the component is pure markup. Execution/ExecutionController.cs — POST /api/Execution/start | pause | resume | run-line | run-step | stop | reset, and GET /api/Execution/status. Execution/ExecutionStatusHub.cs + Execution/ExecutionStatusService.cs — the status broadcast. SignalR Implementation (Web Service Only) ExecutionStatusHub is mapped at /executionStatusHub and answers GetExecutionStatus(). ExecutionStatusService watches the PacePlayer events — IsRunningChangedEvent, IsLockedChangedEvent, IsFinishedChangedEvent and ResetedEvent — and broadcasts each change, so every connected client sees the same run state without polling. See Also Execution Page — the page these controls drive Starting and Stepping — the task these controls serve, with the enable rules read as a procedure"
  },
  "anatomy/execution/graphic-cache-menu.html": {
    "href": "anatomy/execution/graphic-cache-menu.html",
    "title": "Graphic-Cache SubMenu | HiAPI-C# 2025",
    "summary": "Graphic-Cache SubMenu Shipped Surface The panel has no route and no Control-Tree node of its own. It is chrome on the Execution page (/execution): the canvas panel's expansion header carries the Meshed Geom ▾ dropdown — titled Workpiece rendering cache and geometry-diff settings — whose Graphic Cache row opens this panel in a nested menu. It hangs there because it acts on the workpiece meshed geometry's rendering cache, and its sibling row in the same dropdown is Diff Visual Radius. It is therefore only reachable while the Execution page's canvas column is shown. The panel is self-contained: it takes no parent-supplied model. It holds local lower / upper / current values, loads them on mount, and commits each edit to GET/POST /api/preference/graphic-cache. UserService / UserConfig is the server-side model behind that endpoint. Layout Titled Graphic Cache (MB), with the caption “Memory budget for rendering cache. Lower & upper bound the slider.” Graphic-Cache SubMenu Lower numeric field (unit MB) Upper numeric field (unit MB) Current numeric field (unit MB) Slider Behavior There is no apply step and no Save button: each field posts its own value the moment it is committed — on blur, or on Enter — and the whole panel is loaded once when it is mounted. The Current field is bounded by the two limit fields, so a value below Lower or above Upper is refused with an inline message and never sent. The server clamps a submitted value into the limits regardless, and the panel re-applies the effective state that comes back, so the server's answer is always what ends up on screen. The slider is integer-valued and reflects Current in MB. Its range tracks Lower / Upper, clamped defensively so the minimum never exceeds the maximum. Releasing the slider commits the value. A failed write shows the message inline under the fields, raises a notification, and re-reads from the server so the panel never drifts from stored state. A write lands on the live user configuration, so it takes effect at once — GraphicCacheMb is a pass-through onto CubeTree.DispCacheMb. All three values are part of the user-config XML, so they reach disk with the next save of that config. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/preference/GraphicCacheMenu.vue — the panel itself: Lower / Upper / Current numeric fields plus the slider. Loads on mount, commits each edit to the REST endpoint, re-applies the server's clamped response, and reports failures inline plus a notification. wwwroot-src/src/components/execution/ExecutionExtendedToolBar.vue — where the entry hangs: the Meshed Geom ▾ dropdown on the Execution page canvas panel's expansion header, whose Graphic Cache row opens this panel in a nested menu. wwwroot-src/src/components/workpiece/WorkpieceDiffRadiusMenu.vue — the sibling Diff Visual Radius row in the same dropdown. wwwroot-src/src/components/widgets/NumericInput.vue — the shared numeric field used for all three values. wwwroot-src/src/api/preference.ts — getGraphicCache / setGraphicCache over GET/POST /api/preference/graphic-cache, typed as { lowerLimit, upperLimit, value }. Environments/PreferenceController.cs — GetGraphicCacheSettings returns { success, lowerLimit, upperLimit, value }; UpdateGraphicCacheSettings takes the same three as nullable fields, clamps value into the limits, writes the live UserConfig, and returns the effective state. Environments/UserConfig.cs — GraphicCacheLowerLimitMb (default 10) and GraphicCacheUpperLimitMb (default 1200) are plain stored values; GraphicCacheMb is a pass-through whose getter and setter are CubeTree.DispCacheMb. All three round-trip through the config XML. See Also Preference Menu Dropdown — the sibling entries of the same dropdown"
  },
  "anatomy/execution/index.html": {
    "href": "anatomy/execution/index.html",
    "title": "Execution Page | HiAPI-C# 2025",
    "summary": "Execution Page The Execution page is the run cockpit: the simulation plays here, and every panel on it reads the run. It is the app's landing route — / redirects to /execution — and its Control Tree, the Execution root with Mission and Program beneath it, rides the ?tree= query, so /execution?tree=execution/mission deep-links the Mission editor. Note The app says Execution throughout: the route /execution, the REST endpoints (/api/Execution/*), the status hub (/executionStatusHub) and the stored layout (UserConfig.ExecutionDivConfig). The HiAPI engine keeps its own library vocabulary — PlayerCommand (API) and PacePlayer (API) — which is a different codebase's naming, not an inconsistency here. Key Models LocalProjectService — the project data service the whole page reads. MachiningProject — reached through the displayee bound to the canvas. UserService — per-user configuration, including the stored panel layout. Layout Four columns, left to right. The two dock dividers are pixel-sized, so dragging one moves only that dock's edge while the flexible middle absorbs the change. Left dock — the Control Tree over the primary editor panel for the selected tree node. The Execution Tool Bar — the transport buttons — sits atop that panel and is shown for the Execution root and every node under it. Main — the RenderingCanvas over the Session Message Panel, stacked as collapsible panels with a draggable divider between them. The canvas panel's header adopts the RenderingCanvas Tool Bar and the Execution Extended RenderingCanvas Tool Bar. Strip Charts — the strip-chart group bar over the three Strip Charts: Availability Chart, Surface Roughness Chart and Color Index Time Chart. Step Info — Sentence Syntax as its own region (an NC sentence need not map to any machining step, so it is not a member of the step-based panels), then the Step Info group bar, then Step Properties, CWE (cutter–workpiece engagement) and the four Cycle-Line Charts. The four columns are toggled from the app menu bar; the panels inside them collapse in place from their own expansion headers. The canvas stays mounted while collapsed so its rendering connection survives, and its engine is paused rather than torn down. The page itself also stays mounted while the user is on another route: the shell wraps the router view in a keep-alive keyed on the project epoch, so navigating away pauses the canvas but keeps the page — and its connection — alive until the loaded project changes. Control Tree The page hosts an execution-scoped Control Tree: an Execution root with the Mission branch above the Program branch. Selecting a node fills the primary editor pane below the tree, and the Execution Tool Bar is mounted on top of that pane whenever the selected id is execution or starts with execution/ — so the transport stays reachable from every node of this tree. Execution root is the cockpit's home: a short orientation panel, because the controls it would otherwise hold live where they act — the transport on the primary pane's header, the panel switches on each panel's own expansion header, the column switches on the nav bar. The live run state rides the tree itself: the Execution tree item carries a status badge fed by /executionStatusHub. Mission (execution/mission) is the editable command list a run executes — the project's PlayerCommand (API), always a list, with nested lists read as sub-trees. Its ItemType registry supplies the tree checkbox that decides whether a command runs. The branch root is the entry-list editor — Add Command over a drag-reorderable row list with up / down / duplicate / delete — each command entry gets a control bar over that kind's own editor, and each of the kind's remaining setting groups becomes a section child of the command node. Every command type has its own page under Mission. Program (execution/program) is the read-only inspection twin of Mission: one node per NC source file the session read, its passes and execution marks filled in from run data rather than typed in. Its nodes, its per-pass line and mark views, and the status changes that rebuild it are on Program Branch. Selection and URL are synced two ways through the tree query argument: the URL's ?tree= is adopted once the tree is built, and every selection change replaces it. A ?tree= id belonging to another page's tree redirects to that page (routeForTreeId), and /mission lands on /execution?tree=execution/mission. RenderingCanvas Behavior The canvas is split across the two sides: the browser component owns a canvas element and its connection, the server owns the displayee. The browser component opens a SignalR connection to /renderingHub and streams frames. It holds no displayee of its own. POST /api/Execution/initialize/{connectionId} resolves that connection's engine on the server, binds ProjectDisplayeeService.ExecutionDisplayee to the engine's DispEngine.Displayee unless one is already bound there, and snaps the camera to the home view through SetViewToHomeView(). The displayee receives project data from LocalProjectService. The connection is per rendering session, so a collapsed canvas keeps its connection and only stops drawing; the engine is paused while the panel is collapsed or the page is off-screen. Isometric is one of the view presets the user picks from the RenderingCanvas Tool Bar — alongside front, back, right, left, top and bottom — not the load-time view. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): Page, routing and Control Tree: wwwroot-src/src/pages/ExecutionPage.vue — the routed page at /execution: the four columns, their pixel / ratio splitters, the panel-expansion stacks, and the execution-scoped Control Tree host it provides. wwwroot-src/src/router/routes.ts — the / → execution redirect, the execution route, and the /mission redirect to /execution?tree=execution/mission. wwwroot-src/src/router/treeRoutes.ts — routeForTreeId, which lands a ?tree= id on the page that owns that branch. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — the Control Tree state machine: buildExecutionRoot() builds the execution root holding execution/mission above execution/program, syncs ?tree=, and re-reads the Program branch whenever the broadcast execution status changes. wwwroot-src/src/components/controlTree/ControlTreeDock.vue — the left dock: the Control Tree row over the primary editor row. wwwroot-src/src/components/controlTree/ControlTreePanel.vue — the tree pane; carries the live execution-status badge on the Execution tree item. wwwroot-src/src/components/controlTree/PrimarySlavePanel.vue — the primary editor pane for the selected node; mounts the Execution Tool Bar on top whenever the selection is execution or a descendant. wwwroot-src/src/components/controlTree/ExecutionRootPanel.vue — the editor panel of the Execution root node. Mission branch: wwwroot-src/src/components/controlTree/missionItemTypes.ts — the branch's ItemType registry and the per-command enable ticks. wwwroot-src/src/components/controlTree/MissionRootPanel.vue — the entry-list editor of a list command, serving the branch root and every nested list. wwwroot-src/src/components/controlTree/MissionCommandSlavePanel.vue — the per-command editor host. wwwroot-src/src/components/controlTree/MissionSectionPanel.vue — one setting section of a command. Program branch (see the dedicated anatomy page for details): Program Branch — the branch's ItemType registry, its root, file and conversion panels, and the read-only endpoints behind them. Panels and canvas: wwwroot-src/src/components/RenderingCanvas.vue — the browser canvas and its /renderingHub connection. wwwroot-src/src/components/execution/ExecutionToolBar.vue — the transport controls. wwwroot-src/src/components/execution/ExecutionExtendedToolBar.vue — the view and rendering-flag controls adopted onto the canvas panel's header. wwwroot-src/src/components/execution/SelectedStepInfoPanel.vue — Step Properties. wwwroot-src/src/components/execution/StepVolumePanel.vue — the CWE panel. wwwroot-src/src/components/execution/SyntaxPiecePanel.vue — Sentence Syntax. wwwroot-src/src/components/execution/SessionMessagePanel.vue — the message panel and its four sink tabs. wwwroot-src/src/components/panels/PanelExpansion.vue and wwwroot-src/src/components/panels/ResizablePanelStack.vue — the collapse-in-place panels and their draggable heights. wwwroot-src/src/layouts/MainLayout.vue — the shell whose keep-alive wrapper, keyed on the project epoch, holds this page mounted across navigation. Charts (see the dedicated anatomy pages for details): Strip Charts — three uplot-backed strip charts driven by ClStrip. Cycle-Line Charts — four uplot-backed per-step charts. Shared chart primitives under wwwroot-src/src/components/execution/charts/: wwwroot-src/src/components/execution/charts/UplotChart.vue — thin uplot wrapper with ResizeObserver and reactive data / series / bands bindings. wwwroot-src/src/components/execution/charts/BaseStripChart.vue — strip-chart skeleton: min / max banded series, header aspect picker, wheel / drag / click pointer handlers. wwwroot-src/src/components/execution/charts/BaseCycleLineChart.vue — cycle-line skeleton that takes a fetcher prop and re-fetches when the step selection changes. Backends: Execution/ExecutionController.cs — POST /api/Execution/start | pause | resume | run-line | run-step | stop | reset; GET status, status/{connectionId}, project-status, selected-step-info and cl-strip-dots; the canvas actions initialize/{connectionId} (binds the displayee and calls SetViewToHomeView) and fit-view/{connectionId}; and the step-volume/{connectionId} family behind the CWE panel. Execution/ExecutionStatusHub.cs + Execution/ExecutionStatusService.cs — /executionStatusHub, the run-state broadcast that drives the transport and the tree badge. Execution/SessionSinkHub.cs + Execution/SessionSinkBroadcastService.cs — one hub per message sink (/shellMessageHub, /ncDiagnosticHub, /stepDiagnosticHub, /ncManipulationDiagnosticHub), so a client subscribes to exactly the sink it wants. Execution/SelectedStepInfoService.cs — the selected-step payload. It has no hub of its own: the “selection changed” push rides /clStripHub. Execution/ClStripController.cs + Execution/ClStripHub.cs + Execution/ClStripBroadcastService.cs — CL-strip range state and the zoom / pan / select / enter broadcasts. Execution/ExecutionChartsController.cs — the strip-chart and cycle-line-chart data endpoints under /api/execution. Disp/RenderingHub.cs + Disp/RenderingService.cs — the shared /renderingHub every page's RenderingCanvas connects to, keyed per rendering connection id. Disp/ExecutionDisplayee.cs — the server-side displayee bound to the connection's engine. Common/ProjectDisplayeeService.cs — owns the ExecutionDisplayee instance handed to the engine on initialize. Building an Equivalent Page Tip When building an execution cockpit on top of HiAPI: Create the layout with a RenderingCanvas. Set up the canvas behavior. Add the Execution Tool Bar. Add the Execution Extended RenderingCanvas Tool Bar with the CL-strip, fit-view and rendering-items behaviors. Reach the page from the navigation menu on Main Panel. Make it the landing page, with its tool bars. Build the Session Message Panel and the Selected-Step Info Panel, and put the button that opens the Step Present Dialog on the latter's title bar. Pages Ordered as the cockpit reads: the two tool bars across the top, the step column and the charts down the side, the menus and dialogs they open, then the Control-Tree branch the page hosts. Execution Tool Bar — The transport controls on the primary panel header, and the status they read Execution Extended RenderingCanvas Tool Bar — The run-specific canvas controls: the CL strip, fit view and the Scene menu Selected-Step Info Panel — The Step Properties panel in the Step Info column Strip Charts — The whole-program charts in the Strip Charts column Cycle-Line Charts — The per-step charts in the Step Info column Graphic-Cache Menu — The meshed-geometry cache limits, edited from the canvas header Step Present Dialog — The step-property presentation settings, opened from the Step Properties panel Mission — The command-list branch this page hosts, one page per command type Program Branch — The read-only inspection twin of Mission: one node per NC source file the run read, its passes and its execution marks See Also Execution Tool Bar — the transport buttons and their status feed Execution Extended RenderingCanvas Tool Bar — CL strip, fit view and the rendering-items menu Selected-Step Info Panel — the Step Properties panel in the Step Info column Strip Charts — the whole-program charts in the Strip Charts column Cycle-Line Charts — the per-step charts in the Step Info column Session Message Panel — the run log under the canvas RenderingCanvas Tool Bar — the view controls the canvas header adopts Main Panel — the shell that routes to this page Mission — the command-list branch this page hosts, one page per command type General Setup Page — the other Control-Tree page, and the equipment this run consumes Program Branch — the read-only inspection twin of Mission this page hosts below it Control Tree — the engine behind this page's tree, shared with General Setup Tree Ids and Routes — the ?tree= surface this page's selection rides on"
  },
  "anatomy/execution/mission/ListCommand-panel.html": {
    "href": "anatomy/execution/mission/ListCommand-panel.html",
    "title": "List Command Panel | HiAPI-C# 2025",
    "summary": "List Command Panel A ListCommand is the container command: an optional title plus a list of enable-wrapped commands. Running one walks CommandEntryList top-down and skips a disabled entry together with everything nested under it — the wrapper yields nothing while its flag is clear. The mission's own command is always a list, so the Mission branch root is a list, and every nested one is the same shape one level down. List is an ordinary catalog kind — category Flow — so a list is added the way any command is, and adding one grows a sub-tree: the node's children are its own entries, and its panel embeds the same entry-list editor the branch root uses, scoped to the nested list. This page covers what a list is, how its title reads, and what moving commands in and out of one costs. The entry-list editor itself — Add Command, the row actions, the three drag landings — is documented once, on Mission Root Panel. Key Models Primary: ListCommand — Title and CommandEntryList. Supporting: EnablingWrapper — one entry: Command plus IsEnabled. ITitleCommand — ListCommand implements it, and GetCommandTitle composes the label a row shows. PlayerCommand — the mission's command, a list. CommandCatalogAttribute and CommandCategory — what makes List addable, and the group it is offered under. The Panel of a List Entry Selecting a list command in the Control Tree opens, top to bottom: List Entry Panel Control Bar Up / Down / Duplicate / Delete — labelled buttons for the operations that rewrite the parent list. Delete asks for confirmation in a dialog naming the command. At the bar's left, a caption while the command is disabled: skipped during play, still editable. Title (optional) Input Embedded Entry-List Editor This list's own entries, scoped to the node's path. The Title input holds the raw title — empty when unset — while the label the row and the tree show is composed by the engine: List when the title is blank, List [title] when it is not. A titled list still says what it is. A whitespace-only title counts as unset and is never written into the project file, so it cannot come back as a changed title on the next load. Keystrokes debounce into one title save. The pending save is flushed before anything that shifts the entry paths — a structural operation, a duplicate, a selection change — and cancelled on delete and on unmount, so a late write cannot land on whichever command slid into the old path. Once it is saved the tree label refreshes in place rather than by rebuilding the branch, which would remount the open editor mid-edit. The root list is the one list without a title input: the branch root reads Mission. Enabling, and What a Disabled List Skips The enable switch is the checkbox on the command's own Control Tree item, not a control in the entry row. It decides only whether the command runs: while it is clear the row and the tree node dim, and the editor stays open and fully editable. Unticking a list dims its whole sub-tree — the dim rides ancestor propagation in the tree while each nested entry keeps its own flag, which is exactly what the run does: a disabled entry is skipped with everything under it. Paths A command node's key is its Mission API path — \"0\", \"1\", nested \"0.2\" for entry 2 inside the list at index 0. Every structural change re-mints them: deleting entry 2 slides the next command into path \"2\". Each branch build therefore stamps its nodes, so the editor panel remounts onto the new path instead of going on showing the command that used to live there. Moving Commands In and Out Into a list — drag a row onto the middle band of a list row; that row's outer quarters still reorder around it. Out of a list — drag onto the drop-out zone of a nested list's editor, which is visible only while a row inside that editor is being dragged. The entry lands right after the list command itself in the owning list. Both are the same reparent call. The server resolves the source list and the target list to object references before it mutates either, so the index shift the removal causes cannot misroute the insert, and it refuses to move a list into itself or into one of its own descendants. That guard compares identity rather than path-string prefixes, because \"02\", \"+2\" and \" 2\" all parse to index 2. Two more properties of a list follow from the same API: A new command lands at the end of the list it was added to, root or nested. Nothing is pinned; the order is entirely the user's, changed with the row's up / down buttons or by dragging. Duplicate is a deep copy. The entry is cloned through the same XML round-trip the project file uses, so a nested list copies with its whole sub-tree, and the clone lands right after the source. Dragging serves rearrangement only: a drag carrying text or files is ignored, because the row's drag handling returns as soon as the drag did not start on a row. To bring several program files in at once, open a Program File command's picker and pick them together — the first pick lands on that command and each further pick becomes another Program File command right after it, in pick order, inside the same list at any depth. Which Commands a List Can Hold The addable set is the server's command catalog: every engine command carrying [CommandCatalog], reflected into the picker Add Command opens, which searches by display label, kind key and alias. List is one of those commands, which is what makes nesting an ordinary act rather than a special case. The frontend contributes an icon per kind, and its own label where it has one; the server supplies the localized label otherwise, so a newly attributed engine command becomes addable with no frontend change. A command without that attribute stays loadable from a project file but is never offered for creation. General Config is the one such command with an editor of its own: it is the legacy settings bundle, so a project file storing one loads as the individual setting commands it stands for and saving never writes the bundle back — editable when a project still constructs one through the API, and absent from the catalog. Selecting an entry row selects that command's tree node, and the command's editor opens on that node — the kind's own panel when one exists, otherwise a generic editor built from the scalar fields the command declares. Selection is one row at a time: there is no multi-selection here, and every action acts on the row that carries it. Because the server composes every entry label, a command carrying no title of its own still reads as its localized display name. There is no second column inside this editor: the entry list is a single column in the tree's editor pane. The draggable vertical divider on screen belongs to the Execution page, between the left dock — the Control Tree over the editor panel — and the central area; a second divider inside that dock drags the height between the tree and the editor. Source Code Path See HiNC App Anatomy for git repository links. Web Application wwwroot-src/src/components/controlTree/MissionCommandSlavePanel.vue — a list entry's panel: the control bar, the optional Title input with its debounce / flush / cancel discipline, the embedded entry-list editor of a list entry, and the bespoke-or-generic editor choice for every other kind. wwwroot-src/src/components/controlTree/MissionRootPanel.vue — the entry-list editor embedded here and serving the branch root: the rows and their actions, the three drag landings, and the drop-out zone shown only during a drag inside a nested editor. wwwroot-src/src/components/controlTree/missionItemTypes.ts — the child builders that recurse into a list's own entries, the per-kind editor override map, the kind and category icons, and the per-build stamp that forces the panel remount. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — which nodes show a checkbox, the dim that flows down a disabled command's sub-tree, the enable write, and the in-place label refresh after a title edit or a language switch. wwwroot-src/src/api/mission.ts — the typed wrapper over the Mission API and the path convention (root or empty = the root list, 0.2 = a nested entry). wwwroot-src/src/components/mission/GenericCommandPanel.vue — the editor a catalog kind gets when it ships no bespoke panel, built from the command's declared scalar fields. wwwroot-src/src/components/mission/NcFileCommandPanel.vue — the multi-pick file dialog: the first pick lands on the command, each further pick becomes another Program File command right after it. wwwroot-src/src/pages/ExecutionPage.vue — the page-level splitter between the left dock and the central area. wwwroot-src/src/i18n/en/tree.ts — the tree.mission.* strings: the kind names, the drop-out zone, the run-order hint, the disabled hint and the operation labels. Missions/MissionController.cs — the entry lifecycle: GET list-command/entries (recursive), POST list-command/entries and POST list-command/entries/{path} (append at the tail of the root or of a nested list), DELETE list-command/entries/{path}, POST list-command/entries/{path}/move, PUT list-command/reorder, POST list-command/entries/{path}/duplicate (the XML-round-trip deep clone), POST list-command/entries/{path}/reparent (drag-into-list and drop-out, with the self/descendant guard), PUT commands/{path}/listcommand for the title, and PUT commands/{path}/enabled for an entry's enable flag. GetCommandTitle composes every entry label the tree shows. Missions/MissionCommandCatalog.cs — reflects the [CommandCatalog] commands into the addable set and constructs the picked kind. HiAPI Engine HiNc/SessionCommands/ListCommand.cs — the container: the optional title, the entry list a run walks top-down, the whitespace-only-title-is-unset XML rule, the Flow catalog attribute, and the List / List [title] composition. HiNc/SessionCommands/EnablingWrapper.cs — the enable flag plus the wrapped command that together make one entry. HiNc/SessionCommands/ITitleCommand.cs — the interface a command implements to compose its own title from the caller's vocabulary. HiNc/SessionCommands/CommandCatalogAttribute.cs — CommandCategory and the attribute (category, order, kind key, aliases) that makes the addable set backend-owned. HiNc/SessionCommands/PreSettingCommand.cs — the General Config bundle: no catalog attribute, and a loaded project expands a stored one into the split setting commands. HiNc/MachiningProcs/MachiningProject.cs — declares the mission's command and keeps it a list. See Also Mission Root Panel — the entry-list editor this command embeds, documented once Building a Mission — the task this command serves: grouping a mission and moving entries between groups Mission — the rest of the command panels"
  },
  "anatomy/execution/mission/NcCodeCommand-panel.html": {
    "href": "anatomy/execution/mission/NcCodeCommand-panel.html",
    "title": "NcCodeCommand Panel | HiAPI-C# 2025",
    "summary": "NcCodeCommand Panel The key model is NcCodeCommand. The command carries two values: NcText, the NC program itself, and Title, the name that program runs under. Both are written into the project file — the command emits a title element and an NC-text element, and the project nests the whole command list into its own XML — so the program travels with the project instead of existing as a file beside it. That is the whole difference from Program File, which stores a path and leaves the program on disk. A mission can therefore carry a short program without producing an artifact of its own. Title is not decoration. Run passes it to RunNc as the program name the run log shows, which is why the model defaults it to the command's own name, NC Code, rather than to an empty string. It is also the detail the mission row brackets: the row reads NC Code while the title is empty or still that default, and NC Code [title] once it says something else. The panel renders on the command's own node in the Mission branch of the Execution page's Control Tree, below the move / duplicate / delete control bar. A single-purpose kind like this one embeds its whole editor on that node rather than growing section child nodes. Layout NcCodeCommand Panel Title Field The model is Title. Labelled \"Title (optional)\". A newly added command arrives with the model's default name, NC Code, already in the field; renaming it renames the program in the run log and in the mission row. NC Code Editor Area The model is NcText. A plain monospace text area: an 18-row field with a 360 px floor. No line-number gutter and no syntax highlighting. The rich editor in this folder is the Script command's — that command ships CodeMirror with a C# grammar, this one ships a text area. Stats and Actions Row (web) Line count and character count, both recomputed as the text changes. Trim Blank Lines Button — trims every line and drops the ones left empty, then saves at once. Clear Button — confirms in a dialog before emptying the NC text. Both buttons stay disabled while the code is empty. Saving Typing in either field schedules one save 400 ms after the last keystroke, so a burst of typing costs one request instead of one per character. Trim Blank Lines and Clear save immediately rather than through that timer. The write is a single patch endpoint carrying the NC text and the title. Each field is applied only when the body actually carries it, which is why the client sends the field it changed and a null for the one it did not. NC text is not validated while it is edited: there is no parse at edit time and no error surface on the panel — the server stores whatever string arrives. Errors surface when the mission plays the text. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/mission/NcCodeCommandPanel.vue — this panel: the Title input, the 18-row monospace text area, the 400 ms debounced saves, the live line and character stats, Trim Blank Lines, and Clear behind a confirm dialog. wwwroot-src/src/components/controlTree/missionItemTypes.ts — maps the nccode kind to this panel, and states the rule it belongs to: a single-purpose kind embeds its whole editor on the command node. wwwroot-src/src/api/mission.ts — loadNcCode and setNcCode, and the command shape the panel edits (NC code plus title). wwwroot-src/src/i18n/en/mission.ts — the panel's wording: the NC Code label, the character count, Trim Blank Lines, and the line count it shares with the other panels. wwwroot-src/src/i18n/en/dialog.ts — the Clear confirmation's title and message. Missions/MissionController.cs — the single patch PUT for this command, whose NC-code and title fields are each applied when the body carries them, and the command-snapshot arm that returns both back to the panel. HiAPI Engine HiNc/SessionCommands/NcCodeCommand.cs — the model: NcText, Title defaulting to the command's own display name, the Program-category catalog registration, the XML round-trip that puts the NC text into the project file, Run handing text and title to the session shell, and the row-label rule that shows the bare name while the title is unset or still the default. HiNc/MachiningProcs/SessionShell.cs — RunNc takes the NC text plus an alternative file name, and that name is the title this command supplies for the log. HiNc/MachiningProcs/MachiningProject.cs — nests the command list into the project XML, which is how this command's NC text persists with the project. See Also NcFileCommand Panel — the other Program command: a path to a file instead of text stored in the project Script Command Panel — the rich editor this folder does have, and why this command ships a plain text area instead Playing a Program — the task these two commands serve Mission — the rest of the command panels"
  },
  "anatomy/execution/mission/NcFileCommand-panel.html": {
    "href": "anatomy/execution/mission/NcFileCommand-panel.html",
    "title": "NcFileCommand Panel (Program File) | HiAPI-C# 2025",
    "summary": "NcFileCommand Panel (Program File) The key model is NcFileCommand. The command carries exactly two values: NcFile, the path of the program to play, and NcKind, the runner that plays it. The program text stays a file on disk — the project stores the path and nothing else, which is what separates this command from NC Code, whose text is serialized into the project itself. NcFile is normally a path relative to the project folder — that is what the browse dialog yields — and an absolute path on the server is accepted just as well. No base directory is stored with the command: at play time RunNcFile hands the stored path together with the project's own base directory to the local project service, and that is where a relative path acquires its root; the convention behind it is the Load Pattern. The panel renders on the command's own node in the Mission branch of the Execution page's Control Tree, below the move / duplicate / delete control bar. This command has no title of its own, so the row and tree label read Program File [path], the path being the detail the label brackets. Note The GUI labels this command “Program File”: it plays NC, CL (CLSF) and CSV files — the runner is picked by NcKind, and Auto reads it off the extension (DetectByPath: .cl, .cls and .clsf play as CL, .csv as CSV, and every other extension as brand NC). Layout NcFileCommand Panel Head Line Program File Path Field The model is NcFile. Its hint names both accepted forms: an absolute path on the server, or a path relative to the project folder. Every keystroke saves the path. Leaving the field or pressing Enter additionally refreshes the file-info banner. The field flexes to fill the row beside the Browse button at any panel width. Browse Button Opens the shared file-explorer dialog — see Browsing for a Program. Play As Select The model is NcKind. Four choices: Auto (by extension), Brand NC, CL (CLSF) and CSV. The hint restates what Auto detects, so the runner can be pinned when the extension would route the file elsewhere. File Info Banner Appears once the path field is non-empty. Every fact in it is read on the server. Found: a green banner stating the file size, its modified stamp and its line count, with a Preview button in the banner's action slot. Missing: an orange banner saying the file is not found on the server, and no Preview button. Preview Dialog Read-only. The server returns the file's first 100 lines and the dialog shows them in a monospace block that scrolls within 60% of the viewport height, inside a card capped at 80%. An empty file previews as \"(empty)\". Browsing for a Program Browse opens the shared server-side file explorer dialog. File reads happen on the server; the browser never uploads file bytes. The Load Pattern's general web convention offers the Admin, Project and Resource roots. This picker narrows to one: it opens on the project directory and allows no other root, so a pick always yields a project-relative path. A file outside the project is reached by typing its absolute path into the path field, which the server accepts. The dialog carries four filter groups rather than one catch-all: NC Files — .nc, .anc, .tap, .eia, .mpf, .spf, .cnc, .ptp, .h. The open set: brand controller extensions, of which these are the common ones rather than all of them. CL Files — .cl, .cls, .clsf. CSV Files — .csv. All Files — an empty extension list, which is the empty filter the Load Pattern asks every browser to preserve. It is the backstop for a brand extension the NC group does not name. CL and CSV are split out because they are closed extension sets: those are exactly the extensions Auto routes to the CL and CSV runners, and everything else falls through to brand NC. Multi-Pick Fan-Out The dialog is multi-select, and this is the one command editor that grows the mission. The first picked file lands on this command. Each further pick becomes a new Program File command, added to the list this command sits in and moved into place directly after it, in pick order — the same list, so a command inside a nested list fans out inside that nested list. The panel then reports a structure change, which rebuilds the owning list's branch around the new rows and leaves the selection on this command. Where the Program Text Is Edited The command stores a path, and the panel does not edit the file. It assigns the path, picks the runner, reports what the server knows about the file, and previews its first 100 lines read-only. Nothing in the browser writes NC bytes back; the two file endpoints this panel calls are both reads. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/mission/NcFileCommandPanel.vue — this panel: the path field and Browse, the “Play As” kind select, the file-info banner and its Preview button, the read-only preview dialog, the four filter groups, and the multi-pick fan-out. wwwroot-src/src/components/widgets/FileExplorerDialog.vue — the shared server-side browser Browse opens: the pickable / multi / filters / initial-root / allowed-roots props, and the pick event whose emitted strings pair a root name with a relative path — that relative half is what the command stores. wwwroot-src/src/components/widgets/fileFilter.ts — the filter shape the four groups are built from; an empty extension list means all files. wwwroot-src/src/components/controlTree/missionItemTypes.ts — maps the ncfile kind to this panel. A kind absent from that map is served by the generic field editor instead. wwwroot-src/src/api/mission.ts — loadNcFile, setNcFilePath, setNcFileNcKind, getNcFileInfo and previewNcFile, plus the kind union and the file-info shape. wwwroot-src/src/i18n/en/mission.ts — the panel's wording: the path hint, the Play As hint, the four filter labels, the banner's found and not-found lines, and the preview titles. Missions/MissionController.cs — four endpoints serve this command: a PUT for the path, a PUT for the NC kind, and the two server-side reads behind the banner and the preview (both POSTs, both resolving a relative path against the project folder). The command-snapshot builder emits the file path and the NC kind for this kind of command. HiAPI Engine HiNc/SessionCommands/NcFileCommand.cs — the model: NcFile, NcKind defaulting to Auto, the “Program File” display name and its Program-category catalog registration, the XML round-trip that writes the path verbatim, the Program File [path] row label, and Run handing path and kind to the session shell. HiMech/MachiningProcs/NcKind.cs — the kind enum (Auto / BrandNc / Cl / Csv) and the detect-by-path helper, the authority for what Auto does. HiNc/MachiningProcs/SessionShell.cs — RunNcFile passes the stored path together with the project's base directory to the local project service. See Also NcCodeCommand Panel — the other Program command: NC text stored in the project instead of a path to a file Playing a Program — the task these two commands serve Mission — the rest of the command panels"
  },
  "anatomy/execution/mission/NcOptOption-panel.html": {
    "href": "anatomy/execution/mission/NcOptOption-panel.html",
    "title": "NC Optimization Option Panel (NC Optimization Config) | HiAPI-C# 2025",
    "summary": "NC Optimization Option Panel (NC Optimization Config) The key model is NcOptOptionCommand; the options it carries are a NcOptOption. The command exists so the optimizer's settings are a step in the mission rather than a global preference. Run assigns the command's option object onto the session shell — the whole body is sessionShell.NcOptOption = NcOptOption — so the settings take effect at the point the entry sits in the list. Everything played below it optimizes under them, and a second NC Optimization Config further down the list re-points them mid-mission. The command carries no title. Its row and its tree label always read NC Optimization Config: GetCommandTitle returns that fixed name and takes nothing from the user. Where It Renders The web client has one editor component for this command and mounts it once per tree node, each mount scoped to one group of options: The NC Optimization Config node itself carries the four enable checkboxes, below the move / duplicate / delete control bar every command node shows. The node grows five section children — Distances, Feedrate, Motion Dynamics, Force & Safety, Compensation — and each mounts the same component scoped to its own section. Unlike the General Config and Post-Execution sections, none of these five section nodes carries an enable checkbox: this kind declares no section enable flags, so the tree hides the tick on them. The command node's own checkbox is the only switch, and it only decides whether the mission runs the command — a disabled command is skipped during play and stays fully editable. Layout NC Optimization Config Node Enable Optimization CheckBox The model is EnableOpt. Enable Feedrate Optimization CheckBox The model is EnableOptFeedrate. Enable Depth Splition CheckBox The model is EnableDepthSplition. Enable Interpolation CheckBox The model is EnableInterpolation. Distances Section Extended Pre Distance Numeric Field (mm) The model is ExtendedPreDistance_mm. Extended Post Distance Numeric Field (mm) The model is ExtendedPostDistance_mm. Feedrate Section Min Feedrate Numeric Field (mm/min) The model is MinFeedrate_mmdmin. Max Feedrate Numeric Field (mm/min) The model is MaxFeedrate_mmdmin. Rapid Feed Numeric Field (mm/min) The model is RapidFeed_mmdmin. Min Feed Per Tooth Numeric Field (mm) The model is MinFeedPerTooth_mm. Max Feed Per Tooth Numeric Field (mm) The model is MaxFeedPerTooth_mm. Feedrate Assignment Ratio Numeric Field The model is FeedrateAssignmentRatio. Motion Dynamics Section Max Acceleration Numeric Field (mm/s²) The model is MaxAcceleration_mmds2. Max Jerk Numeric Field (mm/s³) The model is MaxJerk_mmds3. Force & Safety Section Preferred Force Numeric Field (N) The model is PreferedForce_N. The one field hinted \"Accepts Infinity.\", and the one field with no lower bound. Yielding Safety Factor Numeric Field The model is YieldingSafetyFactor. Thermal Yield Safety Factor Numeric Field The model is ThermalYieldSafetyFactor. Spindle Torque Safety Factor Numeric Field The model is MaxSpindleTorqueSafetyFactor. Spindle Power Safety Factor Numeric Field The model is MaxSpindlePowerSafetyFactor. Compensation Section Enable Forward Compensation CheckBox The model is EnableForwardCompensation. Enable Side Compensation CheckBox The model is EnableSideCompensation. Enable Depth Compensation CheckBox The model is EnableDepthCompensation. The three compensation switches are bit accessors over the model's compensation mask — forward is bit 0, side bit 1, depth bit 2 — so all three travel as one integer in the project file. Saving Every edit writes at once. There is no Save button and no dirty state: a checkbox saves on click, a numeric field saves when it loses focus or on Enter, and each write is one PUT for that one property. The value is applied locally first; if the request fails, the panel re-reads the whole command and raises a toast, so the field snaps back to what the server holds. The read side is a single command snapshot rather than one GET per property: the panel loads the command and takes its ncOptOption object. Two keys in that object drop the engine's Max prefix — the spindle torque and spindle power safety factors travel as spindleTorqueSafetyFactor and spindlePowerSafetyFactor. Infinity and Bounds Infinity is a legal value for Preferred Force and Max Feed Per Tooth, and those two are exactly the properties whose endpoints take a string body: the client sends the literal Infinity (or -Infinity), and the reader parses the same spelling back. Every other property's endpoint takes a typed bool or double. Every numeric field except Preferred Force is bounded at 0 — a smaller number is refused in the field with “Must be ≥ 0” and never reaches the server. Tip The engine's XML form parses these values through XmlConvert.ToDouble, which is why an infinite feed per tooth or preferred force survives a project save and reload. Defaults A freshly added command carries the option model's own initial values, so the panel opens on them: Option Default The four enable switches all on Extended Pre / Post Distance 2 mm Min / Max Feedrate 1 / 20000 mm/min Rapid Feed 20000 mm/min Min / Max Feed Per Tooth 0 mm / Infinity Feedrate Assignment Ratio 0.01 Max Acceleration / Max Jerk 10 mm/s² / 100 mm/s³ Preferred Force Infinity Yielding / Thermal Yield Safety Factor 0 Spindle Torque / Power Safety Factor 1.5 The three compensation switches all off The web client edits five more, and that is the whole difference between the two editors: Min Feed Per Tooth, Max Feed Per Tooth and Feedrate Assignment Ratio in the Feedrate section, and Yielding Safety Factor and Thermal Yield Safety Factor in Force & Safety. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/mission/NcOptOptionCommandPanel.vue — this panel. A section prop picks the one group it renders, a setter map routes each field to its API call, and a failed write re-reads the command and notifies. wwwroot-src/src/components/controlTree/missionItemTypes.ts — registers the ncoptoption kind's bespoke editor, declares its five section children, gives it the tune icon and the NC Optimization Config display name, and leaves it out of the section-enable readers and writers so its section nodes carry no checkbox. wwwroot-src/src/components/controlTree/MissionCommandSlavePanel.vue — the control bar above the command node's checkboxes. wwwroot-src/src/components/controlTree/MissionSectionPanel.vue — mounts this panel once per section node, scoped to that node's section. wwwroot-src/src/api/mission.ts — the option shape the panel edits, the reader that takes the ncOptOption snapshot and parses Infinity, and one setter per property over commands/{path}/ncoptoption/{endpoint}. wwwroot-src/src/components/widgets/NumericInput.vue — the field every non-boolean option uses: it commits on blur or Enter, spells infinity as Infinity, and enforces the minimum the panel passes. wwwroot-src/src/i18n/en/mission.ts — the option labels and the “Accepts Infinity.” hint. wwwroot-src/src/i18n/en/tree.ts — the kind name and the five section names the tree shows. Missions/NcOptOptionEndpoints.cs — a partial of the same MissionController: one PUT per editable property, two of them string-bodied so Infinity round-trips. Each creates the option object when the command has none, and answers a command-type mismatch when the path holds another kind. Missions/MissionController.cs — builds the command snapshot the panel reads, re-keying the two spindle safety factors onto their wire names, and owns the entry lifecycle — add, delete, move, duplicate, reparent — that puts this command in the list. HiAPI Engine HiNc/SessionCommands/NcOptOptionCommand.cs — the mission entry: the NC Optimization Config display name, its Optimization catalog registration, the single option property, the fixed command title, the XML round-trip that nests the options in the project file, and the Run that assigns them onto the session shell. HiMech/NcOpt/NcOptOption.cs — the option model: the engine-side names MaxSpindleTorqueSafetyFactor and MaxSpindlePowerSafetyFactor, the compensation booleans as bit accessors over one mask, and the mm/min feedrates as conversions over mm/s storage. See Also PostExecutionCommand Panel — where the optimized programs are written out, under the settings this command puts in force The Other Commands — the task this command serves Mission — the rest of the command panels"
  },
  "anatomy/execution/mission/PostExecutionCommand-panel.html": {
    "href": "anatomy/execution/mission/PostExecutionCommand-panel.html",
    "title": "PostExecutionCommand Panel (Post-Execution) | HiAPI-C# 2025",
    "summary": "PostExecutionCommand Panel (Post-Execution) The key model is PostExecutionCommand, labelled Post-Execution. It is the Output category's first catalog entry, and it carries five outputs derived from what the session has played: step files, shot files, optimization files, a CL → NC writeback, and a geometry-difference detection. When It Runs, and What It Covers Post-Execution is an ordinary entry in the command list, not an end-of-run hook. Its name describes what it consumes, not a fixed position: the list runs its entries in order and skips any whose Enable box is clear, and everything this command writes is derived from what the session has played so far. That makes its placement the whole question. Put it after two program entries and it writes both. Put a second one halfway down the list and it writes an interim snapshot of the same accumulating state. The CL → NC writeback says this outright in the panel — place the CL-playing Program File command before this command — and it re-serializes every control file the session played, so an NC play is written back too. Read this together with General Config, the other half of the pair: those settings apply from their position forward, these outputs cover everything up to this position. The command sits anywhere in the list, like any other; nothing pins it to the end. Run executes the enabled outputs in an order of its own, which is not the order the tree and the list below show them in: shot files, then step files, then optimization, then the CL → NC writeback, then the geometry difference. Output timestamps follow that order rather than the layout. Layout Every output is a section child node of the command, and each section's enable flag is that node's own tree checkbox. The command node itself carries only a caption saying so; the section panels hold the template and numeric fields, which stay editable whether or not the output is switched on — the flag decides what runs, not what can be edited. Step Files Output Section The node's checkbox is EnableWriteStepFiles. Step File Template Field The model is StepFileTemplate. Default value: Output/[NcName].step.csv Writes the step-series data of what the session has played. Shot Files Output Section The node's checkbox is EnableWriteShotFiles. Shot File Template Field The model is ShotFileTemplate. Default value: Output/[NcName].shot.csv Shot File Time Resolution Number Field (ms) The model is ShotFileTimeResolution_ms. Default value: 1 This sampling period — not the machining resolution — sets the accuracy ceiling of the time-series data, and a fine period produces a large file: a six-cut program writes about 13 MB at 1 ms and about 128 MB at 0.1 ms. Optimization Output Section The node's checkbox is EnableOptimizeToFiles. Optimization File Template Field The model is OptimizationFileTemplate. Default value: Output/Opt-[NcName] The SoftNc pipeline runs when the SoftNc runner is on and the session holds played syntax layers; otherwise the HardNc path runs. Both clear every cutter's optimization-limit cache first. CL → NC Writeback Section The node's checkbox is EnableConvertClToNcFiles. NC Output Template Field The model is ClToNcFileTemplate. Default value: Output/[NcName].nc Its hint states the substitution: [NcName] is replaced by the source file name, extension kept. A caption below the field explains the synthesis: the MSYS frame becomes a G68.2 tilted working plane, tool posture becomes G43.4 RTCP with rotary words, and motions become G00/G01/G02/G03. The CL must have been played on an XYZABC machine chain first. The converted files appear as → file.nc nodes on the Execution Program branch, with source ⇄ output line jumps. Geometry Difference Detection Section The node's checkbox is EnableGeomDiff. Detect Radius Number Field (mm) The model is GeomDiffDetectRadius_mm. Default value: 1 Compares the workpiece geometry at that radius. With no workpiece in the session it reports “No Workpiece exist” and does nothing. Shot Files Output and Optimization Output are the two physics-gated sections. The condition is the physics preference and the advanced-physics licence, served to the client already combined; when it is off, the tree builder omits those two nodes entirely, and a preference flip shows up on the next branch rebuild. CL → NC Writeback is deliberately not gated — writeback is a SoftNc syntax feature, not a physics one. Every edit saves as it is made. A rejected save is reported and the panel reloads the command. Note Post-Execution writes run-derived files only. The meshed-geometry snapshot is a placeable command of its own, because a snapshot can be taken at any spot in a mission: Record Meshed Geometry (RecordMeshedGeomCommand, with its No Action / Read / Write / Read On First Or Write modes) and Export Meshed Geometry (STL) (ExportMeshedGeomToStlCommand) are both Output-category catalog entries with editors of their own. Opening a project that still carries an enabled meshed-geometry output on this command raises a system warning naming the replacement, and re-saving the project drops the element. Note GeomDiffCommand exists as a standalone command, as do WriteStepFilesCommand, WriteShotFilesCommand and OptimizeToFilesCommand. None of them carries the catalog attribute, so they load from a project file but are not offered in the Add Command dialog. Post-Execution is the catalogued carrier of these outputs, which is why they are edited as its sections. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/mission/PostExecutionCommandPanel.vue — the command node's caption and one headerless block per section: step-files, shot-files, optimization, cl-nc-writeback and geom-diff. No checkboxes live here. wwwroot-src/src/components/controlTree/missionItemTypes.ts — declares the five sections with their labels, marks Shot Files and Optimization physics-gated with an explicit note that CL → NC is not, filters the gated sections out of the tree, and maps each section id to its enable-flag reader and writer. wwwroot-src/src/components/controlTree/MissionSectionPanel.vue — renders one section headerless, the breadcrumb already naming it, and passes no enable state down because the flags decide only what runs. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — the ticks: a command node ticks its own enable flag, a section node with an enable flag ticks that, and every other node hides the box. wwwroot-src/src/api/mission.ts — loadPostExecution and the eleven postexecution/* PUTs. wwwroot-src/src/i18n/en/mission.ts — the field labels, the [NcName] hint, the command node's overview caption and the writeback paragraph. wwwroot-src/src/i18n/en/tree.ts — the five section node labels. wwwroot-src/src/stores/appState.ts — the physics preference and licence flags the tree builder reads. Environments/PreferenceController.cs — serves the physics preference already combined with the advanced-physics licence. Missions/MissionController.cs — the commands/{path}/postexecution/* endpoints: the five enable flags, the four templates, the shot-file time resolution and the geom-diff detect radius. HiAPI Engine HiNc/SessionCommands/PostExecutionCommand.cs — the model, its display name and Output-category catalog registration, every default above, the run order, and the warning raised for a project still carrying a meshed-geometry output. HiNc/SessionCommands/ListCommand.cs — the in-order run that skips disabled entries, which is what makes this command's placement decide what it covers. HiNc/MachiningProcs/SessionShell.cs — what each output actually calls: the shot-file writer and its sampling-period guidance, the step-file writer, the optimization routing between the SoftNc and HardNc paths, the CL → NC writeback synthesis, and the workpiece difference. HiNc/SessionCommands/GeomDiffCommand.cs, HiNc/SessionCommands/WriteStepFilesCommand.cs, HiNc/SessionCommands/WriteShotFilesCommand.cs and HiNc/SessionCommands/OptimizeToFilesCommand.cs — the standalone commands behind the same four outputs: loadable from a project file, absent from the catalog. HiNc/SessionCommands/RecordMeshedGeomCommand.cs and HiNc/SessionCommands/ExportMeshedGeomToStlCommand.cs — the two catalogued Output commands that carry the meshed-geometry snapshot. HiNc/SessionCommands/CommandCatalogAttribute.cs — the attribute that separates a loadable command from an addable one. See Also PreSettingCommand Panel — the other half of the positional pair: those settings apply forward, these outputs cover everything up to here NC Optimization Option Panel — the settings the Optimization Output section writes its result under The Other Commands — the task this command serves Mission — the rest of the command panels"
  },
  "anatomy/execution/mission/PreSettingCommand-panel.html": {
    "href": "anatomy/execution/mission/PreSettingCommand-panel.html",
    "title": "PreSettingCommand Panel (General Config) | HiAPI-C# 2025",
    "summary": "PreSettingCommand Panel (General Config) The key model is PreSettingCommand, labelled General Config. It is one command carrying a bundle of session settings — the machining resolution, the machining motion resolution, collision detection, pause on failure, physics — plus an optional read of a meshed-geometry file. Where a General Config Comes From How a mission acquires these settings is the first thing to know about this panel. The Add Command dialog is served by the server's command catalog, which reflects every engine command carrying [CommandCatalog]. PreSettingCommand carries no such attribute, so the dialog cannot produce one — the catalog keeps presetting only as a readable kind key, and creating a command looks the kind up in the addable set alone. What the web offers instead is the same settings as five separate Setup commands, each placeable anywhere in the list: Machining Resolution — MachiningResolutionCommand, 0.125 mm by default, reading Machining Resolution [0.125 mm] in the list. Machining Motion Resolution — MachiningMotionResolutionCommand, Feed Per Cycle by default. Collision Detection — CollisionDetectionCommand, on by default. Pause on Failure — PauseOnFailureCommand, off by default. Physics — PhysicsCommand, on by default, its field declared physics-licence gated. Machining Motion Resolution ships an editor of its own. The other four declare their one scalar with [CommandField] and are served by the generic field editor, which builds their input and its server-localized label from that declaration — so the web ships strictly more here than one bundle panel, and none of the four needed frontend code. A project file never brings a reader to this panel either. Reading a stored bundle materializes those five commands in its place, in the order the bundle applies them, preceded by a Read-mode Record Meshed Geometry entry whenever the meshed-geometry read is enabled or a file is set. The bundle's own enable state is consumed into every entry the expansion produces, and the Record entry additionally keeps the bundle's read flag. A bundle stored as the project's bare root command expands the same way, and what the project saves from then on is the split commands. That leaves one case this panel serves: a PreSettingCommand an API caller constructed into the list in place, which has not yet round-tripped through a project file. It edits that command through the commands/{path}/presetting/* endpoints, and every field is a PUT of its own. When the Settings Take Effect A list runs its entries in order and skips any entry whose Enable box is clear. General Config's Run then assigns straight onto the session shell, in this order: the meshed-geometry read when it is enabled, the machining resolution, the motion resolution, collision detection, pause on failure, physics. So these are positional settings, not global pre-run settings. A program entry above this command plays under whatever was in force before it; entries below it play under these values, until something further down changes the session again. The five Setup commands state the same contract one setting at a time — each is documented as taking effect “from this command on” — and each can sit at a different point in the list, which is what having them separate buys. Layout In the web client the command owns two tree nodes: the command node carrying the machining settings, and one section child carrying the meshed-geometry file reference. Command Node Machining Resolution Number Field The model is MachiningResolution_mm. Unit mm, floored at 0, default 0.125. A free numeric field — the web offers no option list. Motion Resolution The model is MachiningMotionResolution. A caption over a select with three choices: Feed Per Cycle, Feed Per Tooth and Fixed. Fixed adds a row of two number fields inline, both floored at 0: Linear Resolution (mm) and Rotary Resolution (deg), the two values of FixedMachiningMotionResolution. Switching the type to Fixed carries the outgoing resolution's current linear and rotary values into the new fixed pair rather than resetting them. Enable Collision Detection CheckBox The model is EnableCollisionDetection. Default value: true Enable Pause On Failure CheckBox The model is EnablePauseOnFailure. Default value: false Enable Physics CheckBox The model is EnablePhysics. Default value: true Disabled unless the advanced-physics licence is held. The engine declares the same gate on the split Physics command's field, so both editors refuse the same edit for the same reason. Meshed Geometry Section Node The node's own tree checkbox is EnableReadMeshedGeom; the panel below it holds the file reference only. The flag decides what runs, not what can be edited, so the field stays editable whether or not the box is ticked — a read can be prepared before it is switched on. Meshed Geometry File Field The model is MeshedGeomFile. Hinted as a .wct or .stl path relative to the project folder. Browse Button Opens the shared server-side file explorer, filtered to .wct / .stl with an All Files fallback. It opens on the project directory and allows no other root, so a pick always yields a project-relative path. Every edit saves as it is made. A rejected save is reported and the panel reloads the command, so what is on screen is what the server holds. Note The session's machining resolution is seeded from the workpiece's initial resolution when a project is loaded or assigned — not on a runtime reset and not when the workpiece is swapped, so an explicit setting survives both. This command carries its own value, and overwrites the session's with it at the moment the command runs. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/mission/PreSettingCommandPanel.vue — this editor in both of its modes: the command node's machining settings, and the meshed-geometry section's file field with its Browse button. wwwroot-src/src/components/controlTree/missionItemTypes.ts — maps the presetting kind to this panel, declares its one Meshed Geometry section child, and turns EnableReadMeshedGeom into that node's tree checkbox on read and on write. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — which nodes show a checkbox: a command node ticks its own enable flag, a section node with an enable flag ticks that, and every other node hides the box. A disabled command dims its whole subtree. wwwroot-src/src/components/controlTree/MissionSectionPanel.vue — renders one section of a command's editor headerless, the breadcrumb already naming it. wwwroot-src/src/components/widgets/FileExplorerDialog.vue — the server-side browser Browse opens, with the project-directory root and the filter list this panel passes it. wwwroot-src/src/components/mission/GenericCommandPanel.vue — the editor the four bespoke-panel-less Setup commands get, built from their declared scalar fields. wwwroot-src/src/api/mission.ts — loadPreSetting and the nine presetting/* PUTs behind it. wwwroot-src/src/i18n/en/mission.ts — the panel's wording, including the Rotary Resolution label and the meshed-geometry hint and filter names. wwwroot-src/src/stores/appState.ts — the physics-licence flag the Enable Physics checkbox reads. Missions/MissionCommandCatalog.cs — the addable set the Add Command dialog is built from: the reflected [CommandCatalog] entries, plus presetting as a read-only kind key that creation never looks at. Missions/MissionController.cs — the commands/{path}/presetting/* endpoints: enable-read-meshed-geom, meshed-geom-file, machining-resolution-mm, machining-motion-resolution-type, fixed-linear-resolution-mm, fixed-rotary-resolution-deg, enable-collision-detection, enable-pause-on-failure and enable-physics. The type switch is where the current linear and rotary values are carried into a new fixed resolution. HiAPI Engine HiNc/SessionCommands/PreSettingCommand.cs — the model, its defaults, the order Run applies them onto the session shell, and the expansion into the split Setup commands. HiNc/SessionCommands/CommandCatalogAttribute.cs — the attribute the catalog reflects, and the five categories. A command without it stays loadable from project files but is not offered for creation. HiNc/SessionCommands/CommandFieldAttribute.cs — the scalar-field declaration the generic editor renders, with its label, unit and physics-licence gate. HiNc/SessionCommands/ListCommand.cs — the in-order run that skips disabled entries, and the XML read path that expands a stored bundle in place. HiNc/MachiningProcs/MachiningProject.cs — the same expansion for a bundle stored as the project's bare root command. HiNc/SessionCommands/MachiningResolutionCommand.cs, HiNc/SessionCommands/MachiningMotionResolutionCommand.cs, HiNc/SessionCommands/CollisionDetectionCommand.cs, HiNc/SessionCommands/PauseOnFailureCommand.cs and HiNc/SessionCommands/PhysicsCommand.cs — the five Setup commands the web catalog offers, their defaults and their list titles. The detection, pause and physics settings each carry the “from this command on” wording. HiNc/MachiningProcs/LocalProjectService.cs — the session's machining resolution and the seeding from the workpiece's initial resolution on project load or assignment. See Also PostExecutionCommand Panel — the other half of the positional pair: these settings apply forward, those outputs cover everything up to there The Other Commands — the five Setup commands this bundle expands into, as a task Mission — the rest of the command panels"
  },
  "anatomy/execution/mission/index.html": {
    "href": "anatomy/execution/mission/index.html",
    "title": "Mission | HiAPI-C# 2025",
    "summary": "Mission Mission is a branch of the Execution page's Control Tree, reached as /execution?tree=execution/mission. It holds the command list a run executes: the project's own command is always a list, and nested lists read as sub-trees, so the branch is the mission and the mission is a tree of commands. Each command type has its own editor panel. The pages below document one type each; the root panel documents the list itself — adding, ordering and removing what the run will play. Ordered by where a command falls in a run: the branch root and its container first, then what is set up before the run, what the run plays, and what happens after it. Pages Mission Root Panel — The branch root: the command list, and how a mission is assembled List Command Panel — The container command; a nested one becomes a sub-tree of the mission PreSetting Command Panel — What is applied to the machine state before the run reaches a program NC Optimization Option Panel — The optimizer's options as a command in the list, so a run can change them mid-mission NcFile Command Panel — Playing a program file from disk NcCode Command Panel — Playing NC text held in the project rather than in a file Script Command Panel — Driving the session from C# script rather than from NC PostExecution Command Panel — What runs once the program above it has finished The pages above do not cover every command kind a mission can hold. Three more ship an editor of their own — Machining Motion Resolution, Record Meshed Geom and Export Meshed Geom — and the rest fall back to a generic field editor built from the scalars the command declares, so a kind becomes addable and editable before anyone writes a panel for it. The set on offer is whatever the server's command catalog returns, which is why this folder cannot be a closed list. See Also Execution Page — the run cockpit this branch belongs to"
  },
  "anatomy/execution/mission/mission-root-panel.html": {
    "href": "anatomy/execution/mission/mission-root-panel.html",
    "title": "Mission Root Panel | HiAPI-C# 2025",
    "summary": "Mission Root Panel The Mission branch root of the Execution page's Control Tree: route /execution, Control-Tree path execution/mission, panel MissionRootPanel.vue. /mission resolves to the same place — it redirects onto /execution?tree=execution/mission. The panel edits one list of commands: the mission's own command, which is always a ListCommand. The branch root is therefore a list editor — Add Command, the entries in run order, and the operations that rewrite the list. Editing a command is not this panel's job: clicking a row selects that command's tree node, and the command's own editor renders on that node's panel. Command nodes are addressed by index-derived tree ids and by dotted API paths (\"0\", \"1\", nested \"0.2\"). A command node id extends its parent's, so a root entry is execution/mission/{index} and an entry inside a nested list is execution/mission/{index}/{index}; a command's section children extend it once more, as execution/mission/{index}/{id} keyed on the section. Both forms shift on every structural change — deleting entry 2 slides the next command into path \"2\" — so each branch build stamps its nodes afresh and the editor panels remount onto the new paths. Key Models Primary: PlayerCommand — the mission's command, always a ListCommand. Supporting: MachiningProject ListCommand — the root command and every nested one. CommandEntryList is the row list, and a run walks it top-down. EnablingWrapper — one entry: the command plus IsEnabled. CommandCatalogAttribute and CommandCategory — what Add Command offers, and the group it is offered under. Layout Mission Root Panel Head Line Add Command Button Opens the Add Command dialog. Disabled while no project is open. Commands Caption Command Count Badge Outlined, and grey rather than primary while the list is empty. Separator Empty State “No project loaded” while nothing is open; otherwise “No commands yet”, naming Add Command. (Each) Command Row Drag Handle Icon The whole row is draggable; the handle is the affordance for it. Command Label The command's title as the engine composes it: the kind's localized display name, with a title the user typed appended as Name [title]. Move Up Button / Move Down Button Disabled at the ends of the list. Duplicate Button Delete Button A disabled command's row is dimmed, and its buttons stay live. Clicking the row anywhere but on a button selects that command's tree node. Drop-Out Zone Present in a nested list editor only, and shown only while a row is being dragged. It sits below the rows, so the rows do not shift under the pointer at drag start. Run-Order Hint Commands run top-down, and the checkbox on each command's tree item enables or disables it. Enable/disable is not a control on this panel. It is the tree item's checkbox on the command node; a disabled command is skipped when the mission plays and stays fully editable. Add Command The button opens a search-first picker. The search box matches a command's display label, its kind key, or one of its declared aliases — each alias searchable both by its English key and by its word in the request language. Arrow keys walk the results and Enter takes the highlighted one. Results are grouped by category, in the catalog's own display order. The picked command is appended to the list this editor is scoped to, and the branch rebuilds in place: the selection stays on the list rather than jumping into the new command's panel. The addable set is served by the backend rather than mirrored in a frontend menu. Every engine command carrying [CommandCatalog] is reflected into the catalog, so attributing a new engine command is all it takes for it to appear in the dialog. Thirteen kinds ship: Setup — Machining Resolution, Machining Motion Resolution, Collision Detection, Pause on Failure, Physics Program — Program File, NC Code, Script Optimization — NC Optimization Config Output — Post-Execution, Record Meshed Geometry, Export Meshed Geometry (STL) Flow — List Note Program File plays NC, CL or CSV. The runner is picked from the file extension, and the command can override that choice. Ordering, Duplicating and Deleting Move Up and Move Down move an entry within its own list; they never change which list owns it. Duplicate deep-clones the entry through the same XML round-trip the project file uses — so a nested list copies with its whole subtree — and the clone lands right after the source. Delete asks for confirmation in a dialog naming the command. Dragging a row has three landings: On another row — reorder within this list. A plain row splits at its midline into before and after, and the whole new order is sent as one ordered path list. On the middle band of a list row — move the entry inside that list. That row's outer quarters still reorder around it. On the drop-out zone of a nested list editor — move the entry out, landing right after the list command itself in the owning list. The last two are the same reparent call. The server resolves both lists to object references before it mutates either, so the index shift the removal causes cannot misroute the insert, and it refuses to move a list into itself or into one of its own descendants. Nesting A list entry grows the same structure one level down: its children are its own entries, so nested lists read as sub-trees at any depth, and the very same panel edits them. The differences are the scope — the root list, versus the node's own dotted path — and the drop-out zone, which appears only in a nested editor. A nested list's node adds an optional title above the embedded editor, and that title is appended to the List name in the row and tree label. Because the mission's own command is always a list, the root and a nested list are one editor at two scopes. A project file whose stored command is something else loads with that command wrapped into the root list, so the panel always has a list to edit. Where a Command Is Edited A command's editor renders on its own tree node, below the control bar carrying the operations that rewrite the parent list (Up, Down, Duplicate, Delete): Nine kinds have a bespoke editor: General Config, Machining Motion Resolution, Program File, NC Code, Script, NC Optimization Config, Post-Execution, Record Meshed Geometry and Export Meshed Geometry. list is edited inline by the control-bar panel: the optional title over the embedded list editor. The four remaining Setup kinds — Machining Resolution, Collision Detection, Pause on Failure and Physics — are served by the generic field editor, which renders the command's reflected [CommandField] scalars with server-localized labels. That is what the app does instead of shipping one panel per kind: a catalog kind needs frontend code only when it wants a richer editor. General Config is the one asymmetry. Its editor ships and reads a command, but the catalog does not offer it: a project file that stores the bundle loads as the individual commands it stands for, and the panel serves projects that construct one through the API. The multi-card kinds — General Config, NC Optimization Config and Post-Execution — put their extra cards on section child nodes of the command, one node per card, with the card's own enable flag surfaced as that section node's tree checkbox. Post-Execution's Shot Files Output and Optimization Output sections appear only while the physics preference is on. Source Code Path See HiNC App Anatomy for git repository links. Web Application wwwroot-src/src/components/controlTree/MissionRootPanel.vue — this panel: Add Command, the entry rows and their four actions, the three drag landings, and the delete confirmation. It serves the Mission root and, embedded under a command's control bar, every nested list node. wwwroot-src/src/components/controlTree/AddCommandDialog.vue — the search-first catalog picker. wwwroot-src/src/components/controlTree/MissionCommandSlavePanel.vue — one entry's panel: the move / duplicate / delete control bar over the kind's editor, or over the title input and embedded list editor of a list entry. wwwroot-src/src/components/controlTree/MissionSectionPanel.vue — the panel of a command's section child, rendering that one card. wwwroot-src/src/components/controlTree/missionItemTypes.ts — the Mission wave of the Control Tree: the item types, the child builders that carry the recursion, the per-kind editor map, the section definitions and their enable flags, and the kind and category icons. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — builds the Execution root with the Mission branch node above the Program branch, and drives the command and section checkboxes. wwwroot-src/src/api/mission.ts — typed wrapper over /api/Mission/*: listCommandEntries, addEntry, removeEntry, moveEntry, duplicateEntry, reparentEntry, reorderEntries, setListTitle, getCommandCatalog, loadCommandFields / setCommandField, and the per-kind readers and writers. wwwroot-src/src/components/mission/GenericCommandPanel.vue — the fallback editor for a catalog kind with no bespoke panel: the command's reflected [CommandField] scalars. The bespoke editors: wwwroot-src/src/components/mission/PreSettingCommandPanel.vue wwwroot-src/src/components/mission/MachiningMotionResolutionCommandPanel.vue wwwroot-src/src/components/mission/NcFileCommandPanel.vue wwwroot-src/src/components/mission/NcCodeCommandPanel.vue wwwroot-src/src/components/mission/ScriptCommandPanel.vue wwwroot-src/src/components/mission/NcOptOptionCommandPanel.vue wwwroot-src/src/components/mission/PostExecutionCommandPanel.vue wwwroot-src/src/components/mission/RecordMeshedGeomCommandPanel.vue wwwroot-src/src/components/mission/ExportMeshedGeomCommandPanel.vue wwwroot-src/src/i18n/en/tree.ts — the tree.mission.* strings this panel renders: Add Command, the Commands caption, the no-commands-yet state, the drop-out zone, the run-order hint, the kind display names, the section names and the operation labels. wwwroot-src/src/router/routes.ts — resolves /mission onto /execution?tree=execution/mission. Missions/MissionController.cs — the entry lifecycle (GET list-command/entries, POST list-command/entries and POST list-command/entries/{path} to add at the root or inside a nested list, DELETE list-command/entries/{path}, POST list-command/entries/{path}/move, PUT list-command/reorder, POST list-command/entries/{path}/duplicate and POST list-command/entries/{path}/reparent), the GET command-catalog the Add Command dialog reads, and the per-command endpoints including the generic commands/{path}/fields[/{key}] pair. reparent is what backs both drag-into-a-list and drop-out-to-the-parent, and it is the endpoint that rejects moving a list into itself or its own descendants. Missions/MissionCommandCatalog.cs — reflects every [CommandCatalog] command into the addable set served to Add Command, and creates the picked kind. Missions/MissionCommandFields.cs — the reflection layer behind the generic field endpoints: it describes and updates a command's [CommandField] scalars. Missions/NcOptOptionEndpoints.cs — the NC Optimization Config per-property PUT endpoints. HiAPI Engine HiNc/SessionCommands/CommandCatalogAttribute.cs — CommandCategory and the [CommandCatalog] attribute (category, order, kind key, aliases), plus the class-name-minus-Command derivation of the kind key. This is what makes the addable set backend-owned. HiNc/SessionCommands/ListCommand.cs — the container command: the entry list a run walks top-down, skipping disabled entries. HiNc/MachiningProcs/MachiningProject.cs — declares the mission's command as a list and keeps it one when a project is read. See Also Program Branch — the read-only inspection twin of this list: what a run actually read, one node per NC source file List Command Panel — the same editor one level down, and what moving an entry in or out of a nested list costs Building a Mission — the task this panel serves, as a procedure"
  },
  "anatomy/execution/mission/script-command-panel.html": {
    "href": "anatomy/execution/mission/script-command-panel.html",
    "title": "Script Command Panel | HiAPI-C# 2025",
    "summary": "Script Command Panel The key model is ScriptCommand. The command holds two values: ScriptText, a C# script, and ScriptTitle, the name it runs under. Both are written into the project file, so the script travels with the project. Run evaluates the text against the session shell as the globals object, and when the script returns a sequence of actions that sequence is yielded into the run. The title is what the mission row and the tree node show: the label is composed as Script [title], falling back to a bare Script while the title is empty. A newly added command starts empty on both clients — no title, no text. The panel renders on the command's own node in the Mission branch of the Execution page's Control Tree, below the move / duplicate / delete control bar. A single-purpose kind like this one embeds its whole editor on that node rather than growing section child nodes. Its tree checkbox only decides whether the run plays the command; a disabled script is skipped during play and its editor stays fully usable. Layout Head Line Script Title Text Field The model is ScriptTitle. Labelled \"Title (optional)\". Autosave Indicator (web) Shares the title row. See Saving. Script Editor Area The model is ScriptText. Fills the rest of the panel. The Editor The web editor is CodeMirror 6 running the mission-script mode: a stream tokenizer written for the dialect a mission script actually is — top-level statements, not a compilation unit. It colours keywords and boolean literals, strings (plain, verbatim @\"\", interpolated $\"\" and $@\"\"), character literals, hex and floating-point numbers, line and block comments, and it tags a call site apart from a plain identifier. Because it is linear rather than a parser, every identifier of the same kind gets the same colour no matter where it sits in the file. The C# Lezer grammar the client also ships is not what this editor runs: its compilationUnit rule rejects top-level statements, so it would recover from an error on line 1 and tag identical names inconsistently. That grammar serves the separate csharp mode a .cs file opens in elsewhere in the app. Nothing in the highlighting is semantic. Everything the editor knows about types and members comes from the backend, through completion. Completion Typing an identifier — or asking explicitly — sends the whole script text plus the zero-based cursor offset to POST /api/script/completions, and the response is an items array. Each item carries a label, a kind already normalised to CodeMirror's own completion type names, a detail (the signature, shown dim beside the label), a documentation (the XML <summary>, rendered to plain text by Roslyn and shown in the popup's info pane) and an insertText. Completion is Roslyn in-process, over the very ScriptOptions — the same references and imports — that the run compiles the script with, so the session shell's members and the runtime API surface complete for real rather than by name matching. The service prepends the synthesised using / using static prefix those imports need and offsets the cursor by its length, so what the list offers is what the evaluator will see. A cancelled request is answered 499, and a result that arrives after the editor has moved on is dropped rather than shown. Picking a method inserts the server-formatted call with each argument as a Tab stop, so the cursor lands on the first parameter and Tab walks the rest; a method with no parameters inserts as (). Properties, fields, types and keywords insert as their plain text — a snippet there would be noise. Saving There is no Save button. Every keystroke in either field updates the model and schedules one save 500 ms after the last edit, and the pill beside the title reports the state: Idle, Dirty, Staging…, Staged, or Error with the message in its tooltip. Staged means the server runtime holds the value — its tooltip says so, because a staged script is not yet a committed project. The write is a single PUT carrying the script text, the title and the content hash the last load or save handed back. Each field is applied only when the body carries it. The response returns the new hash to chain into the next save. Two prompts guard the edges, each with three buttons because neither is a yes/no question: Unsaved Changes, raised when the Control Tree tries to move the selection off a command whose save is still pending: Save & switch flushes and then allows the switch, Discard drops the pending write, Cancel keeps the selection where it is. Script changed elsewhere, raised when the server rejects the save because the hash no longer matches — another tab, or a project reload, changed the command underneath. The rejection carries the server's current text, title and hash, so the panel can offer Discard & reload, Force overwrite, or Cancel without a second round trip. The panel snapshots its command path at mount, and the autosave closes over that snapshot rather than over the live selection, so a flush can never land on whichever command happens to be selected when it fires. After each successful save the tree relabels the node in place instead of rebuilding the branch, which would remount the editor mid-edit. The Compile Gate A script that does not compile does nothing at run time: the command reports the compile failure into the run's message stream and yields no work, so the run continues without it. Starting a run therefore compile-checks every enabled script first — with the same script options and globals type the evaluator uses — and refuses to start when any of them has an error, naming the first offender's title, path, diagnostic id, message and line. The SPA's Start sends nothing to bypass that check, so the refusal is what a user sees. The same check is also an endpoint of its own, per command and for the whole mission. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/mission/ScriptCommandPanel.vue — this panel: the title row sharing its line with the autosave indicator, the editor below it, the 500 ms autosave, the two three-button prompts, the path snapshot taken at mount, and the change notice that relabels the tree node. wwwroot-src/src/components/widgets/TextEditor.vue — the CodeMirror 6 wrapper: language and read-only swapped through compartments, CRLF normalised on the way in so an unedited file cannot dirty the autosave, an opt-in completion source that overrides the language's own, and a widened monospace popup so full signatures fit before the dim detail column truncates. wwwroot-src/src/components/widgets/missionScriptLanguage.ts — the mission-script mode: the keyword set, the string and character rules, numbers, comments, call-site tagging, and its own highlight style. wwwroot-src/src/components/mission/csharpCompletionSource.ts — the completion source: fires on an identifier prefix or an explicit request, sends the whole document with the cursor offset, drops stale results, and applies every candidate as a snippet. wwwroot-src/src/api/scriptCompletion.ts — the typed wrapper over the completion endpoint and the kind union that maps straight onto CodeMirror's completion types. wwwroot-src/src/api/mission.ts — the script command shape (text, title, content hash), its loader, the save that carries the expected hash, and the conflict error that carries the server's current copy. wwwroot-src/src/composables/useAutoSave.ts — the debounce, the state machine and the conflict recovery behind the panel's saving, saved and error states. wwwroot-src/src/components/widgets/AutoSaveIndicator.vue — the status pill beside the title. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — funnels every selection change through the active panel's switch gate, which is how the Unsaved Changes prompt gets its say. wwwroot-src/src/components/controlTree/missionItemTypes.ts — maps the script kind to this panel and gives it no section children, so the whole editor lives on the command node. wwwroot-src/src/i18n/en/mission.ts — the panel's wording: both prompts, their buttons, and the load and save error contexts. Missions/ScriptCompletionController.cs — POST /api/script/completions: a thin wrapper that returns the items, 499 on cancellation and 500 with the message on failure. Missions/ScriptCompletionService.cs — the singleton holding one workspace, built from the same script options the session evaluates with, and the snippet insert text it builds for methods. Missions/ScriptCompileCheckService.cs — compiles a script without running it, and walks the mission for every enabled one; it backs the two compile-check endpoints and the pre-start gate. Missions/MissionController.cs — the single script PUT with its hash-based concurrency, the content hash stamped into the command snapshot, and the two compile-check endpoints. Execution/ExecutionController.cs — the start gate that compile-checks the enabled scripts and refuses to run while one of them has an error. HiAPI Engine HiNc/SessionCommands/ScriptCommand.cs — the model: the title and text, the Program-category catalog registration, the XML round-trip that puts the script into the project file, the evaluation against the session shell with a compile failure reported into the run's message stream, the returned actions yielded into the run, and the label rule that brackets the title after the command name. See Also NcCodeCommand Panel — the other command that stores its text in the project, and the one that ships no editor chrome The Other Commands — the task this command serves, beside the settings and output kinds Mission — the rest of the command panels"
  },
  "anatomy/execution/program.html": {
    "href": "anatomy/execution/program.html",
    "title": "Program Branch | HiAPI-C# 2025",
    "summary": "Program Branch Program is the lower of the two Control-Tree branches the Execution page hosts: route /execution, Control-Tree path execution/program, one node per NC source file the session read. It is a read-only view of a run — the file's text, the passes that went over it, the per-line marks the run left behind, and the writeback files the run wrote — assembled from session data rather than from anything typed into it. Its node ids are positional, so an id addresses a node without surviving the branch growing around it. Program Against Mission Mission is what a run executes; Program is what the run read. That one difference sets the rest of the branch: Mission's nodes edit the project. Program's item types declare a panel and a child builder and nothing else — no enable checkbox (the tree hides the tick on every node that is not a Mission command or an enable-bearing Mission section), no control bar, no add, delete, move or duplicate. Mission's shape is authored. Program's shape is a consequence: a subprogram file appears on it only because a run followed a call into it. Mission belongs to the project. Program's contents belong to the session — the index behind it is fed piece by piece as the run executes, and it is dropped when the session ends or the project changes. Before anything runs the branch is not empty. The server seeds it by walking the mission root-first through its nested lists — skipping a disabled entry along with everything beneath it — and taking the NC file of every Program File command and the title of every NC Code command. It seeds one placeholder per distinct string, not one per command: both loops append only where no root already carries that string under the same case-insensitive, slash-normalised comparison the sibling merge uses, and they share one namespace, so a Program File path and an NC Code title that normalise alike collapse into one node. A Program File command whose path is still unset is skipped and seeds nothing. A placeholder carries no invocations, so its panel shows the file's text with no marks and an empty, disabled pass selector. The transport bar is the one control the branch does carry, and it is not the branch's own: the primary editor pane pins the Execution Tool Bar above the panel of the Execution root and of every node beneath it, so a run can be started, stepped and reset while a program file is on screen. The Nodes the Branch Mints Three item types, each keyed by position rather than by identity. The branch root (execution/program) carries the summary panel and the child builder that fetches everything. A file node is one source file as reached through one call edge. The server groups executed sentences by the file index stamped on them, resolves each invocation's caller from the call-stack record on the executed piece, and nests the callee's node under the caller's; the same subprogram called from two different files therefore appears once under each. Sibling nodes merge on a case-insensitive, slash-normalised path comparison, so repeated passes over one file under one caller collapse into a single node holding several invocations. Placeholders are appended after the nodes a run produced, and one whose path a run node already holds is skipped rather than doubled — that skip is also what keeps an inline command to one node, because the run stamps the command's title as the path of every piece it plays, so the placeholder and the run node carry the same string. A later pass flags every root whose path matches an enabled NC Code command's title as inline; that flag drives three presentational choices — the label prefix, the panel's inline caption and which missing-text wording it shows — and one behavioural one: the root's child builder matches a node against the writeback conversions only when the node is not inline, so an inline root is never stamped with a conversion, never gains the forward links to a converted file, and cannot be the target a conversion's converted from header jumps back to. The tree label is the path's base name, prefixed (inline) for an inline node and suffixed with a multiplication sign and a count when the node holds more than one invocation. A conversion node is one NC writeback conversion held by the session, labelled with an arrow and the written file's base name. Conversion nodes are appended after all file nodes. A file node's id is its parent's id plus its index among that parent's children (execution/program/0, execution/program/0/1); a conversion node's is the branch root's id plus dst- and the conversion's position in the session's list. Both are positional, and the tree those indices count into grows as a run discovers files, so a ?tree= link into this branch names a position and not a file. The whole branch costs two requests. The root's child builder takes the file tree in one response and the conversion list in another, stashes each file's raw subtree on the node it mints, and the file nodes' builder only maps what is already there — no node fetches for itself. A failed file-tree request yields an empty branch rather than an error; a failed conversion request leaves the file tree standing without cross-links. Invocations An invocation is one pass over one file, keyed on the file index the run stamps onto every executed sentence. A fresh index is allocated for each top-level play of a file and for every subprogram call, call repetition and loop or jump re-segmentation, so a file entered or looped over more than once contributes one invocation per pass, and the file panel's pass selector is exactly a pick among them. Each entry reads as a hash-prefixed ordinal and a trigger, and the trigger is derived from the piece that opened the pass: the call term with its P word — M98 P8, M198 P8 — when the piece carries a Fanuc subprogram-call record. Only that record is read, so a pass opened by a Siemens or Heidenhain call, or by a Fanuc macro call, falls through to the two cases below; re-entry when this session has already seen a pass over the same path; top otherwise. The selector opens on the last invocation in the node's list — the pass that started most recently — and re-defaults whenever a rebuild leaves the current selection absent from the list. It is disabled while the node has none, and it takes typed text as a filter over the entries. Everything below it belongs to the selected pass alone: switching passes drops the mark and link caches and refetches both for every page of text already loaded, not only for the pages on screen. The footer counts the file's lines and, for the selected pass, the number of distinct source lines that executed in it. What a Run Marks The line viewer is virtualized. Text arrives in 1000-line pages covering the visible window plus two pages either side; the server caps one request at 2000 lines and keeps a small most-recently-used cache of whole files keyed on path and last-write time, so paging through a long program does not re-read it once per page. A path with no file on disk is answered as non-existent, the miss is cached so scrolling does not re-fire it, and the panel captions the file as missing — or, for an inline node, as inline text that is no longer available, because an NC Code command's text is served from the mission command itself and goes when the command is removed or retitled. A disk file wins over a command title that shadows it. Marks are fetched the same way and per selected pass. A line the pass executed carries the sentence index it ran and the range of machining steps that sentence produced; a line absent from the answer did not execute in that pass and is greyed — but only once the node holds at least one invocation, so a placeholder's text renders plain rather than uniformly grey. A line whose sentence produced steps carries a step badge, single-valued or a range. Marks grow as a run advances, so a page cached early would keep later lines looking unexecuted. The panel drops its mark cache and re-fetches the visible window on every throttled CL-strip update broadcast. Clicking a line points the shared sentence cursor at that source position, which is what fills the Step Info column's Sentence Syntax panel; when the line's sentence produced steps, the click also selects that sentence's first step, moving the charts and the 3D strip with it. A line with no steps — a G54, a comment, a line that never ran — moves the cursor alone. Hovering a line sends the same anchor as the entered step on a 50 ms leading-edge throttle, and leaving the viewer clears it. The traffic runs the other way too. A step picked on a chart or the 3D strip resolves to a source anchor and lands on the cursor; a file panel whose path matches switches to the pass that step belongs to and scrolls the line into view. The Follow toggle beside the pass selector is the live variant: while it is on, the panel scrolls to whatever line the execution-status hub's cursor reports for this file. It is off by default, it belongs to the mounted panel rather than to stored preferences, and it does not change the selected pass. Writeback Conversions The session retains the destination piece streams and source-to-destination maps of its latest CL-to-NC writeback run — NcConversions(API), refilled by ConvertClToNcFiles(API). This branch only displays them; the writeback itself is switched on by the mission's Post-Execution command, in its CL → NC Writeback section. Because the conversions live on the session, they go when it does. A conversion node shows the written file's lines, each line whose piece has a registered source carrying a back-arrow badge naming that source line. The panel's header names this conversion's source file; the link on that name lands on the file's node when a root file node matched the conversion's source path, and otherwise falls back to the first entry of the branch's file-index map, so a conversion whose source was reached only as a nested or inline node can name one file and open another. Clicking a badge selects the source node, switches it to the invocation the piece came from, and scrolls to the line; clicking anywhere else on a row only highlights it. The viewer has no missing-file caption of its own, so a written file no longer on disk renders as an empty viewer. The reverse direction is carried by the file panel. A root file node whose path matches a conversion's source path gets forward-arrow badges naming the destination line, with a count when one source line produced several destination lines, and clicking one selects the conversion node and scrolls to the first of them. That matching is done on root nodes only, and never on an inline node, so a subprogram file reached through a call carries no forward badges of its own even though a backward jump can land on it and switch its pass. The jump itself rides one shared slot, because only one editor panel is mounted at a time: the requesting panel parks the target line and emits a selection, and the twin takes the parked jump when it mounts — or through a watcher, when it was already the selected panel. A target consumed before the first page of text resolves is parked again and re-applied once the line array is sized. When the Branch Is Rebuilt Page initialization. Building the Execution root builds the branch, and only when a project is loaded; without one it stays empty. Any change in the broadcast execution status. The status the hub reports is one of NoProject, Ready, Running, Paused and Finished, and the host re-reads the branch whenever that value changes. It deliberately does not take the structural-change path used elsewhere in the tree, because that path force-expands the node it rebuilds and a run would then keep re-opening a branch the reader had closed. The panels pick up part of the change from the replaced nodes: the path caption, the pass selector, the inline wording and the executed-line count are all derived from the node, but the file text is not — it is fetched once per page on mount and on scroll, with no watcher on the path, and the panel is not remounted because its key is built from the node id, which is positional and therefore unchanged. A rebuild that puts a different file at the same index leaves the previous file's text on screen under the new node's caption and marks. The refresh button on the root panel. This one does take the structural-change path: it re-reads the file tree from the current session and expands the branch. A reset is the emptying event: it ends the session and clears the index, so the next read of the branch returns the mission's placeholders and nothing else. Layout Program Node Intro Caption Status Row Run-State Badge — reads run data when any of the branch root's direct file children holds at least one invocation and not run yet otherwise; like the count beside it, it looks one level deep and never at nested subprogram nodes. It is computed from the nodes, not from the file-tree response's own run-data flag. File Count Caption — the branch root's direct file children only; nested subprogram nodes are not counted. Converted File Count Caption — shown only when the session holds conversions. Refresh Button Not-Run Hint — shown while the badge reads not run yet. Conversions Hint — shown only when the session holds conversions. Program File Node Path Caption — the path as the run stamped it; an inline node appends an inline-NC-code tag. Pass Select Follow Toggle Not-Run Hint — shown while the node has no invocations. Missing-Source Caption — the disk-file wording or the inline-text wording. Line Viewer Line Number Line Text Step Badge Converted-Line Badge Count Footer — line count, plus the selected pass's executed-line count. Converted File Node Path Caption Converted-From Line — the source file's name, linked to its node when a root file node matched. Line Viewer Line Number Line Text Source-Line Badge Count Footer — line count and converted-piece count. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/programItemTypes.ts — the branch's three item types, the node ids, the labels, the conversion stamping, and the two-request child builder. wwwroot-src/src/components/controlTree/ProgramRootPanel.vue — the branch root: intro, run-state badge, file and conversion counts, hints and the refresh button. wwwroot-src/src/components/controlTree/ProgramFilePanel.vue — one source file: the pass selector, the Follow toggle, the paged line viewer, the execution marks, the step and converted-line badges, and the cursor and hover wiring. wwwroot-src/src/components/controlTree/ProgramConversionFilePanel.vue — one written file: the paged line viewer and the source-line links back into the file panel. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — declares the branch root under the Execution root, re-reads it on every execution-status change without expanding it, and hides the tick on every node that is not a Mission command or an enable-bearing Mission section. wwwroot-src/src/components/controlTree/itemTypes.ts — the node shape carrying the program bookkeeping, the merged item-type registry, and the eager subtree builder. wwwroot-src/src/components/controlTree/ControlTreePanel.vue — the tree pane that renders the branch's nodes and binds the tree's strict tick strategy. wwwroot-src/src/components/controlTree/PrimarySlavePanel.vue — mounts the selected node's panel, forwards its selection request to the host, and pins the transport bar above every Execution-scope node. wwwroot-src/src/api/ncProgram.ts — the typed client for the file tree, the paged lines, the line marks, the syntax piece, the sentence-to-step mapping and both directions of conversion links. wwwroot-src/src/api/clStrip.ts — the step-select and step-enter posts a line click and a line hover make. wwwroot-src/src/composables/useConversionJump.ts — the single parked-jump slot the two viewers hand a target through. wwwroot-src/src/composables/useSentenceCursor.ts — the shared source position, written by a line click and by the resolved step selection. wwwroot-src/src/composables/useClStripHub.ts — the throttled run-advance counter that invalidates the visible marks. wwwroot-src/src/composables/useExecutionStatusHub.ts — the status the branch rebuild watches and the running cursor the Follow toggle scrolls to. wwwroot-src/src/components/execution/SyntaxPiecePanel.vue — the Step Info column's Sentence Syntax panel, the other reader of the shared cursor. wwwroot-src/src/i18n/en/tree.ts — the branch's labels, hints, badges and pluralised counts. Execution/NcProgramController.cs — the read-only endpoints: the file tree, the paged file lines with their inline-command fallback and whole-file cache, the line marks, the syntax piece, the sentence and step lookups, the conversion list and both directions of conversion links. Execution/NcProgramRegistryService.cs — the session-scoped index: the event feed, the invocation records with their trigger and caller resolution, the file-tree snapshot with its mission placeholders, the per-line marks, and the clear on reset or project change. HiAPI Engine HiNc/MachiningProcs/LocalProjectService.cs — the app-lifetime bridge that forwards each executed piece and each built machining step, and the reset that ends the session. HiMech/MachiningProcs/MachiningSession.cs — the retained conversions and the CL-to-NC writeback run that refills them. HiMech/NcParsers/NcWriteback/NcConversion.cs — one conversion: the destination piece stream, its written path and the source-to-destination map the cross-links walk. HiMech/NcParsers/Syntaxs/SyntaxPiece.cs — the executed unit the index is keyed on, and the source line stamped on its sentence. HiNc/SessionCommands/NcFileCommand.cs — the Program File command whose path seeds a placeholder. HiNc/SessionCommands/NcCodeCommand.cs — the NC Code command whose title is the pseudo-path of an inline node and whose text is that node's only source. See Also Mission Root Panel — the editable twin: the command list this branch reports on, and the only place the NC file list is changed Execution Page — the page that hosts both branches, and the transport, canvas and charts the branch's selections drive"
  },
  "anatomy/execution/selected-step-info-panel.html": {
    "href": "anatomy/execution/selected-step-info-panel.html",
    "title": "Selected-Step Info Panel | HiAPI-C# 2025",
    "summary": "Selected-Step Info Panel The panel that shows the selected machining step's properties. It sits in the Execution Page's Step Info column, where the app labels it Step Properties. The model is MachiningStep and UserService. The MachiningStep is assigned by ClStrip.PosSelected. Show step information from UserService.DisplayedStepPresentAccessList. The resx of MachiningStep contains the translation of PresentAttribute.Name; apply the translation to the GUI, and fall back to the original value when no translation exists. Which properties are listed is chosen on the Step Present Preference Page, opened from the Step Present button on this panel's title bar. Layout A plain key / value list, not a q-list: the value cell has to shrink and wrap, because a step carries arbitrarily long values (a file path, a whole NC line) and a non-shrinking cell would widen the entire column. Each row is labelled shortName, falling back to name and then to the raw key, with the full name as the row's tool-tip; the unit follows the value, and an absent value renders as -. With nothing selected the panel shows No step selected. Click a step in the canvas to inspect its info. The StepIndex row is filtered out even when the configured list contains it — the column's group bar already carries the step index as a badge. Behavior Selection bursts (a SetSelectedPos per step while a mission runs) are coalesced into one trailing fetch on an 80 ms timer, and responses are sequence-guarded so a slower earlier fetch cannot overwrite a newer one. A language change re-pulls, because the field names arrive already localized. Sample Code Refer to this code to show step information. internal static void ShowStepPresent( UserService userEnv, MachiningStep machiningStep) { foreach (var entry in userEnv.DisplayedStepPresentAccessList) { var present = entry.Value.Present; var valueText = string.Format(\"{0:\" + present.DataFormatString + \"}\", entry.Value.GetValueFunc.Invoke(machiningStep)); Console.WriteLine($\"{present.ShortName}: {valueText} {present.TailUnitString} ({present.Name} [{entry.Key}])\"); } } Selection Push (Web Service Only) SelectedStepInfoService answers the payload on demand: the REST endpoint GET /api/Execution/selected-step-info calls it. It has no SignalR hub of its own — the “selection changed” push rides /clStripHub, whose StepSelected broadcast follows the same PosSelected event. The panel and the cycle-line charts watch that broadcast and re-pull this payload. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/execution/SelectedStepInfoPanel.vue — the panel. wwwroot-src/src/components/execution/StepInfoGroupBar.vue — the group bar above it, shared by the step-based panels of the column. Execution/ExecutionController.cs — GET /api/Execution/selected-step-info. Execution/SelectedStepInfoService.cs — the payload. Execution/ClStripBroadcastService.cs — the StepSelected broadcast that tells the panel to re-pull. See Also Execution Page — the page whose Step Info column hosts this panel Step Present Preference Page — chooses which properties are listed Inspecting a Step — the task this panel serves, and the rest of the column around it"
  },
  "anatomy/execution/step-present-dialog.html": {
    "href": "anatomy/execution/step-present-dialog.html",
    "title": "Step Present Dialog | HiAPI-C# 2025",
    "summary": "Step Present Dialog Shipped Surface The dialog has no route and no Control-Tree node. It is a modal on the Execution page (/execution), opened by the tune icon button on the Step Properties panel's title bar in the Step Info column — so it is reachable only while that column and that panel are shown. The button sits next to the list it configures. The dialog's own view models are the two fetched values, categories and displayedKeys. The server models they mirror are UserService.CandidateStepPresentKeyList plus UserService.StepPresentAccessDictionary (the candidates) and UserConfig.DisplayedStepPresentKeyList (the ordered displayed list). The dialog's only prop is its open/closed flag. Layout Header Title, then the counts — n displayed / n available The save-state line (Saving… / Saved / error), which stands in for a Save button Reset and close Splitter Candidate Keys Panel (left) One accordion per category, in the order the server sends them A tri-state checkbox on the category header One checkbox per key, with the key's label and unit Add Selected Displayed Keys Panel (right) One row per displayed key, in UserConfig.DisplayedStepPresentKeyList order, drag-reorderable Per-row up / down / remove Clear Rows are labelled from the per-key payload the server sends — key, name, shortName, unit. The visible label is shortName, falling back to key, with a unit appended in parentheses when it is not None. The tooltip carries the full name above the raw key. Behavior Adding is a two-step gesture on the left: tick candidates — individually, or a whole category through the header's tri-state checkbox — then press Add Selected. A key that is already displayed has its checkbox disabled and shows a check badge instead. Removing lives only on the right, per row or through Clear. Every add, remove and reorder persists immediately: the dialog POSTs the whole ordered list, the server drops unknown keys and duplicates and answers with the effective list, and the dialog re-syncs to that answer. Reset is a DELETE that empties the list; both Reset and Clear go through a confirmation. A failure flips the header state to its error label and notifies; a failed list write additionally re-reads from the server, so the editor never drifts from persisted state. The dialog fetches fresh on every open, and re-pulls when the UI language changes, because the category and key labels arrive already localized. The list this dialog configures omits StepIndex even when it is displayed: the Step Info column's group bar already shows the step index as a badge, so the panel filters that one row out rather than repeating it. Categories Categories are a GUI-level grouping of keys. Each ships as a stable code plus a display label: the code is the transport identity the client compares and keys its UI state on, the label is display text only. The seven, in canonical order: fileCmdFlagTimeSystem — “File / Command / Flag / Time / System” (StepIndex, FileNo, LineNo, FilePath, LineText, FlagsText, EndTimecode, StepDuration). toolFeedrateSpindle — “Tool / Feedrate / Spindle Speed” (ToolId, SpindleSpeed_rpm, Feedrate_mmdmin, CuttingSpeed_mmds, …). coordinateMove — “Coordinate / Move” (Cl, MoveOnProgramCoordinate, MovingLength_mm, and every MC. key). cuttingGeometryChip — “Cutting Geometry / Chip / Bias / Roughness” (CuttingDepth_mm, ChipThickness_um, Mrr_mm3ds, …). mechanicsPowerEnergy — “Mechanics / Power / Energy” (MaxAbsForce_N, SpindleOutputPower_W, AvgAbsTorque_Nm, …). temperatureWear — “Temperature / Wear” (ChipTemperature_C, AccumulatedFlankWearWidth_um, …). custom — “Custom”, the catch-all for every key the mapping does not place, including the keys registered at run time through UserService.AdditionalStepPresentAccess. All seven are always returned; nothing gates any of them, and the candidate list is read from UserService.CandidateStepPresentKeyList rather than from MachiningStep directly, so runtime-registered keys are included. The key → category mapping is ResolveStepPresentCategory on the webservice, with the seven category codes as its contract. Labels and Localization The web app resolves name and shortName server-side for the requested language from the shipped step-present catalog, laid over the live PresentAttribute.Name and ShortName values — those are the English truth and the fallback for a missing catalog file or key. Unit is sent as-is and does not localize. The dialog pins the language with a ?lang= argument on the request and re-pulls when the UI locale changes. Refer to the code to apply PresentAttribute: internal static void ShowStepPresent( UserService userEnv, MachiningStep machiningStep) { foreach (var entry in userEnv.DisplayedStepPresentAccessList) { var present = entry.Value.Present; var valueText = string.Format(\"{0:\" + present.DataFormatString + \"}\", entry.Value.GetValueFunc.Invoke(machiningStep)); Console.WriteLine($\"{present.ShortName}: {valueText} {present.TailUnitString} ({present.Name} [{entry.Key}])\"); } } See Also Selected-Step Info Panel — the panel whose property list this page configures Preference Menu Dropdown — the preference surface this editor sits beside Inspecting a Step — the task this dialog serves, as a procedure Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/preference/StepPresentPreferenceDialog.vue — the dialog itself: a Candidate Keys / Displayed Keys splitter, category accordions keyed on the stable category code, the per-category tri-state checkbox, Add Selected, drag-reorder plus up / down / remove and Clear, the header counts, Reset and close, and the auto-save state. Refetches on every open and on a locale change. wwwroot-src/src/components/execution/SelectedStepInfoPanel.vue — what opens it: the tune icon button teleported into the panel's title bar (the hosting expansion header, or the panel's own bar when standalone). Also the list the dialog configures, with the StepIndex row filtered out. wwwroot-src/src/components/execution/StepInfoGroupBar.vue — the Step Info column's group bar, which carries the step-index badge instead. wwwroot-src/src/pages/ExecutionPage.vue — the only surface the dialog is reachable from. wwwroot-src/src/api/preference.ts — getStepPresentKeys (language-pinned) / setStepPresentKeys / resetStepPresentKeys, and the StepPresentKeyInfo / StepPresentCategory / StepPresentKeysSnapshot types. Environments/PreferenceController.cs — GET / POST / DELETE /api/preference/step-present-keys, the seven-entry category table, the ResolveStepPresentCategory mapping, and persistence of DisplayedStepPresentKeyList through SaveUserConfig(). Environments/PresentCatalogService.cs — server-side localization of name and shortName from the shipped step-present catalog, with the live PresentAttribute data as the English base and fallback. Environments/UserService.cs — StepPresentAccessDictionary and CandidateStepPresentKeyList, the candidate-key model. Environments/UserConfig.cs — DisplayedStepPresentKeyList, the ordered displayed-key model."
  },
  "anatomy/execution/strip-charts.html": {
    "href": "anatomy/execution/strip-charts.html",
    "title": "Strip Charts | HiAPI-C# 2025",
    "summary": "Strip Charts The strip charts visualise a windowed, downsampled view of the full mission timeline for physics / quality aspects that are computed per step across the whole NC program. They are rendered as min/max banded series over the ClStrip.GetDispBegin() .. AbsDispEnd window. Operators use them to spot which segments of the mission are loading the spindle, degrading surface quality, or hitting thermal limits. They occupy the Strip Charts column of the Execution Page. The anatomy covers three, all sharing BaseStripChart.vue: Chart Source Aspect Items Availability Chart Availability Yielding-stress / max-spindle-torque / max-spindle-power / spindle-working-temperature / thermal-yield ratios (5 series). Surface Roughness Chart SurfaceRoughness Re-cut depth + program-side cusp + Δ tip deflection X / Y / Z in µm (5 series). Color Index Time Chart Individual One series of a user-picked StepPropertyAccessDictionary key (≈90 keys). Key Model: MachiningProject via LocalProjectService.ClStrip + LocalProjectService.StepPropertyAccessDictionary. Layout One group bar drives all three charts, and each chart is a collapsible panel below it. Group Bar Range chip — [{dispBegin}..{absDispEnd}] / {count}, with Showing steps {begin}..{end} of {count} total as its tool-tip. Cursor x readout — the hovered x value, shared by all three charts and reserving a fixed width so hovering never reflows the bar. It is the one place the hovered value is printed; the charts themselves carry no per-chart cursor row. X-axis mode — IndexByTime (default) / IndexByStep, applied to every strip chart at once. Fit View — fits the 3D canvas to the tool path / home position. Disabled without a rendering connection id, and the only control here that acts on something other than the charts. Stick disp-end to live end — keeps the window pinned to the running end of the mission. The state is dispEnd === -1, so a pan or a wheel turns it off by writing a concrete end, and Reset re-arms it. Reset display range — returns the window to the whole mission. Reload all strip charts. Each chart panel Header — title label; the aspect picker on the Color Index chart, a dropdown listing every StepPropertyAccessDictionary key with a GetQuantityFunc, sorted by PresentAttribute.Name and filtered by a type-to-search field; the Y-axis range editor (Fit / Lock / Symmetric with a ± bound); and, on the Color Index chart only, a Colors dropdown editing the colour guide's floor / ceiling / tone function. That editor drives the 3D workpiece colouring and the colour-scale bar, not the chart's own line. Body — UplotChart.vue rendering one min/max band pair per item (two stroked series of the same colour plus a filled band at 15% opacity), with uPlot's own legend panel in a splitter pane beside the plot. The legend carries the swatches, labels and live values; its width is shared by all three charts, so dragging one divider moves them together. Empty-state overlay — in order: “No project loaded”; “Pick a property to inspect” (Color Index with no key chosen); “No mission data” when the fetch returned none; “No physics data” when every item's min / max arrays are all NaN, which is what Availability looks like without a physics licence. Behavior Windowed fetch. Only the ClStrip.GetDispBegin() .. AbsDispEnd window is fetched, at a bucket count matching the chart's pixel width. The server-side ClStrip.GetMinMaxList(threshold, itemCount) handles down-sampling. Pointer interactions — every one of them writes the shared ClStrip, so a gesture on one chart moves all three: wheel over the plot area → POST /api/execution/cl-strip/wheel with scale = Math.pow(1.05, deltaY * 1/166) + xPositionPercentage. Right / middle-button drag → POST /api/execution/cl-strip/pan with accumulated xOffsetPercentage. Frame-batched via requestAnimationFrame. Pen drags also pan without a button modifier. Left-button drag → a rubber-band x-range zoom: a translucent band tracks the drag over the plot area and the release POSTs the swept fractions to /api/execution/cl-strip/zoom-range. A drag under 6 px, or under half a percent of the plot width, is discarded so the trailing click selects a step instead — which is what makes click-to-select survive an unsteady hand. The gesture is mouse-only. Left click → POST /api/execution/cl-strip/select-step with the nearest bucket's original step index (via chart.valToPos reverse lookup). A click that ended a pan or a zoom drag is ignored. Touch → one finger pans, a second finger converts the pan into an x-axis pinch-zoom; the trailing synthetic click is swallowed so panning past a step never selects it. Mouse move (debounced 80 ms) → POST /api/execution/cl-strip/enter-step for hover, which is also what fills the group bar's cursor readout. Live refresh. useClStripHub subscribes to DispRangeChanged (re-fetch when anyone else zooms / pans) and Updated (coalesced re-broadcast while a mission is running). A rising edge on the execution status hub's hasProject also triggers a refetch. Client-side debounce. BaseStripChart.load() is debounced 50 ms on the client so a burst of Updated events during a fast-running mission coalesces into one fetch. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/execution/charts/StripChartGroupBar.vue — the group bar over the three charts. wwwroot-src/src/components/execution/charts/BaseStripChart.vue — shared strip-chart skeleton. wwwroot-src/src/components/execution/charts/UplotChart.vue — uplot wrapper. wwwroot-src/src/components/execution/charts/PluralStripAvailabilityChart.vue — availability chart. wwwroot-src/src/components/execution/charts/PluralStripRoughnessChart.vue — surface-roughness chart. wwwroot-src/src/components/execution/charts/StripIndividualChart.vue — aspect-picker individual chart. wwwroot-src/src/api/clStrip.ts — typed REST wrappers for the range calls. wwwroot-src/src/composables/useClStripHub.ts — singleton hub wrapper (the same ref-counting pattern as the other execution hubs). Execution/ExecutionChartsController.cs — strip-chart data: GET /api/execution/strip-chart?aspect=Availability|SurfaceRoughness|Individual&xValueCategory=IndexByTime|IndexByStep&widthHint=…&dispBegin=…&dispEnd=…&inspectingKey=… → { xs, indexes, items:[{ key, label, unit, min, max }], isXTicksRangeMode, dispBegin, absDispEnd, count }. The Color Index chart's picked key rides the inspectingKey query parameter of that same call. GET /api/execution/strip-chart-item-config and GET /api/execution/color-guide — the per-item display config and the colour legend. Execution/ClStripController.cs — range manipulation at /api/execution/cl-strip/* (the server-side counterparts of the pointer handlers above): GET range — snapshot { dispBegin, absDispEnd, count, selectedIndex, enteredIndex }. POST disp-range body { dispBegin, dispEnd }, and POST zoom-range. POST wheel body { scale, xPositionPercentage, xValueCategory }. POST pan body { xOffsetPercentage, xValueCategory }. Legacy feelingRatio=2. POST select-step body { stepIndex } → ClStrip.SetSelectedPos(...). POST enter-step body { stepIndex } (nullable) → ClStrip.SetEnteredPos(...). Execution/ClStripHub.cs + Execution/ClStripBroadcastService.cs — SignalR at /clStripHub. Broadcasts DispRangeChanged(snapshot), StepSelected({ stepIndex }), StepEntered({ stepIndex }), Updated(snapshot). A single-flight Interlocked mutex coalesces re-broadcasts; the client debounce handles the rest of the rate-limiting. See Also Execution Page — the page whose Strip Charts column hosts these charts Cycle-Line Charts — per-selected-step charts that share the same uplot engine Execution Extended RenderingCanvas Tool Bar — the tool-path display this column's Fit View acts on Watching the Run — the task this column serves, with the pointer contract read as a procedure"
  },
  "anatomy/general-setup/background-coolant.html": {
    "href": "anatomy/general-setup/background-coolant.html",
    "title": "Background / Coolant | HiAPI-C# 2025",
    "summary": "Background / Coolant Background and Coolant are two leaves of the General Setup page's Control Tree (/general-setup?tree=equipment/background, /general-setup?tree=equipment/coolant), sitting directly under the General Setup group between Spindle Capability and Fixture. They are two tree items rather than a page, so the older /equipment/background-coolant path redirects onto the Background leaf. Both are served by one panel component, which branches on the selected node's role path. They edit the thermal condition on the project's authored equipment face, SetupEquipment, reached as SetupEquipment: BackgroundTemperature_C (Background leaf) the whole CoolantHeatCondition (Coolant leaf) — file-first, see below Key Model: SetupEquipment (+ its CoolantHeatCondition). Layout Background leaf — equipment/background, item type ThermalCondition Background Temperature NumberField (°C) — BackgroundTemperature_C. Coolant leaf — equipment/coolant, the same item type and the same panel (file pick on top, properties below, as on the workpiece material leaf) “Not attached” badge — visible until the first coolant-related save (see Lazy CoolantHeatCondition creation below). File row — FilePathInput (.CoolantHeatCondition, resource subfolder CoolantHeatCondition): a Select dropdown button whose menu holds Browse…, Browse Resource… and — only while a file is set — Clear, beside a read-only path input; it loads a saved condition by named root. A Save As… button follows it, prompting for a project-relative file to export the current condition to. Tracked in CoolantHeatConditionFile. The three standard cooling types ship as ready-made files in HiNc-Resource (Resource/CoolantHeatCondition/StandardForcedAir.default.CoolantHeatCondition, StandardOilBasedCoolant.default.CoolantHeatCondition and StandardWaterSolubleCoolant.default.CoolantHeatCondition), so Browse Resource… starts populated like the workpiece-material picker — picking a shipped file is the cooling-type selection. Name / Note — read-only mirror of the loaded condition. Property fields (always visible, under Name / Note): Coolant Temperature (°C) — CoolantTemperature_C. Flood Convection Coefficient (W/(m²·K)) — CoolantConvectionCoefficient_Wdm2K, min: 0. Mist / Flood Ratio — MistFloodConvectionRatio, min: 0. Off (Air) Convection Coefficient (W/(m²·K)) — OffConvectionCoefficient_Wdm2K, min: 0. Both leaves, with no project open: every control is disabled and a “no project — open one first” caption is shown. The panel fetches the snapshot itself on mount and gates on its hasEquipment flag, so the tree host holds no state for either leaf. Behavior File-based conditions (WorkpieceMaterial pattern). Picking a .CoolantHeatCondition file installs it as the whole condition (XFactory.GenByFile); Save As… exports the current values and renames the condition after the file (IPreferredFileName). While CoolantHeatConditionFile is set, the project save externalizes the condition as <CoolantHeatCondition><XmlSource>relPath</XmlSource></CoolantHeatCondition> and regenerates the side-file (a resource pick is copied into the project on save); with no file the bare inline shape is kept byte-compatible. Coefficient edits tune this project's copy. The static presets on CoolantHeatCondition (StandardPresets / ApplyPreset / MatchStandardPreset) are the API-side source the shipped files are authored from. The file row's Clear entry does nothing here. FilePathInput reports a clear by emitting update:modelValue(null), and this panel binds the widget's value one-way and listens only for picked — so the entry is rendered, is clickable while a file is set, and drops nothing. Clearing the tracked file is therefore not reachable from this leaf at all; the reference changes only by loading another file or by a Save As. The .default marker never survives a user save. The shipped resource files carry a .default ownership marker in their names. The Save As… prompt strips it from its prefill, and the controller strips it again from the name it stamps on the condition, so a user save cannot mint a file that masquerades as a shipped default. The “not attached” badge is unreachable, and the lazy creation behind it never fires. SetupEquipment initializes CoolantHeatCondition at its declaration and nothing assigns null to it — the project-XML read replaces the instance only when the element is present — so the controller's hasCoolant, which is a null test on that property, is true whenever a project is open. The badge is therefore rendered only in the no-equipment case the panel already covers with its own caption, and the null branch each scalar PUT carries is defensive rather than reached. What a fresh project actually carries is the class defaults, which are the water-soluble preset's values. Celsius is the wire format. CoolantHeatCondition stores Kelvin internally but exposes _C accessors that handle the conversion, and the DTO carries Celsius. Finite values only. Every field handler drops a null or non-finite entry before any request is made, so Infinity never reaches these endpoints even though the numeric widget can parse it. Background and coolant temperatures accept negatives (e.g. -40 °C for cryogenic coolant); the three convection fields are clamped to min: 0. The run sees it at once. The background-temperature write, all four condition scalars and the file load each end in the project service's ForwardSetupEnvironmentToExecution, which stamps the background temperature and the condition reference onto the runtime equipment face — including the lazily created condition, which otherwise would exist only on the authored side. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/ThermalConditionPanel.vue — the one panel both leaves share, branching on the node's last role-path segment: Background renders the single temperature field, Coolant the not-attached badge, the file row, the read-only Name / Note and the four property fields. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — declares the two ThermalCondition leaves (equipment/background, equipment/coolant) under the General Setup group, with no host-level init state. wwwroot-src/src/components/controlTree/itemTypes.ts — registers the ThermalCondition item type against that panel: no child tree, no geometry-cache chain. wwwroot-src/src/components/widgets/FilePathInput.vue — the file row widget: Browse… / Browse Resource… (opening at the CoolantHeatCondition resource subfolder) / Clear. wwwroot-src/src/components/widgets/NumericInput.vue — the numeric field used by every value on both leaves, and the source of the min: 0 clamp on the three convection fields. wwwroot-src/src/api/backgroundCoolant.ts — typed client for /api/mech/background-coolant/*: the flat snapshot, the load / save-as pair, and the five scalar PUTs. wwwroot-src/src/router/routes.ts — carries the equipment/background-coolant redirect, which lands on general-setup?tree=equipment/background. Mech/BackgroundCoolantController.cs — REST surface at /api/mech/background-coolant over the authored equipment face: GET / — flat snapshot { hasEquipment, backgroundTemperature_C, hasCoolant, coolantTemperature_C, coolantConvectionCoefficient_Wdm2K, mistFloodConvectionRatio, offConvectionCoefficient_Wdm2K, coolantName, coolantNote, coolantHeatConditionFile }. POST /load, POST /save-as — { rootName, relFile }: install a .CoolantHeatCondition file / export the current condition. Both resolve the path under the named root and refuse anything that escapes it, and both record the result in CoolantHeatConditionFile as a project-relative path when it lands under the project. Save-as appends the extension when it is missing and renames the condition after the file (IPreferredFileName) with the .default marker stripped. PUT /background-temperature-c — set BackgroundTemperature_C. PUT /coolant-temperature-c, PUT /coolant-convection-coefficient-wdm2k, PUT /mist-flood-convection-ratio, PUT /off-convection-coefficient-wdm2k — the four condition scalars, all through one helper that lazy-creates the condition when absent, writes it, and forwards to the runtime face. HiAPI Engine HiMech/Physics/CoolantHeatCondition.cs — the model: Kelvin storage with _C accessors, the flood / mist-ratio / off convection coefficients, Name and Note with PreferredFileName, and the StandardPresets / ApplyPreset / MatchStandardPreset statics behind the shipped resource files. HiMech/Machining/MachiningEquipmentUtils/SetupEquipment.cs — the authored equipment face that owns the background temperature, the condition and its file reference, and externalizes the condition to the side-file when that reference is set. See Also Spindle Capability — sibling equipment editor, editing the same authored equipment face. Coolant (manual) — the end-user task: picking a cooling type in the application. Coolant Model — what the values on this panel mean, which one a running program applies, and how the condition is stored."
  },
  "anatomy/general-setup/controller/brand-matrix.html": {
    "href": "anatomy/general-setup/controller/brand-matrix.html",
    "title": "Brand Matrix | HiAPI-C# 2025",
    "summary": "Brand Matrix The Controller branch is the one branch of the equipment tree whose node set is not fixed: it is grown from a snapshot of the active NC runner, and a node whose backing dependency the runner does not resolve is never created at all. This page is the index of every node that branch can grow, and it owns no node of its own — the ids it lists sit under ?tree=equipment/controller on /general-setup, on two plane stems, equipment/controller/machine and equipment/controller/program-data. Important Anatomy makes no claim that any id named here is stable across versions. The migration hop that keeps an older ?tree= value resolving is described in Tree Ids and Routes. What Decides the Shape One request returns a flat snapshot of the active runner: the brand marker, the chain-driven axis list, and a set of presence flags. Each flag is a type probe over the runner's proxy-resolved dependency list — GetEffectiveNcDependencyList(API), so what is probed is the concrete table a proxy stands in for, never the proxy. Every gate the tree reads tests a single type; two of the fields no component reads test a pair instead. The branch builder reads that snapshot once per build and pushes a node for each flag that reads true. A node that fails its gate is absent, not hidden and not disabled; the branch is regrown from a fresh snapshot whenever a panel swaps the runner. How a branch is built, rebuilt and selected is the Control-Tree engine's own subject — see Control Tree. Five brands ship as presets: Fanuc, Siemens, Heidenhain, Syntec and Mazak. Each is a property on the engine's runner type returning a fresh instance whose dependency list is written out literally, so what a brand grows is decided by that list and by nothing else. The snapshot also carries one non-boolean field that changes a panel rather than the tree. workCoordinateKind names which storage model backs the work coordinates, by a type switch over the first IIsoCoordinateConfig in the effective list: fanuc on Fanuc and Mazak, syntec on Syntec, siemens on Siemens (the frame table precedes the machine-data table, which is not an ISO coordinate provider), heidenhain on Heidenhain, and none when nothing resolves. Its generic arm answers for the brand-neutral IsoCoordinateTable, which no brand preset carries — it is reachable only from a runner that already holds one, so the arm is defensive rather than dead. The Fixed Core Both plane stems are the builder's return value rather than gated entries, so they appear together whenever a runner resolves, and neither is ever empty: each carries leaves that no flag guards. Both are Group stems, so each renders an intro line and a clickable child list rather than a field editor. The machine plane's ungated leaves are Controller Brand, Machine Limits (Stroke), Rapid Feedrates, Home / G28 Reference, Tool-Change Position and Controller Parameters. The program-data plane's are Work Coordinates (G54…) and Tool Offsets. Nothing in that core is gated, so no dependency decides whether those leaves exist — the builder pushes them whatever resolves. What the preset lists decide is whether they have anything to show, and on every brand they do. ControllerParameterTableBase declares the machine-config interfaces itself — home reference, axis set, rapid feedrates, stroke limits, spindle control, M-code declarations and the tool-change trigger — and every brand's parameter table derives from it, which covers the limits, rapid, home and parameters leaves at once. The other two read dependencies each preset carries in its own right: CncBrandDependency behind Controller Brand, and ToolingMcConfig behind Tool-Change Position. On the program-data plane, every preset proxies the generic ToolOffsetTable, and each brand supplies an ISO coordinate provider of its own. The axis names the per-axis leaves list are the parameter table's own axis entries, which the machining chain adds to and re-types when a machine tool is attached — it sets a type per chain axis and removes nothing, so an attached chain yields the union of the two sets rather than a replacement. Each brand's default table already seeds a linear X, Y and Z, so those rows are populated before any chain is wired. With No Runner The builder returns an empty child list, so both stems and every leaf disappear and only the branch root survives. Its editor is the runner root panel, which then shows an hourglass over “No NC controller runner on this project.” and a hint pointing at the ⋮ menu's Load command; the brand badge is dropped and the file caption reads “No NC runner”. The same empty list is returned when the snapshot request throws, so a failed fetch and a genuine absence produce an identical tree shape, and the root panel renders the same hourglass block for both. What separates them is transient and comes from elsewhere: the shared snapshot's own failed read resets it to the empty value and raises an error toast. That read is a separate request from the builder's, so the two can disagree — a branch collapsed by a thrown build fetch can sit under a root panel still showing the brand badge of a snapshot that loaded. Every leaf panel still opens with its own guard on the same flag, rendering the shared empty body “No NC runner — load a project first.” Since a leaf node is built only when the snapshot already reported a runner, that guard is a live defence against the shared snapshot emptying under a mounted panel — closing the project does exactly that — rather than a state reached by navigating. The Matrix Keyed on the node id, because one tree label is itself conditional: the generic tool-offsets leaf is relabelled when the Siemens $TC_DP table resolves, so an index keyed on labels would be conditional on the very thing it indexes. Rows are in the order the builder pushes them. Machine-plane rows name the page that documents the node. The program-data leaves have no page of their own, so those rows point at the Layout section below, which names every one of them in tree order. Node id Tree label Gate Dependency probed Brands Documented by equipment/controller/machine/brand Controller Brand always — all five Controller Brand equipment/controller/machine/limits Machine Limits (Stroke) always — all five Per-Axis Tables equipment/controller/machine/rapid Rapid Feedrates always — all five Per-Axis Tables equipment/controller/machine/home Home / G28 Reference always — all five Per-Axis Tables equipment/controller/machine/tool-change Tool-Change Position always — all five Per-Axis Tables equipment/controller/machine/parameters Controller Parameters always — all five Interface Parameters equipment/controller/machine/m-codes M-Code Declarations hasNativeTable ControllerParameterTableBase all five M-Code Declarations equipment/controller/machine/canned-cycle Canned Cycle (Peck) hasCannedCycle ICannedCycleConfig all five Interface Parameters equipment/controller/machine/block-skip Block Skip / Delete hasBlockSkip IBlockSkipConfig Fanuc, Siemens, Syntec, Mazak Program Reading equipment/controller/machine/subprograms Subprogram Folders hasSubprogramFolders SubProgramFolderConfig all five Program Reading equipment/controller/machine/indexing-positions Indexing Position Tables hasIndexingTables SiemensMachineDataTable Siemens Indexing Position Tables equipment/controller/machine/native Parameters (Native) hasNativeTable ControllerParameterTableBase all five Native Parameters equipment/controller/program-data/work-coordinates Work Coordinates (G54…) always — all five Layout below equipment/controller/program-data/tool-offsets Tool Offsets, read as Tool Offsets (ISO G43 H) under hasSiemensToolOffsets always; label switched by hasSiemensToolOffsets — all five Layout below equipment/controller/program-data/siemens-tool-offsets Tool Offsets ($TC_DP) hasSiemensToolOffsets SiemensToolOffsetTable Siemens Layout below equipment/controller/program-data/tool-names Tool Names hasSiemensToolOffsets SiemensToolOffsetTable Siemens Layout below equipment/controller/program-data/datum-presets Datum Presets (Q339) hasDatums HeidenhainDatumTable Heidenhain Layout below equipment/controller/program-data/datum-shifts Datum Shifts (D) hasDatums HeidenhainDatumTable Heidenhain Layout below equipment/controller/program-data/frames Frames (Siemens) hasFrames SiemensFrameTable Siemens Layout below equipment/controller/program-data/retained-variables Retained Common Variables hasRetainedVariables RetainedCommonVariableTable Fanuc, Syntec, Mazak Layout below equipment/controller/program-data/r-parameters R Parameters hasRParameters SiemensRParameterTable Siemens Layout below Three gates never read false on a shipped preset. hasNativeTable is true wherever any brand parameter table resolves, which every preset provides. hasSubprogramFolders is true because every one of the five lists carries SubProgramFolderConfig. hasCannedCycle is true on Fanuc and Mazak through FanucParameterTable, on Syntec through SyntecParameterTable, and on Siemens and Heidenhain through the FallbackConfig those two presets carry. So M-Code Declarations, Parameters (Native), Canned Cycle (Peck) and Subprogram Folders are gated in code and unconditional in practice — they can only go missing on a runner composed by hand or loaded from a file. Two answers are decided by list order, not only by membership, because the snapshot takes the first match rather than any match: the parameter table behind hasIndexingTables and the ISO coordinate provider behind workCoordinateKind are both first-of-type lookups over the effective list. Each has exactly one candidate in every shipped preset, so order settles nothing there; it becomes load-bearing only on a runner carrying two. The Flag That Does Double Duty hasSiemensToolOffsets is the only flag that both adds nodes and rewrites one. It adds Tool Offsets ($TC_DP) and Tool Names, and at the same time switches the ungated tool-offsets leaf from the label key softNc.node.toolOffsets to softNc.node.toolOffsetsIsoH, so the row reads “Tool Offsets (ISO G43 H)” instead of “Tool Offsets”. The node id is untouched by the relabel. The reason is that the two ledgers coexist on Siemens — the (T,D)-keyed $TC_DP table beside the single-index ISO G43 H table — and an unqualified “Tool Offsets” would blur them into one. The One Brand-Shaped Hole Block Skip / Delete is the only node that exists on four brands and not the fifth. GenericBlockSkipConfig is the sole implementer of IBlockSkipConfig in the engine, and the Heidenhain preset is the one brand list that does not carry it. Reads of the block-skip endpoint answer absent there, and writes answer unsuccessful with a message naming the missing dependency. Mazak Resolves the Fanuc Table The Mazak preset's dependency list differs from the Fanuc one only in the brand token it carries: it proxies the same Fanuc parameter table. Both proxies resolve the same concrete per-case table, so every downstream consequence follows — the same native parameter numbering and prefix, the same fanuc work-coordinate storage model, and the same rows under a Mazak brand badge. It is also the one brand pair whose per-case parameter table survives a switch between them, because the sweep that removes tables the new runner references through no proxy finds this one still referenced. Flags Computed and Read By Nothing Five snapshot fields are computed by the web service, typed and parsed by the client, and read by no component. They stay part of what the endpoint returns, so a client other than this one still receives them. hasProject — a null check on the loaded project rather than a dependency probe. It is the only field the early-return snapshot sets when no runner resolves. The panels gate on the runner flag instead, and the shared state watches the project store directly. hasCutterComp — would report a cutter-comp startup type on the Fanuc and Syntec tables. hasToolAxisDirection — would report a tool-axis-direction parameter on the Heidenhain table. hasIterationGuards — would report the iteration guards. nativeIdPrefix — # on Fanuc and Mazak, Pr on Syntec, MD on Siemens, MP on Heidenhain. The screen gets the other four elsewhere. The controller-parameters panel shows its cutter-comp, tool-axis and iteration-guard controls only where its own read returns a non-null value for each, and the native-parameters panel renders the prefix from its own read, which recomputes the same switch server-side. Two of the snapshot's own doc comments disagree with the code that ships, and the code is what the tree obeys. The subprogram-folder flag is annotated as a Fanuc-family trait. All five presets carry the folder config: the Siemens entry is the L-call lookup root and the Heidenhain entry the CALL PGM lookup root, each with its own comment saying so. The node grows on every brand. The iteration-guard flag is annotated as the Fanuc GOTO / WHILE-DO guards. The probe also matches the Siemens jump guard, and matches neither HeidenhainGotoIterationDependency — which the Heidenhain preset does carry — nor the Fanuc WHILE-DO guard. The flag would therefore misreport Heidenhain even if something read it. What This Table Cannot Check The two halves of every brand column live in different repositories and nothing in either build joins them. The flags are computed in the web service. The snapshot builder in Mech/SoftNcRunnerController.cs holds one probe per flag. Changing a probe's type, or reordering the first-of-type lookups it depends on, moves a whole row of this table. What each brand carries is written in the engine. The five brand presets in HiMech/NcParsers/SoftNcRunner.cs are literal dependency lists. Adding or removing one entry changes a brand column here, with no compile error and no failing test to mark it. The brand columns above are read from those preset lists. Re-deriving them means diffing those two files against each other — the probe list on one side, the five preset lists on the other — and nothing else reports the drift. Two narrower falsifiers sit under the same join. The interface list on ControllerParameterTableBase is why the machine plane's ungated leaves have a live table behind them on every brand; if a brand table ever implements IBlockSkipConfig, the Heidenhain hole closes silently. And the label strings in the English locale bundle currently match the hard-coded labels in the branch builder one for one; the tree renders the label key, so a drift there changes what the tree reads without changing any id in this table. Layout Control Tree — the General Setup root Controller Node Row — the branch root; its editor carries the Object-Management ⋮ button, the brand badge and the runner-file caption, or the hourglass no-runner block Machine / Controller Group Stem — intro line plus a clickable list of its children Controller Brand Node Row Machine Limits (Stroke) Node Row Rapid Feedrates Node Row Home / G28 Reference Node Row Tool-Change Position Node Row Controller Parameters Node Row M-Code Declarations Node Row — gated Canned Cycle (Peck) Node Row — gated Block Skip / Delete Node Row — gated; absent on Heidenhain Subprogram Folders Node Row — gated Indexing Position Tables Node Row — gated; Siemens only Parameters (Native) Node Row — gated Program Data Group Stem — intro line plus a clickable list of its children Work Coordinates (G54…) Node Row Tool Offsets Node Row — reads Tool Offsets (ISO G43 H) where the Siemens $TC_DP table resolves Tool Offsets ($TC_DP) Node Row — gated; Siemens only Tool Names Node Row — gated; Siemens only Datum Presets (Q339) Node Row — gated; Heidenhain only Datum Shifts (D) Node Row — gated; Heidenhain only Frames (Siemens) Node Row — gated; Siemens only Retained Common Variables Node Row — gated; absent on Siemens and Heidenhain R Parameters Node Row — gated; Siemens only The rows marked gated are the ones this page's table keys; the rest are the fixed core. Every row is a plain label with no icon and no checkbox, since the tick column belongs to the mission branch alone. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/softNcItemTypes.ts — the branch builder: it mints every node id in the table above, holds each leaf's gate, carries the tool-offsets relabel, and returns an empty child list both when no runner resolves and when the snapshot request throws. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — declares the equipment/controller root that prefixes every id in the table, and rebuilds the branch when a panel reports a structural change scoped to it. wwwroot-src/src/api/softNcRunner.ts — the snapshot type, its empty value and its parser; the five fields with no reader are declared, defaulted and parsed here. wwwroot-src/src/composables/useSoftNcRunner.ts — the shared snapshot the leaf panels gate on, the project watch that empties it, and the brand switch and Object-Management install that re-read it. wwwroot-src/src/components/controlTree/SoftNcRunnerRootPanel.vue — the branch root's editor and the no-runner block the branch collapses to. wwwroot-src/src/components/controlTree/SoftNcEmptyState.vue — the shared no-runner body every leaf panel falls back to. wwwroot-src/src/components/controlTree/SoftNcWorkCoordinatesPanel.vue — the one consumer of the snapshot's work-coordinate kind. wwwroot-src/src/components/controlTree/SoftNcControllerParamsPanel.vue — gates the cutter-comp, tool-axis and iteration-guard controls on its own read rather than on the snapshot flags. wwwroot-src/src/components/controlTree/SoftNcNativeParamsPanel.vue — renders the native id prefix from its own read. wwwroot-src/src/i18n/en/softNc.ts — the node label strings the tree renders, the two group intros, and the empty-state bodies. Mech/SoftNcRunnerController.cs — builds the snapshot: one probe per flag over the proxy-resolved dependency list, the early-return form used when no runner resolves, and the brand switch that swaps the whole runner and sweeps the orphaned per-case tables. HiAPI Engine HiMech/NcParsers/SoftNcRunner.cs — the five brand presets as literal dependency lists, and the proxy resolution every flag probe reads through. HiMech/NcParsers/ControllerPresetWriter.cs — the brand token list and the factory that turns one token into a preset runner, for the shipped preset files. HiMech/NcParsers/Dependencys/ControllerParameterTableBase.cs — the machine-config interfaces every brand table inherits, which is why the machine plane's ungated leaves have data on all five brands. HiMech/NcParsers/Dependencys/CncBrandDependency.cs — the brand marker the snapshot reports, and the five brand tokens. HiMech/NcParsers/Dependencys/Generic/GenericBlockSkipConfig.cs — the sole implementer of the block-skip interface, and therefore the whole reason one node is missing on one brand. HiMech/NcParsers/Dependencys/Generic/FallbackConfig.cs — the peck-retraction provider that makes the canned-cycle gate true on the two brands whose own table has none. HiMech/NcParsers/Dependencys/Generic/SubProgramFolderConfig.cs — the folder config every preset carries, against the snapshot comment that calls it a Fanuc-family trait. HiMech/NcParsers/Dependencys/Fanuc/FanucParameterTable.cs, HiMech/NcParsers/Dependencys/Syntec/SyntecParameterTable.cs, HiMech/NcParsers/Dependencys/Siemens/SiemensMachineDataTable.cs, HiMech/NcParsers/Dependencys/Heidenhain/HeidenhainParameterTable.cs — the four brand tables and the extra interfaces that decide the canned-cycle, indexing and work-coordinate answers. HiMech/NcParsers/Dependencys/Fanuc/FanucParameterTableProxy.cs — the per-case resolution the Fanuc and Mazak presets share, which is why those two survive each other's brand switch. See Also Controller Branch — the branch this table indexes, its two planes and the runner behind them Editing Contract — the rules every leaf panel in this table obeys when it reads, commits and rolls back Machine and Controller Plane — the machine plane, whose leaves make up most of this table Program Data Plane — the program-data plane, whose per-case leaves are the rest of this table's rows Controller Brand — the control that changes which rows of this table exist, and what it resets on the way Per-Axis Tables — the four ungated per-axis leaves: stroke limits, rapid rates, home reference and the tool-change position Interface Parameters — the interface parameter form and the canned-cycle leaf, two of the rows above M-Code Declarations — the M-code declaration leaf, gated by the native-table flag Program Reading — the block-skip and subprogram leaves, and the one gate that switches a node off for exactly one brand Indexing Position Tables — the one row that appears on a single brand only Native Parameters — the native parameter form behind the id prefix this page reports as unread Hidden Controller Branches — the other kind of withheld node: the two equipment branches a device preference hides, which a link can reveal where none of these can"
  },
  "anatomy/general-setup/controller/editing-contract.html": {
    "href": "anatomy/general-setup/controller/editing-contract.html",
    "title": "Editing Contract | HiAPI-C# 2025",
    "summary": "Editing Contract Every leaf of the Controller branch edits a different table, and almost all of them edit it the same way. This page is that shared way: what a leaf panel fetches, when an edit commits, what a failed write does, what a panel shows while its table is absent, and what it never notices. It owns no Control-Tree node of its own — it holds over every panel of the Controller branch on /general-setup: the root at equipment/controller, and every leaf beneath equipment/controller/machine and equipment/controller/program-data. Each leaf page can then state only what is its own. The last section is the other half of the contract: every panel that departs from it. Important Anatomy makes no claim that these ids are stable across versions. See Tree Ids and Routes for the migration hop that keeps an older link resolving. The Shape of a Leaf Panel Each leaf panel takes one prop, the tree node, and reads the shared runner snapshot through a module-singleton composable whose installer it calls synchronously while its script runs rather than on mount. The installer is idempotent, so whichever panel mounts first pays for it and the rest get the cache. Only four panels read the node prop at all: two use its id to tell apart the sibling leaves they serve, and two use it as the scope of the structural change they report. Beyond that shared snapshot, a panel owns its own table. It imports its reader and its setters directly from the branch's typed API module and fetches once, in onMounted. There is no store, no request queue and no batch: one panel, one read, one table. The two panels that fetch nothing — the branch root and Controller Brand — are exactly the two that have no table of their own and render off the snapshot alone. How the branch itself is built, rebuilt and selected belongs to the Control-Tree engine and is described in Control Tree. Only one panel is mounted at a time. The editor row's remount key is composed from the node id, the node key and the mission stamp; controller nodes carry an empty key and no mission record, so the key reduces to the node id alone. Moving the selection therefore remounts and refetches; re-clicking the row already selected does neither. No controller item type registers a large content view, so the General Setup content column keeps its own empty hint for every selection in this branch. When an Edit Commits The commit rule is per control kind, and every panel that uses a given kind uses it the same way. Numeric fields are the shared numeric widget, and it commits on blur or on Enter and on nothing else — never per keystroke. Its full contract, including what a bound violation does to the box, is Numeric Input. Three consequences matter here. Enter commits without moving focus, so leaving the field afterwards commits the same value a second time. The widget carries no equality guard, so a field that is focused and left unchanged still emits. And the two halves of the rule are not wired alike: blur is the input component's own event and is raised only while the field is editable, whereas Enter is a plain listener on the underlying element and still fires on a read-only one — which is why a read-only cell can still commit. Checkboxes, toggles and selects commit immediately, on the click or the pick. That covers the block-skip layer boxes, the tool-change Stays put box, the M-code tool-change box and its Spindle and Coolant selects, the tool-word trigger toggle, the cutter-compensation and tool-axis selects, and the tool-offset Set ideal offset dependent on tool house toggle. Plain text fields have no shared widget and are wired twice over. The M-code Not-simulated note commits on the field's own change event, which carries the string and fires on Enter or on leaving a changed field. The two subprogram folder inputs bind blur and Enter explicitly, and commit as a pair. Row actions — the datum reset-to-zero button, the work-coordinate P0 and M0 buttons, a delete button, an add button — commit on the click, and are not optimistic: they write first and touch the local rows only after the request resolves. Two panels do not commit per control at all; they stage a draft behind an explicit button, and both are named below. The Optimistic Write A per-control commit follows one fixed shape. The handler captures the current value, assigns the new one so the screen updates at once, awaits the setter, and on failure restores the captured value and raises a toast. Nothing is queued and nothing is retried. Two details of that shape are easy to misread from the screen: The write is row-scoped even though the handler is per cell. Editing one cell of a work coordinate, a datum row, a frame or a tool-offset row sends the whole row or the whole XYZ triad as it stands after the edit. An M-code edit likewise sends all four declaration fields, which is why the wire format is a whole-declaration replace rather than a patch. The rollback restores what the handler captured, which is usually narrower than what it sent. A work-coordinate, datum, frame or tool-offset handler captures the one cell it edited and puts back only that, though the request carried the whole row. Three handlers capture the whole set they send and restore it intact — the M-code declaration row, the tool-change Stays put pair, and the two subprogram folders. Either way, a failure the server had partly applied leaves the two sides disagreeing; the panel's recovery is the toast and a later remount, not a re-read. Adds and removes are outside this shape, and the local rows never move before the request resolves. Two panels then append the returned row themselves — the generic tool-offset table and the Siemens $TC_DP table, the two whose add hands back a freshly minted key. The other five re-read their whole table instead: M-Code Declarations, Tool Names, R Parameters, Retained Common Variables and Parameters (Native). A delete usually filters the row out in place; Parameters (Native) re-reads there too. Three deletions are guarded by a confirmation dialog first: a tool-offset row, a Siemens $TC_DP row, and a native parameter. M-code declarations, tool names, R parameters and retained common variables delete on the click with no confirmation. When a Write Fails The branch's REST surface answers a missing dependency inside a success envelope rather than with an error status: the dependency lookup returns HTTP 200 carrying success: false and a message naming the type it could not find, such as No IStrokeLimitConfig on the active runner, and an exception raised inside the same lookup is reported the same way. The shared fetch helper turns both a non-2xx status and a success: false body into a thrown error, so a panel cannot tell the two apart; the first arrives with the status prefixed to the message, the second as the server's own sentence. What the user sees is one negative toast, three seconds, composed as the panel's localized context followed by the raw server message — the locale bundle stores each error key as the bare context and the code appends the separator and the message. A failed write leaves no inline error state, no retry affordance and no dirty marker: once the toast expires, nothing on screen records that it happened. (The unsaved badge and the staged-brand banner on the two draft panels mark a pending edit, not a failed one.) A console error accompanies the toast. The server message is not localized. Only a coded error payload can be re-rendered in the app locale, and the envelope this branch answers with carries no code, so its English sentence is appended verbatim under any language. The two writes that replace the whole runner answer with real status codes instead of the envelope: installing one through Object Management, and switching brand. Of the codes they raise, only not found with no project loaded carries the coded payload — the conflict raised rather than swapping the parser under a playing NC program, and the refusals of an unknown key or an unknown brand, are all bare English sentences. One further status code sits on the datum routes, a defensive 400 for a table segment that is neither preset nor shift; the panel sends only those two, so nothing reachable from the branch produces it. The Two Empty Layers A leaf panel opens with two guards, in this order. Layer one is the shared snapshot. The shared empty state renders the single line \"No NC runner — load a project first.\" whenever the snapshot reports no runner. Every leaf panel carries it; the branch root is the one panel that does not, because it renders a richer block of its own. Reaching that line by navigating is not possible: a leaf node is created only when the snapshot already reported a runner, and a deep link naming an id the built tree lacks is refused. The guard is live rather than navigational — it answers the snapshot emptying under a panel that is already mounted, which is what closing the project does. Layer two is the panel's own read. Where the runner resolves but its table does not, the panel renders one line naming the absent table — \"No block-skip config on the active runner.\", \"No Siemens frame table on the active runner.\", \"No tool-offset table on the active runner.\", and so on, one string per table. Three panels key that line on one table: Controller Parameters, M-Code Declarations and Parameters (Native) all gate on the brand's controller parameter table and all render \"No controller parameter table on the active runner.\" Controller Parameters is the loosest fit — its two iteration-guard fields resolve through dependencies of their own, and only its presence flag is the parameter table. Controller Brand, which reads no table, has no second layer at all; every other leaf has one. Only after both guards does the editor body render. One panel keys its second layer on something other than its read's presence flag, and it is named below. What a Mounted Panel Does Not See The shared snapshot is fetched once per load of the application. The installer's flag lives at module scope, so a later call does nothing and only a browser reload starts over, and the snapshot is re-read on exactly three events afterwards: the project store's has-a-project flag turning true, an Object-Management install of a runner, and a brand switch. The flag turning false re-reads nothing — it clears the snapshot in place. No panel re-reads it either; the composable exposes a reload function that nothing in the branch calls. Three consequences follow, and they are the contract's sharpest edges. A project-to-project load does not refresh it. The has-a-project flag is derived from the project path being non-empty, and loading another project assigns the new path directly, so the flag never leaves true and the watch never fires. The page itself is destroyed and rebuilt, because the layout keys its keep-alive on a project epoch — but the rebuilt panels call the same now-idempotent installer, which does nothing. Meanwhile the branch builder makes its own, independent request for the same snapshot, so the tree shape can be built from the new project while every leaf gates on the old one. Nothing pushes changes at a mounted panel. No panel holds a watcher, a poll or a status-hub subscription over its table. A write made by another browser tab, by an NC run, or by the server's own sweep after a brand switch is invisible until the panel is remounted by moving the selection away and back. A panel's own edits do not update the snapshot or the branch. Deleting the last row of a table leaves both the cached snapshot and the tree branch as they were until one of the three refresh events happens. Because the shared snapshot is a reactive reference, a panel does track it live once it changes — but with one panel mounted at a time, the change that matters in practice is a project close. The Table Primitive Where a leaf renders a table it is Quasar's markup table — dense, flat, bordered — with a hand-written header and body and a repeat over the rows. No panel in the branch uses the data-table component, and the four data tables left in the application are the legacy controller tabs this branch supersedes. The practical difference is that these tables have no built-in sort, no pagination and no column menu: what the header says is what the column is. Key columns are rendered as plain text and cannot be edited: the tool and edge numbers of a $TC_DP row, a tool name, an R number, a # variable number, a datum row index, a native parameter id, and the axis names of every per-axis table, which follow the machining chain rather than the panel. The one renameable key is the generic tool-offset row's tool number, and it is guarded against duplicates on both sides of the wire. A table that can grow carries an add control, and the branch spells it three ways. Five carry a true footer below the table — the new row's fields, then a primary button: Add / Set on Tool Names, R Parameters, Retained Common Variables and Parameters (Native), Declare on M-Code Declarations. Two carry a fieldless button in the toolbar above the table instead, because the server mints the key: Add on Tool Offsets and Add Tool on the Siemens $TC_DP table. The last is Add Position on Indexing Position Tables, which appends an empty row to the local draft and sends nothing. Two tables carry a Show all toggle that hides an all-zero extended tail, on Work Coordinates and on Frames. Nothing Guards a Switch Away No panel in the branch registers the Control-Tree host's before-switch gate, and none exposes anything to the host at all. Selecting another node therefore always succeeds immediately. For the per-control panels that is exactly right — every edit is already on the server. For the two draft panels it means an unsaved draft and a staged brand are discarded silently when the selection moves, with no prompt and no warning. Where the Wave Is Not Uniform Everything above is the rule. What follows is every place the branch departs from it, panel by panel. A contract page without this section invites the next editor to tidy it into a uniformity that was never true. Machine Limits / Rapid Feedrates / Home Reference — the presence flag is discarded The axis-table panel serves three leaves and is the one panel whose second empty layer is not its read's presence flag: it keys on the row count instead. The rows and the flag are independent on the server, which builds one row per chain axis whether or not the backing config resolves and reports presence separately. So a runner with axes but no stroke-limit, rapid-feedrate or home config still renders a full, editable table, and every commit fails with a toast naming the missing dependency. What fills the cells differs by leaf: the stroke-limit and home values are nullable and come through blank, while a rapid rate is a plain number the server defaults to 0, so that one leaf shows a table of zeros that never signals the absence at all. Controller Brand — staged, confirmed, and destructive by design Controller Brand is one of two panels with no table read of its own, the only panel with no local error handler, and one of the two whose write replaces the whole runner — the branch root's Object-Management install is the other. The select stages a pending brand rather than applying it; Revert drops the staging, an orange banner spells out what the switch destroys, and Apply brand opens a confirmation dialog before the request. Its failures surface through the shared composable's global notification rather than the panel's own, so the console line names the shared state and not the panel. Controller root — its own empty block, its own toast The branch root panel does not use the shared empty state. It renders an hourglass over its own no-runner title and hint. Its error path also differs: it takes an already-composed string from the Object-Management button, omits the console line, and uses a longer toast than every other panel. Indexing Position Tables — draft, validate, save whole The one draft table. Its numeric cells bind straight into a local draft row with no handler, an unsaved badge appears while the draft differs from what was saved, and nothing reaches the server until the per-table Save Table button, which stays disabled while the draft fails validation. The validation mirrors the endpoint's own rules — a per-table maximum, strictly ascending values, and a 0 ≤ position < 360 range when a modular rotary axis reads the table — and reports the first violation under the table. A failed save deliberately does not roll the draft back: the draft stays dirty so the edit is not lost, which is the opposite of every other panel. Its axis-assignment table above the drafts is display-only. The assignment is not editable on this panel and the endpoint exposes no writer for it; the value is edited as a per-axis integer parameter in Parameters (Native), which is what the panel's own hint says. Subprogram Folders — two fields, one write The two folder inputs are plain text fields committed together on blur or Enter of either one, and the guard against a redundant write is a saved snapshot of both values rather than a per-field captured value. Editing one folder writes both. M-Code Declarations — a third text-commit wiring, and an add that submits on Enter The note cell is the only text cell in the branch that commits through its field's native change event rather than an explicit blur binding or the numeric widget. The timing matches; the wiring is a third variant. This is also the only add-row footer whose input submits on Enter. R Parameters and Retained Common Variables — the two panels that commit a null Every other numeric handler returns early on a null and treats a cleared cell as no edit. These two send the null, because an empty value is a real state in both tables — the vacant entry, which a program reading it reports as an error rather than silently taking as zero. Tool Offsets — a read-only column that still writes, and a two-call rollback With the tool-house dependence on, the two ideal columns are made read-only rather than hidden. A read-only field is still focusable and still takes keystrokes, and the widget's Enter binding is a plain listener on the underlying element rather than the component event blur travels on — so pressing Enter in one of those cells re-sends the whole row unchanged, while focusing it and leaving does not, because a non-editable field raises no blur. The tool number column, by contrast, is swapped for plain text and is genuinely inert. The tool-change position field takes a third route — it is disabled rather than read-only while its axis stays put, and a disabled field takes no keystrokes either. Turning the dependence on also makes two server calls inside one try: the toggle write, then the refresh from the tool house. If the second fails after the first succeeded — the refresh answers unsuccessfully when the project carries no tool house — the catch reverts the local toggle while the server has already committed it. Work Coordinates — the one panel that writes outside the branch Clicking a row picks which coordinate the General Setup canvas marks, and that write goes to the equipment-display surface rather than to this branch's own. It is also the branch's one call through the plain-JSON helper instead of the envelope helper, so only a transport failure throws there. The row click is bound on the whole row with no click-stopping on the cells or the P0 and M0 buttons, so acting anywhere in a row marks it; a same-id short circuit is what keeps cell editing on the marked row from writing again on every pass through. Two truth sources for “this is Siemens” The tree relabels the generic Tool Offsets leaf from the snapshot's $TC_DP flag, while the tool offsets panel shows its ISO-G43-H caveat, and the controller parameters panel picks its macro-guard labels, from the brand string instead. The brand marker is a free-form string that can be edited independently of the dependency list, so the label and the caveat can disagree. The error handler does not agree with itself Every panel that has a local handler composes the same toast through one signature carrying two incompatible conventions. Nine pass a localization key and translate inside the handler; eight pass an already-translated string. Both first parameters are typed as a plain string, so nothing separates the two conventions at compile time. Nothing user-visible changes; the console line does — the key-style panels log the raw key path, the string-style panels log the rendered sentence. The add-row footers disagree on two details Whether Enter submits: only M-Code Declarations binds it. Whether the fields clear after a successful add: M-Code Declarations clears its code, Tool Names clears both fields, and R Parameters, Retained Common Variables and Parameters (Native) leave what was typed in place. A source comment the code contradicts The shared composable's header names the Execution page as the owner of the Controller root. The root is built by the equipment-scoped host, which only the General Setup page creates, so the code is what ships. The shared empty state's comment reads like a second case and is not one: the number in it counts the byte-identical copies its extraction removed, not the call sites it has today, which are one more. Layout General Setup Control Tree — the left dock of /general-setup Editor Row — the panel of whichever controller leaf is selected, one at a time No-Runner Body — \"No NC runner — load a project first.\"; shown first, from the shared snapshot Absent-Table Body — one line naming the table this leaf edits, from the panel's own read Editor Body Description Caption — the leaf's own one-line explanation, above the table Toolbar — where the add button carries no fields: Add on Tool Offsets, Add Tool on the Siemens $TC_DP table, beside that panel's own toggles Table — dense, flat, bordered, no sort and no pagination Header Row — the leaf's own columns, over the shared labels Axis, Id, Value, Unit and Actions Data Row — a bold plain-text key cell, then one editable cell per column, then the row's action buttons Add Row Footer — the new row's fields, then Add / Set or Declare Show all Toggle — Work Coordinates and Frames only, revealing the all-zero extended tail Draft Bar — Add Position, Revert and Save Table with an unsaved badge on Indexing Position Tables; Revert with Apply brand on Controller Brand Toast — negative, three seconds, the panel's context followed by the server's own message Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/composables/useSoftNcRunner.ts — the shared snapshot every panel gates on: the module-scope installed flag, the project-presence watch, the three events that re-read it, the reload no panel calls, and the global notification the brand panel's failures take. wwwroot-src/src/api/softNcRunner.ts — the branch's typed REST wrappers: the snapshot parser, one reader and one setter family per table, and the whole-row payloads the per-cell handlers send. wwwroot-src/src/api/http.ts — the two failure shapes a panel cannot tell apart, and the coded error rendering that a message without a code falls through. wwwroot-src/src/components/widgets/NumericInput.vue — the numeric field: commit on blur or Enter, no per-keystroke emit, no equality guard, and the Enter listener that keeps firing where a read-only field's blur is suppressed. wwwroot-src/src/components/controlTree/SoftNcEmptyState.vue — the shared no-runner line, and the comment that counts the copies its extraction removed rather than its call sites. wwwroot-src/src/components/controlTree/softNcItemTypes.ts — the branch builder: the node ids the two multi-leaf panels discriminate on, and the empty node key that reduces the remount key to the id. wwwroot-src/src/components/controlTree/PrimarySlavePanel.vue — the editor row: the remount key, the one-panel-at-a-time mounting, and the events it wires to the host. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — the before-switch gate no panel in this branch registers, and the rebuild that a reported structural change triggers. wwwroot-src/src/components/controlTree/SoftNcAxisTablePanel.vue — the three per-axis leaves, and the second empty layer keyed on the row count instead of the presence flag. wwwroot-src/src/components/controlTree/SoftNcBrandPanel.vue — the staged select, the revert, the confirmation and the structural change it reports. wwwroot-src/src/components/controlTree/SoftNcRunnerRootPanel.vue — the panel with its own empty block and its own toast shape. wwwroot-src/src/components/controlTree/SoftNcIndexingPositionsPanel.vue — the draft table: the unsaved badge, the client-side mirror of the endpoint's rules, the save that keeps a failed draft, and the display-only assignment column. wwwroot-src/src/components/controlTree/SoftNcSubprogramPanel.vue — the two text fields committed as a pair against a saved snapshot. wwwroot-src/src/components/controlTree/SoftNcMCodesPanel.vue — the change-event text cell, the whole-declaration write, and the only add input that submits on Enter. wwwroot-src/src/components/controlTree/SoftNcToolOffsetsPanel.vue — the read-only ideal columns that still commit, the renameable key with its duplicate guard, and the two-call dependence toggle. wwwroot-src/src/components/controlTree/SoftNcWorkCoordinatesPanel.vue — the row click that writes to the display surface, and the row-scoped triad write. wwwroot-src/src/components/controlTree/SoftNcRParametersPanel.vue and wwwroot-src/src/components/controlTree/SoftNcRetainedVariablesPanel.vue — the two panels that commit a null to vacate an entry. wwwroot-src/src/components/controlTree/SoftNcSiemensToolOffsetsPanel.vue and wwwroot-src/src/components/controlTree/SoftNcNativeParamsPanel.vue — the other two confirmed deletions, and the two add flows that part company: one appends the minted row, the other re-reads the whole table. wwwroot-src/src/components/controlTree/SoftNcToolNamesPanel.vue, wwwroot-src/src/components/controlTree/SoftNcToolChangePanel.vue, wwwroot-src/src/components/controlTree/SoftNcDatumTablePanel.vue and wwwroot-src/src/components/controlTree/SoftNcControllerParamsPanel.vue — the conforming shape: one read on mount, per-control commit, capture-assign-await-restore, one toast. The tool-change Stays put box is the one handler among them that captures and restores a pair of fields. wwwroot-src/src/api/equipmentSetup.ts — the canvas marker id the work-coordinate row click writes, outside this branch's own surface and through the plain-JSON helper. wwwroot-src/src/stores/project.ts — the has-a-project flag the shared snapshot watches, and the direct path assignment that keeps it true across a project-to-project load. wwwroot-src/src/layouts/MainLayout.vue — the project epoch that rebuilds the page without re-running the idempotent installer. wwwroot-src/src/i18n/en/softNc.ts — every empty line, column header, hint and error context this branch renders, and the convention that an error key stores the bare context. wwwroot-src/src/i18n/en/common.ts — the shared column and action labels the tables reuse. Mech/SoftNcRunnerController.cs — the REST surface: the dependency lookup that answers a missing table inside a success envelope, the reads that report presence independently of their rows, the rapid rate defaulted to zero where its config is absent, the two runner-replacing writes that answer real status codes instead, and the datum routes' defensive rejection of an unknown table segment. Common/ApiError.cs — the coded payloads, and why only the no-project answer can be re-rendered in the app locale. See Also Controller Branch — the branch these rules hold across, its two planes and the runner behind them Machine and Controller Plane — the plane whose seven leaf pages this contract lets stay short Program Data Plane — the other plane these rules hold across, whose six leaf pages inherit them the same way Brand Matrix — which leaf exists on which brand, and the snapshot flags the first empty layer reads Numeric Input — the numeric field's own contract: what parses, what the bounds do, and why Enter commits twice Controller Brand — the staged, confirmed, whole-runner write that departs furthest from these rules Per-Axis Tables — the three leaves whose empty layer keys on the row count, and the tool-change position beside them Interface Parameters — the interface parameter form and the canned-cycle field, both plain per-control commits M-Code Declarations — the whole-declaration write and the change-event text cell Program Reading — the block-skip boxes and the paired folder inputs Indexing Position Tables — the draft-then-save table, the one panel that keeps a failed edit Native Parameters — the confirmed deletions and the add-or-set footer that keeps what was typed"
  },
  "anatomy/general-setup/controller/index.html": {
    "href": "anatomy/general-setup/controller/index.html",
    "title": "Controller Branch | HiAPI-C# 2025",
    "summary": "Controller Branch The Controller branch is the SoftNcRunner-native settings face: the controller the project actually parses NC with, edited one tree node at a time. It lives on the General Setup page at /general-setup under the Control-Tree id equipment/controller, and grows two plane stems beneath it — equipment/controller/machine and equipment/controller/program-data. The superseded HardNcEnv surface still ships as a route of its own at /controller, and edits a different model. Important Anatomy makes no claim that these ids are stable across versions. See Tree Ids and Routes for the migration hop that keeps an older link resolving. Key Models NcRunnerSuit — the switchable suit the branch edits: one runner plus the per-workpiece dependency list the runner's proxy placeholders resolve against. A suit constructs on the Fanuc preset, and a project file that carried no runner element keeps that. SoftNcRunner — the NC pipeline itself, and the object the branch root's Object-Management menu loads, pastes and saves. PipelineNcDependencyList — what a runner file carries. PerCaseNcDependencyList — what stays on the project. CncBrandDependency — the brand marker the root panel's badge reads. Its Brand is a plain string with five declared tokens, so the marker can be edited independently of the dependency list it sits in. SoftNcRunner — the facade setter every install and every brand switch assigns through. It re-binds the proxies to the suit, stamps the machining chain's axis codes onto the axis config, and resets the per-session runner state. Every value the branch reads is resolved through GetEffectiveNcDependencyList(API) rather than the raw pipeline list: the proxies deliberately implement no machine-config interface, so a consumer that read the raw list would see a placeholder instead of the table. The tree itself speaks domain vocabulary only — brand, machine limits, work coordinates. The dependency pipeline, the proxy indirection and the brand preset lists have no node. The Two Planes The branch root's children are two Group stems, and neither is ever empty: each carries at least one leaf that every runner grows. A stem's editor panel is the shared group panel — an intro line over a clickable list of its children. Machine / Controller (equipment/controller/machine) introduces itself as \"Machine and controller presets that travel with the runner file — brand, travel limits, rapid rates, home / G28 reference, the tool-change position and the controller parameters (in both a domain-grouped interface form and the native parameter form).\" Program Data (equipment/controller/program-data) introduces itself as \"Data that travels with the workpiece / project — work-coordinate offsets (G54…), tool offsets and the brand-specific per-case tables. Kept on the project even when the runner file is swapped.\" What a runner file actually carries The runner's pipeline list holds two kinds of entry, and the difference decides what an installed runner file changes. Plain instances are the runner's own and are replaced outright by an install: the brand marker, the tool-change position, the block-skip, subprogram-folder and iteration-guard configs a given preset carries, and — on Siemens and Heidenhain — the generic fallback config those two presets add because their parameter tables declare no number for the peck clearance. That last entry is why Canned Cycle (Peck) is runner-owned on those two brands, while on the other three the same clearance is a row of the brand parameter table and stays with the project. The brand parameter table is reached through a proxy instead. The proxy carries a machine-config seed, and that seed — not the live table — is what the runner file serializes. WireNcDependencyProxies(API) deep-clones the seed into the project's per-case list only when the project holds no table of that type yet; a project that already carries one keeps it. So the per-axis limits, rapid rates, home references, M-code declarations and native parameters a panel edits are stored on the project, and installing a same-brand runner file leaves them where they are while it does replace the plain instances above. The Fanuc-family and Syntec parameter tables are per-case because they mix machine configuration with per-case work-coordinate offsets, which the two planes could not otherwise split. The Siemens machine-data and Heidenhain tables hold no work coordinates and are per-case for the other half of the reason: a project's own table wins over the seed, so installing a same-brand runner file re-binds to the machine data already edited instead of resetting it to the preset's. What survives a swap The per-case list belongs to the project and survives an install or a brand switch, minus one step: after the new runner is assigned, per-case tables its proxies resolve nothing for are removed, so a project switched from Fanuc to Siemens does not keep a retained-common-variable table nothing reads. The generic tool-offset table survives every switch, because every brand preset proxies it. Switching back does not restore what the sweep removed. Only the brand parameter table returns from a seed, deep-cloned out of the new preset's proxy; the per-case tables beside it carry no seed at all, so their proxies create bare instances — a project switched back to Fanuc gets an empty retained-common-variable table, not the values it held before. The Root Panel The Controller node's editor is the branch root panel. Its header row carries three things: The Object Management menu (⋮), whose entries are Load, Save As, Copy, Paste and XML Mode. Load and Save As browse the server file system through the shared file-explorer dialog, filtered to *.Controller, *.SoftNcRunner and *.xml; Save As proposes the name NcRunner.Controller. Paste checks the pasted object against the expected type Hi.NcParsers.SoftNcRunner, HiMech. Load, Paste and an XML apply all install the swapped object onto the project and then regrow the branch. The button is disabled while no runner key is indexed, which is the state with no project open; with a project but no runner a blank placeholder is indexed so the menu stays reachable as a Load target. A brand badge, shown only while a runner resolves. It reads the brand marker's string, or Unknown brand when the marker is empty. A runner-file caption. It reads the side-file path recorded on the suit, or Embedded in project when the runner is inlined in the project file, or No NC runner when none resolves. The web service reads that recorded path and never writes it, so a Save As from this menu writes a file without changing what the caption names — and after an Object-Management install or a brand switch the caption still names the file the project was loaded with rather than the runner now in place. Below the separator the panel shows one of two bodies. With a runner it shows the presets hint — \"Machine / controller presets (brand, limits, rapid, home, tool change, parameters) travel with the runner and can be saved / loaded as a .SoftNcRunner asset via the ⋮ menu. Program data (work coordinates, tool offsets…) stays with this project's workpiece. Edit each group via this item's child tree-nodes.\" Both hint blocks name .SoftNcRunner, while the file picker offers .Controller first. An orange line follows when the snapshot reports no axes: \"No machine axes yet — per-axis rows (limits / rapid / home) are driven by the Machine Tool chain. Attach a machine tool to populate them.\" The axis set is read from the controller parameter table's axis-type rows, which the facade setter stamps from the Machine Tool chain — adding the chain's axes and keeping the table's persisted ones. Every brand preset's default table already declares X, Y and Z, so on a preset-built runner the warning does not appear; it is a live guard for a runner whose table declares no axis, or which resolves no parameter table at all. When No Runner Resolves With no project open the host skips the branch builder entirely, so the Controller node stands alone with no children, and the root panel shows its own no-runner block: an hourglass, \"No NC controller runner on this project.\", and the hint \"Load a project, or use the ⋮ menu → Load to attach a .SoftNcRunner file.\" This block is the panel's own, not the shared empty state the leaf panels use. With a project open the builder runs and returns no children when the snapshot reports no runner — and returns exactly the same empty result when the snapshot request throws. Nothing in the branch shape distinguishes a failed fetch from an absent runner, and neither does the root panel: a failed load resets the shared snapshot to the empty one, so the panel renders the same no-runner block. The only signal is the error toast that failed load raises. The builder's own fetch failure raises nothing, so a request that fails for the builder alone leaves a childless branch under a panel still showing the brand badge. In practice a loaded project resolves a runner, since the suit's runner property constructs on the Fanuc preset and a project file with no runner element keeps that default. The empty branch is therefore what a reader meets before a project is open rather than a state a loaded project sits in. How the Branch Regrows Two panels in the whole branch report a structural change, and both scope it to the branch root: The root panel, after an Object-Management Load, Paste or XML apply. It installs the indexed object onto the project, refreshes the shared snapshot and the runner key, and then emits — whether or not the install itself succeeded, so the branch always regrows against a fresh snapshot. Controller Brand, after a brand switch, and only when the switch reported success. The host resolves the named scope, re-runs the branch builder over it, and adds the node to the expansion list so the fresh children are visible. Because a brand switch replaces the whole runner, this is what makes the brand-driven leaves appear and disappear. A brand switch that fails after the server has already assigned the preset leaves the two halves out of step: the shared snapshot is reloaded either way, so the badge and the brand select read the new brand, while the branch was not regrown and still lists the old brand's leaves. The tree shape and the panels' own gate come from two independent requests for the same snapshot. The builder calls the endpoint directly; the panels read a module-singleton cache filled once per SPA session and refreshed on a project-presence change, an Object-Management install and a brand switch. No panel refreshes it, so an edit that empties a table changes neither the cache nor the branch until one of those happens. Both structural writes are refused while an NC program is playing: installing a runner and switching brand each answer a conflict rather than swapping the parser under a running session. The Superseded Route The legacy controller page still ships at /controller/:tab? and is reached from the app menu bar's Page → Legacy-Controller entry. It edits HardNcEnv through its own REST surface, which is a different model from the runner this branch edits — the two are not two views of one object, and an edit on one is invisible to the other. Its anatomy is Legacy Controller Page. Layout General Setup Control Tree — the left dock of /general-setup Controller Node Row — equipment/controller, built after Workpiece and ahead of the two optional runner-suit leaves Machine / Controller Group Row — equipment/controller/machine Controller Brand, Machine Limits (Stroke), Rapid Feedrates, Home / G28 Reference, Tool-Change Position, Controller Parameters — grown for every runner M-Code Declarations, Canned Cycle (Peck), Block Skip / Delete, Subprogram Folders, Indexing Position Tables, Parameters (Native) — each grown only where the snapshot reports its backing entry. Across the shipped presets only Block Skip / Delete and Indexing Position Tables ever go missing; the other four are gated in code and unconditional in practice Program Data Group Row — equipment/controller/program-data Work Coordinates (G54…) and Tool Offsets — grown for every runner. The second reads Tool Offsets (ISO G43 H) while the Siemens $TC_DP table resolves, so the two offset ledgers do not read as one; its node id is unchanged by that relabel Tool Offsets ($TC_DP), Tool Names, Datum Presets (Q339), Datum Shifts (D), Frames (Siemens), Retained Common Variables, R Parameters — each grown only where the snapshot reports its backing table Editor Row — the panel of whichever node is selected Controller Root Panel Object Management Menu Button (⋮) — Load, Save As, Copy, Paste, XML Mode Brand Badge — the brand marker, or Unknown brand Runner File Caption — the recorded side file, Embedded in project, or No NC runner No-Runner Block — hourglass icon, No NC controller runner on this project., and the attach-a-file hint; shown instead of the two items below Presets Hint No-Axes Warning — shown only while the snapshot carries no axis Machine / Controller and Program Data Group Panels — the stem's intro line over a clickable list of its children, each row selecting that node Which brand grows which leaf is Controller Brand Matrix; how a leaf panel commits an edit is Controller Editing Contract. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/SoftNcRunnerRootPanel.vue — the branch root's editor: the Object-Management button and its install-then-regrow handler, the brand badge, the runner-file caption, the no-runner block, the presets hint and the no-axes warning. wwwroot-src/src/components/controlTree/softNcItemTypes.ts — the wave's item-type registry and the branch builder: the two plane stems, the leaves every runner grows, the snapshot flag each further leaf is grown behind, and the Siemens relabel of the Tool Offsets leaf. wwwroot-src/src/composables/useSoftNcRunner.ts — the module-singleton snapshot and runner key, the idempotent install of the project-presence watch, and the install and brand-switch calls the two emitting panels use. wwwroot-src/src/api/softNcRunner.ts — the snapshot shape the tree and the panels parse, and the typed wrappers over the controller's REST surface. wwwroot-src/src/components/controlTree/SoftNcEmptyState.vue — the shared “no runner” line the leaf panels render; the root panel renders its own block instead. wwwroot-src/src/components/controlTree/SoftNcBrandPanel.vue — the other panel that regrows the branch: the staged brand select, its confirmation, and the scope it emits. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — builds the equipment/controller root inside the equipment group, and turns a reported structure change into a branch rebuild. wwwroot-src/src/components/controlTree/GroupInfoPanel.vue — the editor both plane stems use. wwwroot-src/src/components/controlTree/itemTypes.ts — the base item-type registry the wave's own registry is spread into, and the mapping of the Group item type to that shared editor. wwwroot-src/src/components/widgets/ObjectManagementMenuButton.vue — the ⋮ menu: the server file browser and its extension filter, the expected type it sends with a paste, and the events the root panel listens to. wwwroot-src/src/pages/GeneralSetupPage.vue — the route that creates the equipment-scoped tree host this branch is built in. wwwroot-src/src/router/routes.ts — the /general-setup route and the still-shipping /controller/:tab? route beside it. wwwroot-src/src/components/AppMenuBar.vue — the Page menu entry that reaches the legacy route. wwwroot-src/src/i18n/en/softNc.ts — every label, group intro, hint and empty string this branch renders. wwwroot-src/src/i18n/en/tree.ts — the Controller root label. Mech/SoftNcRunnerController.cs — the branch's REST surface: the snapshot the tree shape is built from, the index-and-install pair behind Object Management, the brand switch with its carry and sweep, and the per-group readers and writers the leaves use. Widget/ObjectManagementController.cs — the server half of the ⋮ menu: the paste that rejects an object the expected-type string does not admit. HiAPI Engine HiMech/NcParsers/NcRunnerSuit.cs — the suit: the runner, its optional side-file path, the per-case list, the nested serialization of both, and the proxy wiring that materialises a per-case table into a project holding none of that type yet. HiMech/NcParsers/SoftNcRunner.cs — the pipeline and the five brand presets whose entries decide which leaves a brand grows, plus the chain configuration that stamps axis codes onto the axis config. HiMech/NcParsers/Dependencys/CncBrandDependency.cs — the brand marker behind the badge and the five declared tokens. HiMech/NcParsers/Dependencys/ControllerParameterTableBase.cs — the base whose interface list is why the per-axis leaves exist on every brand, and the axis-type rows the axis set is read from. HiMech/NcParsers/Dependencys/Fanuc/FanucParameterTableProxy.cs — the get-or-create proxy pattern the parameter tables use: a serialized seed on the runner, the live table on the project. HiNc/MachiningProcs/LocalProjectService.cs — the facade setter: the hoist of pre-proxy baked tables, the proxy re-binding, the chain-driven axis stamp and the session reset. HiNc/MachiningProcs/MachiningProject.cs — where the suit hangs off the project and the load path that leaves a project with the default preset when its file names no runner. Pages Ordered as the branch is read: the two references that hold across every node in it, then the two plane folders whose leaves have editors of their own. Controller Brand Matrix — Which leaf exists on which brand, the snapshot flag behind each one, and what a brand switch keeps, resets or destroys Controller Editing Contract — The rules every leaf panel in the branch follows — when an edit commits, what a failed write does, how a table is rendered — and the panels that depart from them Machine / Controller Plane — The plane that carries the machine and controller settings: the brand switch, the per-axis tables, the parameter forms, the M-code declarations, program reading and the indexing tables Program Data Plane — The plane that carries the per-case tables: the work coordinates, the two tool-offset ledgers, the Heidenhain datum rows, the Siemens frames and the two variable tables See Also Brand Matrix — which leaf exists on which brand, and the snapshot flag behind each one Editing Contract — the commit, rollback and error rules every leaf panel in this branch follows Machine and Controller Plane — the plane whose leaves carry the machine and controller settings, one page per editor Program Data Plane — the plane whose leaves carry the per-case tables, and the ownership rules that keep them on the project General Setup Page — the page that hosts this branch, and the equipment items beside it Control Tree — the engine that builds, rebuilds and selects this branch Legacy Controller Page — the superseded HardNcEnv route this branch replaces, still shipped at /controller"
  },
  "anatomy/general-setup/controller/machine/brand-switch.html": {
    "href": "anatomy/general-setup/controller/machine/brand-switch.html",
    "title": "Controller Brand | HiAPI-C# 2025",
    "summary": "Controller Brand Controller Brand is the first leaf of the Controller branch's machine plane, and the one leaf whose write replaces the entire NC runner instead of one field of one table — the branch root's Object-Management Load and Paste replace it by the other route, described below. It sits on the General Setup page at /general-setup under the Control-Tree id equipment/controller/machine/brand, and it is the only leaf whose write changes which of the branch's other nodes exist. The tree row reads Controller Brand; the select inside the panel is labelled Controller brand. Important Anatomy makes no claim that the id named here is stable across versions. The migration hop that keeps an older ?tree= value resolving is described in Tree Ids and Routes. What the Brand Actually Selects The brand marker itself is a plain string carried by CncBrandDependency, and nothing on the switch path reads it: the preset that answers a pick is chosen by the token the request carries, and what the installed runner does afterwards follows from that preset's own dependency list. What the panel writes is a preset: a whole SoftNcRunner built fresh from the engine's brand property, carrying its own syntax list, its own segmenter, its own initializers and its own dependency list. Four of the five segment one block per line and Heidenhain brings a segmenter of its own; Fanuc, Syntec and Mazak share an ISO initializer while Siemens and Heidenhain each bring theirs. So a brand switch changes the dialect a program is read in, not only the tables the branch shows. Away from this panel the marker is not inert. NC optimization reads it back out of the session's effective dependency list for the writeback patch grammar, which takes five things from the marker: its variable prefix, its comment spans, its keyword set, the place an inserted F word lands — on Heidenhain after the rightmost DR+/DR- and RL/RR/R0, so the element order a TNC enforces holds — and the shape of the source note the optimizer embeds, a ; comment on Heidenhain and a parenthesized one on the rest. The radius-compensation syntax all five presets carry reads it too, raising its negative-radius validation warning only where the marker is Heidenhain. The piece classifier does not read it: none of its re-interpolation guards is keyed on the brand, and the guard that singles a klartext arc out is keyed on where the arc's centre came from. So an arc centred on a modal CC line splits like any other, and the one refused (NcOpt--SplitionStartPointCenterUnsupported) is the arc whose CC chain left an in-plane coordinate for its own start point to supply. An arc whose centre falls entirely on its start point never reaches that guard: with no radius it is not an arc at all, so it warns Arc-CircleCenter--OnStartPoint and is degraded to a chord as the program is read. Each of the five properties returns a new instance per read, so no two projects can share one preset and the returned runner is safe to mutate before it is installed. The five brand tokens are declared once as constants on the brand dependency and are then enumerated again, independently, in the engine's preset writer, in the REST action's own switch and in the client's option constant — the first two by reference to the constants, the client by spelling the names out. Nothing joins those lists, and they are not the only places in the engine where the five are spelled out again, so the option a reader picks and the preset that answers it agree by convention rather than by construction. The option list this panel offers is the client-side constant: Fanuc, Siemens, Heidenhain, Syntec, Mazak, in that order. Brand names never translate. What Names the Current Brand, and What Names the Target Every string on the panel and in its dialog is either the brand in force or the brand about to replace it, and the same interpolation token means the opposite thing in two adjacent places. The select is seeded from the snapshot's brand and re-seeded by a watch whenever the snapshot's brand changes, so before any pick it reads the brand in force; from the moment a different option is picked, nothing left on the panel names the brand in force — only the confirmation dialog names both at once. Where it is read What it names The Controller brand select, before a pick the brand in force, from the shared snapshot The Controller brand select, after a pick the target — the staged brand, not yet applied The orange banner's {brand} the target The dialog's {brand} the brand in force, or the literal word current when the snapshot carries no brand marker The dialog's {next} the target The success toast's {brand} the target The select is not a placeholder surface. It has no placeholder text: with a brand marker present it shows that marker, and with none it shows only its own label. Because the select maps its value through the option list and falls back to the raw value when no option matches, a runner whose marker is a string outside the five — a controller file authored elsewhere, or a marker edited by hand — displays that string verbatim in the closed select even though no option in the list can reproduce it. Such a marker is not only cosmetic: the marker's other readers compare it against the five tokens, so the writeback grammar falls back to its Fanuc-family form in every choice it makes — the Fanuc variable prefix and comment spans, no keyword set, the conventional F position and a parenthesized source note — and the negative-radius validation warning stays off. Staging, and the Two Buttons The panel is one of the branch's two draft panels: the pick stages, it does not write. Apply brand is enabled only while the staged value is non-empty and differs from the brand the snapshot reports. It carries a spinner and both buttons disable while a request is in flight. Revert drops the staging by re-reading the snapshot's brand, and is enabled under the same condition. Two consequences follow from that enablement rule. First, the REST action's same-brand re-flash — a POST naming the brand already in force, which the action documents as per-case lossless — cannot be issued from this node, because staging the current brand is not a change. Second, on a runner whose marker is blank or outside the five options, every option counts as a change, so all five become applicable. Nothing guards a switch away from the node. The panel registers no before-switch gate, so selecting another tree row discards the staging silently; returning to the node re-seeds the select from the snapshot. The carry checkbox is not part of that staging and is not persisted anywhere: it is on when the panel mounts and keeps whatever state it was left in for as long as the panel stays mounted. The Confirmation Flow Apply brand opens a confirm dialog before any request is sent. Its title is Switch controller brand, and it declares no button labels of its own, so both buttons come from Quasar's language pack — which follows the app locale, and reads OK and Cancel in English. Cancel closes the dialog and leaves the staging untouched. The body is one of two whole sentences chosen by the carry checkbox — the two are separate strings rather than a concatenation, because the clause order differs between languages: Unticked — \"Replace the {brand} runner with the {next} preset? Machine settings reset to the preset's defaults; the old brand's program-data tables are removed.\" Ticked — \"Replace the {brand} runner with the {next} preset? Machine settings reset to the preset's defaults; the old brand's program-data tables are removed after their work-coordinate XYZ is carried over.\" While a different brand is staged, an orange banner stands above the buttons with the same warning in the target's voice: \"Switching brand replaces the whole runner with the {brand} preset. Machine settings reset to that preset's defaults and the old brand's program-data tables are removed — switching back does not restore them.\" Both sentences generalise, in opposite directions, and the exact reading is What Survives below. The sweep is narrower than the old brand's program-data tables are removed: the generic tool-offset table is program data and is never removed, the retained common-variable table survives a switch among the three brands that proxy it, and between Fanuc and Mazak the brand parameter table survives too. The reset is broader than a cross-brand switch: the runner-owned machine entries return to the preset's defaults on every apply, including the ones where nothing at all is swept. What the request can be refused with The action refuses before it touches anything in three cases, and each reaches the same toast: Refusal Answer No project loaded not found, with the coded no-project payload — the one refusal here that a non-English locale re-renders An NC program is playing conflict, rather than swapping the parser under a running session A brand token outside the five bad request, naming the token it was given The third is unreachable from this node: the select offers only the five, and staging is only possible for a value that differs from the marker in force, so the request always carries a token the action's own switch recognises. It stays live for any other client of the endpoint. Anything thrown after the work has begun is reported inside a success envelope instead: HTTP 200 carrying an unsuccessful flag and the exception's own message. The shared fetch helper raises both shapes as the same kind of error, so the panel cannot tell a refusal from a failure part-way through. What the operator sees afterwards Success raises an informational toast, \"Controller brand switched to {brand}\", naming the target. Failure raises a negative toast composed as “Switch controller brand” followed by the server's own sentence — untranslated, because the envelope carries no code to re-render. Controller Brand is the one panel in the branch with no local error handler at all: its failures surface through the shared runner state's global notification, so the console line names that shared state rather than this panel. What the Switch Does The action runs four steps in a fixed order, and the order is what decides the outcome. Capture. The outgoing work-coordinate provider — the first IIsoCoordinateConfig in the runner's proxy-resolved list — is asked for every coordinate id it currently holds a value for, and those id/offset pairs are held aside. With the carry checkbox unticked the captured list is empty. Swap. The preset is assigned through SoftNcRunner, the single rewiring entry point. That setter first hoists any brand parameter table baked directly into the outgoing runner's pipeline list into the project's per-case list, so the incoming proxy can claim it; assigns the runner; re-wires every proxy, the kinematics solver and the session script dictionaries; resets the per-session runner state so the next run re-parses from scratch and clears the NC diagnostics; and finally drops any hoisted table the incoming runner claimed through no proxy. Proxy re-wiring is also where the new brand's own per-case tables are materialised: each get-or-create proxy installs a deep clone of its seed only where the project holds no table of that type. Carry. The held offsets are written into the new provider, and only for ids that provider also exposes. The step is skipped entirely when the new provider is the same object as the old one, which is exactly the Fanuc-to-Mazak case. Sweep. Every per-case table the new runner resolves through no proxy is removed from the project's per-case list, so the previous brand's tables do not linger unread. What Is Carried The carry moves only the work-coordinate XYZ offsets. No other table's values cross, and nothing else on either plane is copied. The accepted set is the intersection of what the outgoing provider currently holds with what the incoming provider exposes, and the four providers do not expose the same ids. What each one allocates by default: Provider Brands Coordinate ids it exposes FanucParameterTable Fanuc, Mazak G54–G59 and G54.1 P1–P48, all seeded SyntecParameterTable Syntec the same set, through the same address map — spelled Pr rather than # SiemensFrameTable Siemens G54–G57, plus the extended series G505–G599 HeidenhainDatumTable Heidenhain G54–G59, aliased onto preset rows 1–6 So the carry is lossy in ways the checkbox's caption does not say. A switch out of Fanuc, Syntec or Mazak into Siemens keeps G54 through G57 and drops G58, G59 and all forty-eight G54.1 P offsets. The reverse switch keeps G54 through G57 and drops the whole G505–G599 extended series. Into Heidenhain from one of those three, G54 through G59 cross and the G54.1 P offsets do not; from Siemens, only G54 through G57 have anywhere to land. Between Fanuc, Syntec and Mazak the two id sets match, so nothing is lost. Whatever is dropped is dropped silently: an id the target does not expose is skipped without a message, and the table that held it is removed by the sweep in the same request. What Survives and What Is Swept The sweep's keep set is the new runner's proxy-resolved list, so a per-case table survives exactly when the target brand's preset proxies its type. Per-case table Proxied by Behaviour on a switch ToolOffsetTable all five survives every switch RetainedCommonVariableTable Fanuc, Syntec, Mazak survives among those three; swept into Siemens or Heidenhain FanucParameterTable Fanuc, Mazak survives between those two; swept otherwise SyntecParameterTable Syntec swept on leaving Syntec SiemensMachineDataTable Siemens swept on leaving Siemens SiemensFrameTable Siemens swept on leaving Siemens SiemensRParameterTable Siemens swept on leaving Siemens SiemensToolOffsetTable Siemens swept on leaving Siemens, tool-name map included HeidenhainDatumTable Heidenhain swept on leaving Heidenhain HeidenhainParameterTable Heidenhain swept on leaving Heidenhain HeidenhainQParameterTable Heidenhain swept on leaving Heidenhain, and exposed by no node or endpoint in the branch Switching back does not restore a swept table. The returning proxy finds nothing of its type on the project and clones a fresh table from its seed, so the rows come back at the preset's defaults and the previous values are gone. The tool-name map is worth naming separately because it is not a table of its own: it lives on the Siemens tool-offset table and leaves with it. Beside the per-case tables, the preset's plain entries are replaced outright on every apply, whatever the target brand. Those are the runner-owned machine settings, and they reset to that preset's defaults even in the Fanuc-to-Mazak case where nothing at all is swept: ToolingMcConfig — the tool-change position, back to its three-axis default, where X and Y are left unset and Z returns to zero. GenericBlockSkipConfig — the block-skip layers, back to layer 1 alone. The Heidenhain preset carries no block-skip config at all, so the node itself is gone after a switch to that brand. SubProgramFolderConfig — the subprogram lookup folders, back to an internal folder of NC and no external folder. The macro iteration guards, back to the target preset's own guard set. The Object-Management Load and Paste on the branch root install a runner through the same setter and the same sweep, so the same table survives or is lost by the same rule — but that path has no carry step and no confirmation of its own. What the Tree Does Afterwards The panel derives its rebuild scope from its own id by stripping the fixed /machine/brand suffix, so the scope is the branch root rather than this leaf, and it reports the structural change only on a successful switch. The Control-Tree host then rebuilds that branch and adds the root to the expansion list so the fresh children are visible. The rebuild makes its own request for the runner snapshot, independent of the shared one the panels gate on. The shared snapshot is re-read either way, in the call's finally block, together with the runner's index key. Three things follow: The selection does not move. Controller Brand exists on every brand, and the editor row's remount key is composed from the node id and the node key, both unchanged — so the panel is not remounted. The select is re-seeded by its watch rather than by a fresh mount, which is why the staged value clears after a success and stays put after a failure that left the brand alone. A failure that reached the server after the swap leaves the tree describing the previous shape. The regrow is skipped on failure, but the snapshot re-read is not; the select and the root's brand badge then show whatever brand the server now reports, over a branch built before the attempt. The staging clears with the brand, so Apply brand is disabled and the branch cannot be regrown from this node. Moving the selection does not regrow it either — only a structural change reported on that branch, a whole-tree rebuild, or the page rebuild a project change forces will bring the two back into agreement. A failed snapshot re-read empties the branch's panels. That read resets the shared snapshot to its empty value and raises its own toast, “Load controller settings” followed by the server's message; every leaf panel then renders the shared no-runner line even where the tree still lists the leaves. Layout General Setup Control Tree — the left dock of /general-setup Controller Node Row Machine / Controller Group Row Controller Brand Node Row — equipment/controller/machine/brand Editor Row — Controller Brand Panel Shared Empty Line — \"No NC runner — load a project first.\", in place of everything below it while the shared snapshot reports no runner Controller brand Select — dense, outlined; five options in list order, Fanuc, Siemens, Heidenhain, Syntec, Mazak; no clear button and no search field Carry work-coordinate XYZ (G54…) into the new brand's table CheckBox — dense, ticked when the panel mounts Warning Banner — orange, dense, rounded; present only while a different brand is staged Button Row Apply brand Button — primary, disabled unless a different brand is staged, spinner while the request is in flight Revert Button — flat, same enablement Confirm Dialog — title Switch controller brand, one of the two message variants, Cancel and OK No controller item type registers a large content view, so the General Setup content column shows its own empty hint while this node is selected. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/SoftNcBrandPanel.vue — this panel: the staged brand and its watch, the carry checkbox and its default, the dirty rule behind both buttons, the confirm dialog and its two message variants, and the rebuild scope derived by stripping the leaf's own id suffix. wwwroot-src/src/components/controlTree/SoftNcEmptyState.vue — the shared no-runner line this panel renders in place of its body. wwwroot-src/src/composables/useSoftNcRunner.ts — the shared snapshot the select is seeded from, the brand-switch call with its success and failure toasts, and the snapshot and key re-read that runs whichever way the call ends. wwwroot-src/src/api/softNcRunner.ts — the five-brand option constant, the snapshot shape, and the typed brand-switch request carrying the target and the carry flag. wwwroot-src/src/api/http.ts — why a refusal and a part-way failure arrive as the same kind of error, and why only a coded payload is re-rendered in the app locale. wwwroot-src/src/components/controlTree/softNcItemTypes.ts — this node's id, label and label key, and the branch builder that regrows the whole child set from a fresh snapshot after the switch. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — the branch root the scope resolves to, and the rebuild that expands it and re-resolves the selection. wwwroot-src/src/components/controlTree/SoftNcRunnerRootPanel.vue — the brand badge and runner-file caption that change with the snapshot, and the Object-Management install that replaces the runner by the other route. wwwroot-src/src/i18n/en/softNc.ts — the tree label, the select label, the checkbox caption, the banner sentence, the button captions and the two toast contexts. wwwroot-src/src/i18n/en/dialog.ts — the dialog title, the two message variants and the current fallback used when the snapshot carries no brand marker. Mech/SoftNcRunnerController.cs — the brand-switch action: its refusals, the four ordered steps, the sweep of per-case tables the new runner references through no proxy, and the runner-install action that shares that sweep. Common/ApiError.cs — the coded no-project payload, the one refusal here a non-English locale can re-render. HiAPI Engine HiMech/NcParsers/SoftNcRunner.cs — the five brand presets as literal dependency lists, each property returning a fresh instance, together with the segmenter, initializers and syntax list each brand brings; and the proxy resolution every read on this branch goes through. HiMech/NcParsers/NcRunnerSuit.cs — the suit that holds the runner beside the project's own per-case dependency list, and the proxy wiring the swap triggers. HiMech/NcParsers/ControllerPresetWriter.cs — the brand token list and preset factory that mirror the REST action's switch, and the controller-file extension a saved runner takes. HiMech/NcParsers/Dependencys/CncBrandDependency.cs — the brand marker itself: five tokens and one free-form string property, with no behaviour of its own; its readers live elsewhere. HiMech/NcOpt/SoftNcOptProc.cs — where NC optimization reads the marker back out of the session's effective dependency list, for the writeback grammar. HiMech/NcOpt/NcOptPieceClassifier.cs — the re-interpolation guards, none of them keyed on the brand; the arc guard keys on the centre's provenance instead. HiMech/NcParsers/Keywords/Generic/ArcCenterSource.cs — the two centre-provenance stamps: the one the arc guard refuses, and the one that tells the writeback a split arc's fragments share the CC line unchanged. An arc whose own block states its centre carries neither. HiMech/NcParsers/NcWriteback/NcPatchWriter.cs — the writeback grammar the marker selects: the variable prefix, the comment spans, the Heidenhain keyword set, the pre-feed word patterns that place an inserted F, and the trailing-comment shape the embedded source note takes. HiMech/NcParsers/PostLogicSyntaxs/RadiusCompensationSyntax.cs — the negative-radius validation warning raised only where the marker reads Heidenhain, in a syntax all five presets carry. HiMech/NcParsers/Dependencys/IIsoCoordinateConfig.cs — the work-coordinate provider contract the carry reads and writes through, including the id enumeration that decides what crosses. HiMech/NcParsers/Dependencys/IsoCoordinateAddressMap.cs — the G54–G59 and G54.1 P1–P48 id set the Fanuc-family and Syntec tables expose, and the seeding that makes every one of them present. HiMech/NcParsers/Dependencys/Siemens/SiemensFrameTable.cs — the frame table's own allocation, G54–G57 plus the extended G505–G599 series, which is what a carry into Siemens accepts. HiMech/NcParsers/Dependencys/Heidenhain/HeidenhainDatumTable.cs — the datum table's preset rows and the six of them aliased onto G54–G59. HiMech/NcParsers/Dependencys/Fanuc/FanucParameterTableProxy.cs — the get-or-create proxy shape the brand tables share: a serialized seed on the runner, a deep clone installed only where the project holds no table of that type, and a take thereafter. HiMech/NcParsers/Dependencys/Generic/ToolOffsetTableProxy.cs — the proxy every preset carries, and therefore the reason the generic tool-offset table survives every switch. HiMech/NcParsers/Dependencys/Generic/ToolingMcConfig.cs — the tool-change position's preset default, one of the runner-owned values every apply resets. HiMech/NcParsers/Dependencys/Generic/GenericBlockSkipConfig.cs — the block-skip layers' preset default, and the config the Heidenhain preset does not carry. HiMech/NcParsers/Dependencys/Generic/SubProgramFolderConfig.cs — the subprogram folders' preset defaults. HiNc/MachiningProcs/LocalProjectService.cs — the facade setter the swap assigns through: the hoist of pre-proxy baked tables, the proxy and kinematics re-wiring, the per-session runner state reset, and the drop of hoisted tables no proxy claimed. See Also Machine and Controller Plane — the plane this leaf opens, and the storage column that says which of its other leaves this control resets Brand Matrix — which nodes each brand grows, so what the branch looks like after the switch is a lookup rather than a surprise Editing Contract — the commit and error rules the rest of the branch follows, and which this panel departs from on purpose"
  },
  "anatomy/general-setup/controller/machine/index.html": {
    "href": "anatomy/general-setup/controller/machine/index.html",
    "title": "Machine and Controller Plane | HiAPI-C# 2025",
    "summary": "Machine and Controller Plane Machine / Controller is the first of the Controller branch's two plane stems: what describes the machine and the control that drives it, edited one leaf at a time. It lives on the General Setup page at /general-setup under the Control-Tree id equipment/controller/machine, and each of its leaves takes that id plus one segment — brand, limits, rapid, home, tool-change, parameters, m-codes, canned-cycle, block-skip, subprograms, indexing-positions, native. The stem is not gated: it is part of the branch builder's return value rather than a conditional entry, so it appears wherever a runner resolves and always carries the leaves no flag guards. Important Anatomy makes no claim that any id named here is stable across versions. The migration hop that keeps an older ?tree= value resolving is described in Tree Ids and Routes. Selecting the stem shows the shared group editor: its own introduction over a clickable list of its children. The introduction reads \"Machine and controller presets that travel with the runner file — brand, travel limits, rapid rates, home / G28 reference, the tool-change position and the controller parameters (in both a domain-grouped interface form and the native parameter form).\" What “Travels With the Runner File” Means The phrase names an ownership boundary, not a file on disk, and the boundary does not fall where the introduction's list suggests. Half of what this plane edits is stored on the project. The suit's two members NcRunnerSuit carries the runner, SoftNcRunner, and the project's own PerCaseNcDependencyList, and serializes the two side by side. The runner half honours SoftNcRunnerFile: with a project-relative path recorded there the runner XML is written to that side file and referenced from the project; with none recorded it is inlined in the project file. The per-case half is always inlined — the suit writes it as a nested element with no file reference of its own. The web service reads that recorded path and never writes one. On a project that has never been given a side file, both halves therefore sit inside the same project file, in two slots whose contents behave differently the moment a runner is swapped. A controller file is one serialized runner. Its canonical extension is .Controller (FileExtension), and the branch root's Load browser accepts the earlier .SoftNcRunner spelling beside it. Which half a value lands in A runner's PipelineNcDependencyList holds two shapes of entry. A plain dependency is the runner's own. Its edited values serialize with the runner, and installing another runner replaces the instance outright. A proxy — INcDependencyProxy — carries no live data. Each brand parameter-table proxy holds a fixed machine-config seed and serializes only that seed; WireNcDependencyProxies(API) deep-clones the seed into the project's per-case list only when the project holds no table of that type, and an existing table wins. Reads and writes then resolve through GetEffectiveNcDependencyList(API), which substitutes the project's table for the placeholder. All four brand tables' proxies are written to the same shape, and the seed is set once at construction and never rewritten by an edit. Two consequences follow, and they are what the introduction's phrasing hides: The per-axis rows, the M-code declarations and the native parameter rows are stored on the project, because they are all rows of the brand parameter table. Installing a same-brand runner file leaves them where they are, apart from the rotary reference and rapid rows that any re-bind of the suit re-stamps. Saving a runner file captures the proxy's seed, not the table the panels have been editing. A .Controller written after the axis tables were tuned carries the preset seed those tables were cloned from. Why the table is per-case at all splits by brand. The Fanuc-family and Syntec tables mix machine configuration with the per-case work-coordinate offsets the program-data plane edits, which the two planes could not otherwise separate. The Siemens machine-data and Heidenhain tables carry no work coordinates — those two brands keep their offsets in a separate per-case table — and are per-case for the other half of the same reason: the project's own table wins over the seed, so machine data and machine parameters already edited survive a same-brand runner install instead of resetting to the preset's. The Plane's Leaves Ordered as the branch builder pushes them: the ungated leaves first, then each gated leaf behind the snapshot flag that grows it. Which brands satisfy each flag is Brand Matrix; the column that page does not carry is the last one here. Node segment Label the tree shows Gate What backs it Stored on brand Controller Brand ungated CncBrandDependency runner limits Machine Limits (Stroke) ungated the brand parameter table's stroke-limit rows project rapid Rapid Feedrates ungated the brand parameter table's rapid-rate rows project home Home / G28 Reference ungated the brand parameter table's reference-position rows project tool-change Tool-Change Position ungated ToolingMcConfig runner parameters Controller Parameters ungated the brand parameter table, plus the runner's iteration guards split m-codes M-Code Declarations hasNativeTable the brand parameter table's declaration map and tool-change trigger project canned-cycle Canned Cycle (Peck) hasCannedCycle the brand parameter table, or FallbackConfig brand-dependent block-skip Block Skip / Delete hasBlockSkip GenericBlockSkipConfig runner subprograms Subprogram Folders hasSubprogramFolders SubProgramFolderConfig runner indexing-positions Indexing Position Tables hasIndexingTables SiemensMachineDataTable project native Parameters (Native) hasNativeTable the brand parameter table, as its raw dictionaries project Every label above is a translated role string rather than a type name, so the tree renders the translation and a locale change rewrites the rows without touching an id. One flag grows two of these leaves: hasNativeTable gates both M-Code Declarations and Parameters (Native), because the declarations live on the same table the native form exposes. Two leaves that straddle the boundary Controller Parameters is the one leaf whose fields do not share a storage half. Max spindle speed, the cutter-compensation startup type and the tool-axis direction are written onto the brand parameter table, so they are project-owned; the macro loop guards under Macro loop guards (advanced) are written onto the runner's own iteration-guard dependencies, so they are runner-owned. The panel gates its whole body on the parameter table's presence, which is the project-owned half. Canned Cycle (Peck) is the one leaf whose storage half depends on the brand. Where the brand table supplies the clearance it is a row of that table and project-owned; where the preset supplies it through the generic fallback config it is a plain runner entry and runner-owned. The read reports which of the two answered, and the panel names the source in the caption under the field. What an Install or a Brand Switch Does Object-Management Load, Paste and XML apply all install a runner through SoftNcRunner, and a brand switch assigns the brand's preset through the same setter. Both are followed by the same sweep, and for this plane the outcome splits exactly along the storage column. The runner-owned leaves take the incoming runner's values, so a brand switch returns the tool-change position, the block-skip layers, the subprogram folders and the macro guards to the new preset's defaults. Installing a controller file of the brand already in force replaces those same four with the file's values while the project keeps its own parameter table — the same-brand re-flash the REST surface's own remark calls per-case lossless, naming those four as what resets. That re-flash is not reachable from the brand select, whose apply is enabled only while the staged brand differs from the active one (Brand Switch); Load, Paste and XML apply are the surfaces that issue it. The project-owned leaves keep the project's table: the incoming proxy re-binds to it rather than cloning its seed over it. Before the swap, any brand parameter table baked directly into the outgoing runner's pipeline list — the storage a project file saved before that table went per-case still uses — is moved into the per-case list so the incoming proxy can claim it, and a moved table no proxy claims is dropped again afterwards. The chain walk that follows the re-bind is the only part of the swap that writes into the surviving table: it stamps the chain's axes onto it, and with them every rotary axis's reference position and rapid rate. A switch to a different brand ends with the per-case tables the new runner resolves through no proxy removed, so the previous brand's parameter table does not linger unread. Switching back does not restore it; a fresh table is cloned from the new preset's seed instead. Both writes are refused while an NC program is playing, and each answers with a conflict rather than swapping the parser under a running session. One Table, Two Forms Machine Limits, Rapid Feedrates, Home / G28 Reference, M-Code Declarations, most of Controller Parameters and all of Parameters (Native) read and write one object: the brand parameter table. ControllerParameterTableBase declares the role accessors — home reference, axis set, rapid feedrates, stroke limits, spindle control, M-code declarations, the tool-change trigger — and each brand subclass maps those roles onto its own parameter numbers. The domain-grouped leaves call the accessors; the native leaf writes the raw dictionary cell under the number. Editing one form changes what the other shows. Where a brand stores a role in its own unit the two forms differ by that unit, and the peck clearance is the case that ships: the Syntec table stores it in microns and its accessor converts, while the Fanuc-family table stores millimetres directly. The interface leaf therefore shows the same number on every brand and the native leaf shows the brand's raw stored value. What a freshly switched brand shows is decided by that brand's default table. Every one of them declares a linear X, Y and Z with a reference position of zero and a rapid rate per axis, so Rapid Feedrates and Home / G28 Reference open populated. None of them declares a stroke limit, so Machine Limits opens with empty cells on every brand; and only the Siemens default table pre-declares any M-codes, so M-Code Declarations opens empty on the other four brands, Mazak included, because it carries the Fanuc table. An axis with no rapid-rate row of its own reads a fixed default rather than a blank cell. The axis rows those leaves list are the parameter table's own axis entries. Whenever the suit or the machine chain is re-bound, a chain walk stamps the chain's axis codes onto that table: it adds axes and removes none, and a linear axis keeps what the table already holds, gaining a reference position only where it had none. A rotary axis is the exception — every walk rewrites its reference position to 0 deg and its rapid rate to 36000 deg/min, so a tuned rotary value does not survive the next stamp. The chain itself is edited on Machine Tool. Layout General Setup Control Tree — the left dock of /general-setup Controller Node Row Machine / Controller Group Row — equipment/controller/machine Controller Brand Node Row Machine Limits (Stroke) Node Row Rapid Feedrates Node Row Home / G28 Reference Node Row Tool-Change Position Node Row Controller Parameters Node Row M-Code Declarations Node Row — grown while the snapshot reports a brand parameter table Canned Cycle (Peck) Node Row — grown while it reports a peck-clearance provider Block Skip / Delete Node Row — grown while it reports a block-skip config Subprogram Folders Node Row — grown while it reports a subprogram-folder config Indexing Position Tables Node Row — grown while the brand table is the Siemens machine-data table Parameters (Native) Node Row — grown on the same flag as M-Code Declarations Program Data Group Row — the plane beside this one Editor Row — the panel of whichever node is selected Machine / Controller Group Panel Intro Caption — the stem's introduction line Child List — one bordered, separated row per leaf above, each showing the leaf's label in the theme's primary colour with a right chevron; a click selects that leaf The stem's own editor holds no field, so nothing on this plane is edited from the group row itself. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/softNcItemTypes.ts — the branch builder: the machine stem's id, label key and intro key, the leaves it pushes unconditionally, and the snapshot flag each further leaf is pushed behind, in the order the table above lists them. wwwroot-src/src/components/controlTree/GroupInfoPanel.vue — the stem's editor: the intro caption and the clickable child list that selects a leaf. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — builds the equipment/controller root this stem hangs from, inside the equipment group. wwwroot-src/src/api/softNcRunner.ts — the snapshot shape the builder reads its flags from, and the typed wrappers over each leaf's reader and writers. wwwroot-src/src/composables/useSoftNcRunner.ts — the shared snapshot the leaf panels gate on, and the install and brand-switch calls that regrow the branch. wwwroot-src/src/i18n/en/softNc.ts — the stem's introduction line and every leaf label in the table above. Mech/SoftNcRunnerController.cs — the plane's REST surface: the presence flags, the per-group readers and writers, the runner install, and the brand switch with its carry and its sweep of per-case tables the new runner references through no proxy. HiAPI Engine HiMech/NcParsers/NcRunnerSuit.cs — the suit: the runner, its optional side-file path, the per-case list, the flat serialization that inlines the per-case half and file-references the runner half, and the proxy wiring. HiMech/NcParsers/SoftNcRunner.cs — the pipeline list this plane's dependencies sit in, the five brand presets that decide which of them a brand carries, the proxy resolution every read goes through, and the chain configuration that stamps axis codes onto the table. HiMech/NcParsers/ControllerPresetWriter.cs — the canonical controller-file extension and the writer that renders one brand preset as a standalone runner file. HiMech/NcParsers/Dependencys/INcDependencyProxy.cs — the maker-and-taker contract: what a proxy may serialize, and why its resolved data is never written into the runner. HiMech/NcParsers/Dependencys/Fanuc/FanucParameterTableProxy.cs — the get-or-create proxy behind the Fanuc-family table the Fanuc and Mazak presets share, and the shape the other three brand tables each repeat in a proxy class of their own: a serialized seed on the runner, a deep clone installed into the project only when the project has no table of that type, and a take thereafter. HiMech/NcParsers/Dependencys/ControllerParameterTableBase.cs — the role accessors the domain-grouped leaves call, the per-brand parameter numbers they map onto, and the raw dictionaries the native leaf edits. HiMech/NcParsers/Dependencys/Fanuc/FanucParameterTable.cs, HiMech/NcParsers/Dependencys/Syntec/SyntecParameterTable.cs, HiMech/NcParsers/Dependencys/Siemens/SiemensMachineDataTable.cs, HiMech/NcParsers/Dependencys/Heidenhain/HeidenhainParameterTable.cs — the four brand tables and their default seeds: the axis rows, the rapid rates, the peck clearance and its unit, and the only pre-declared M-codes on the plane. HiMech/NcParsers/Dependencys/Generic/ToolingMcConfig.cs, HiMech/NcParsers/Dependencys/Generic/GenericBlockSkipConfig.cs, HiMech/NcParsers/Dependencys/Generic/SubProgramFolderConfig.cs, HiMech/NcParsers/Dependencys/Generic/FallbackConfig.cs — the plain runner-owned dependencies behind the tool-change, block-skip, subprogram and fallback-clearance leaves, and the values each one serializes with the runner. HiMech/NcParsers/Dependencys/Fanuc/FanucGotoIterationDependency.cs — a macro guard, the runner-owned half of the Controller Parameters leaf. HiMech/NcParsers/Dependencys/CncBrandDependency.cs — the brand marker the first leaf edits. HiNc/MachiningProcs/LocalProjectService.cs — the facade setter every install and brand switch assigns through: the hoist of pre-proxy baked tables, the drop of the ones no proxy claims, the proxy re-binding and the chain-driven axis stamp. HiGeom/Common/XmlUtils/XmlUtil.cs — the file-reference helper that decides whether the runner is written to its side file or inlined. Pages Ordered by the first node each page owns, as the plane lists them. Controller Brand — The brand select and its staged apply, and what a brand change carries, resets and destroys Per-Axis Tables — The four leaves whose rows follow the machine chain: stroke limits, rapid rates, the G28 reference and the tool-change position Interface Parameters — The domain-grouped parameter form and the peck-clearance leaf beside it, including the fields whose storage half differs M-Code Declarations — What a declared machine M-code consumes, the tool-change trigger mode, and the codes an undeclared M word still warns about Program Reading — The two leaves that decide how a program is read rather than how the machine moves: block-skip layers and the subprogram lookup folders Indexing Positions — The coded-position tables and the per-axis assignment that decides which axis reads which Native Parameters — The raw parameter form: brand numbering, raw stored units, and the same table every other leaf on this plane edits See Also Controller Branch — the branch this plane is half of, its runner root and the program-data plane beside it Program Data Plane — that plane itself, whose leaves are project-owned throughout where this one's ownership splits between the runner file and the project Brand Matrix — which brand satisfies each gate named above, and what each flag actually probes Editing Contract — the commit, rollback and rendering rules every leaf on this plane inherits, and the panels that depart from them Controller Brand — the control that replaces the runner, and therefore everything in the runner-owned column here Per-Axis Tables — the per-axis leaves whose rows come from the machine chain and whose values are stored on the project Interface Parameters — the interface parameter form and the peck-clearance leaf, the two entries that straddle the storage boundary M-Code Declarations — the declaration map on the same table the per-axis leaves edit Program Reading — the block-skip and subprogram leaves, the two settings that change how a program is read rather than how the machine moves Indexing Position Tables — the leaf that grows only where the brand table is the Siemens machine-data table Native Parameters — the raw form of the table behind most of this plane"
  },
  "anatomy/general-setup/controller/machine/indexing-positions.html": {
    "href": "anatomy/general-setup/controller/machine/indexing-positions.html",
    "title": "Indexing Position Tables | HiAPI-C# 2025",
    "summary": "Indexing Position Tables Indexing Position Tables is the machine plane's single-brand leaf: the two global position lists a Sinumerik control resolves coded-position words against, edited as drafts and saved whole. It lives on the General Setup page at /general-setup under the Control-Tree id equipment/controller/machine/indexing-positions, and of the five controller brands only Siemens grows it. The tables it edits are machine data of the Siemens machine-data table; the assignment that decides which axis reads which of them is shown here and edited on the sibling leaf, Parameters (Native). Important Anatomy makes no claim that any id named here is stable across versions. The migration hop that keeps an older ?tree= value resolving is described in Tree Ids and Routes. The One Single-Brand Node The branch builder pushes this leaf behind the hasIndexingTables snapshot flag, and that flag is a pure type probe: it reports whether the runner's brand parameter table is the SiemensMachineDataTable. Nothing about the tables' contents is examined, so the node grows on every Siemens runner whether or not a single position has been entered. Only the Siemens preset carries that table, which is why this leaf is the machine plane's one single-brand row in the Brand Matrix; the program-data plane beside it has several. The flag and the panel's own read do not ask quite the same question. The flag inspects the first brand parameter table in the resolved dependency list; the panel's reader looks for a Siemens machine-data table anywhere in it. The two agree on every shipped preset, where the Siemens machine-data table is the only parameter table present. That table is also the sole implementer of IIndexingPositionConfig in the engine, so nothing else in a runner can supply an indexing table and no other brand can grow this node by carrying a different type. What the Two Tables Are The leaf edits IndexAxPosTab1 and IndexAxPosTab2 — the general machine data MD10910 and MD10930. They describe axes that take up discrete stations rather than arbitrary positions: Hirth-coupled tables, indexing rotaries, turret-style workholders. They are global, not per-axis. Each is one ordered list shared by every axis assigned to it, so an edit to Table 1 changes every axis whose assignment reads 1. Row order is the position number, and numbering is 1-based. Row 1 is indexing position 1. The used-length machine data beside each table — MD10900 and MD10920 — is not stored: the list count is the used length, which is why the panel has no length field. Values are in the axis' own native units — degrees on a rotary axis, millimetres on a linear one — and the panel prints no unit suffix on the cells, because the unit follows whichever axes read the table. Values must be strictly ascending, and where a modular rotary axis reads the table they must also satisfy 0 ≤ position < 360. At most 60 entries per table, the MD10910 / MD10930 array size. Finer station counts are what the equidistant definition below exists for. What consumes them The tables are read at the write stage of the parsing pipeline, through TryGetIndexingPosition(API) and TryFindIndexingAnchor(API), for the Siemens coded-position coordinate functions CAC(), CIC(), CDC(), CACP() and CACN() — the family whose argument is a position number rather than a coordinate. The Siemens per-word coordinate syntax unwraps those verbs only on axes that IsIndexingAxis(API) reports as usable, and the rotary-only members of the family additionally require a rotary axis; the rotary words are then resolved by the ABC write pass and the linear words by the incremental-resolve pass, both through the shared coded-position helper. An empty table is a real state with a visible consequence. An axis assigned to a table that holds no entries is not a usable indexing axis, so its coded-position words are left unrecognised and surface as unresolved text rather than being resolved against nothing. The engine lookups themselves deliberately do not validate the Siemens constraints — a table that breaks them resolves nonsense positions with no diagnostic — which is why the write endpoint, and this panel with it, is where the rules are enforced. Machine Data, Not Program Data The tables belong to the machine plane rather than the program-data plane: they configure the machine's stations, not a part's setup, and they carry no per-workpiece meaning the way a work coordinate or a datum shift does. That is the classification the branch builder gives the node, and it is the reason the node sits beside Machine Limits and Rapid Feedrates rather than beside Work Coordinates. Their storage half is a separate question, and the answer is the project. The Siemens preset carries a SiemensMachineDataTableProxy, not a table: the proxy holds a fixed machine-config seed, deep-clones it into the project's per-case list only when the project has no Siemens machine-data table yet, and thereafter resolves the project's own table. Three consequences follow, and they are the ones the plane's other project-owned leaves live with — Machine Limits, Rapid Feedrates, Home / G28 Reference, M-Code Declarations and Parameters (Native), all rows of the same per-case table. The plane's runner-owned leaves get the opposite of all three, and which half a leaf falls in is listed on Machine and Controller Plane: Edited positions are stored on the project, serialized with the per-case table as one XML element per entry carrying its table number and its value. Installing another Siemens runner, or re-applying the Siemens brand, leaves them alone: the incoming proxy re-binds to the project's table instead of cloning its seed over it. Saving a controller file captures the seed, not the edited table. A .Controller written after the tables were filled in carries the preset seed they were cloned from. Switching to any other brand removes the Siemens machine-data table from the project, because no proxy of the incoming runner resolves it, and the positions go with it. Switching back clones a fresh table from the seed rather than restoring the removed one — see Brand Switch. The Assignment Is Shown Here and Edited Elsewhere Above the two drafts the panel renders one display-only table: Axis against Indexing assignment (MD30500), the per-axis machine datum that decides what an axis does with the two global lists. Four values are named: Assignment Label the user reads Meaning 0 Not an indexing axis the axis ignores the coded-position family 1 Table 1 (MD10910) the axis reads the first draft below 2 Table 2 (MD10930) the axis reads the second draft below 3 Equidistant (MD30501–MD30503) positions come from a spacing rule, not from either table Any other stored value renders as the bare number. The rows are the axes that carry an MD30500 entry, not the plane's usual axis set. Every other per-axis leaf reads the table's axis-type rows — the set a machine-tool install stamps the chain's axis codes into — while this one reads the keys of the assignment row itself, sorted by axis name. An axis of the machine with no assignment entry does not appear here at all, and an assignment entry written against a name the machine does not have does. An axis the table reports as modular rotary carries the note (wraps 0–360°) beside its name, and its presence is what turns on the one-revolution rule for whichever table it reads. That report is the machine-axis contract's default — IsModularRotary(API) is not overridden by any parameter table — so on this branch every rotary and every spindle-mode axis counts as modular. Nothing on this leaf writes an assignment. The panel renders the value as plain text, and the leaf's REST surface exposes a reader for the two tables with their per-axis assignments and a writer for one position table; no endpoint of its own writes an assignment. MD30500 is written where every other raw machine datum is written: on Parameters (Native), as a row of the Axis parameters (integer) section, added through the Section / Parameter id / Axis / Value (raw) footer with the section set to Axis (integer). With no assignment row anywhere on the table this panel says so and points there: \"No axis declares an indexing assignment (MD30500) yet — add it as a per-axis integer parameter in Parameters (Native).\" The equidistant definition is edited entirely on that same sibling leaf and has no surface here. Its three machine data — the numerator MD30501, the denominator MD30502 and the offset MD30503 — are ordinary parameter rows, and an axis on assignment 3 consults neither of the two tables this panel edits. On a modular rotary axis the numerator is ignored and the revolution is divided into MD30502 positions; elsewhere the spacing is the numerator over the denominator and the position count is unbounded. Draft, Validate, Save Whole This is the branch's one draft-then-save table, and it departs from the shared commit rule that Editing Contract sets for its siblings. Every other table in the branch commits per cell and rolls a failed write back; this one commits nothing until a button is pressed, and keeps a failed edit on screen. Cells bind straight into the draft. Each numeric cell is bound with a two-way model and carries no commit handler, so a cell's commit — which the widget runs on blur and on Enter, never on a keystroke — lands in the draft row and goes no further. The badge, the validation line and the two buttons therefore follow those commits rather than the typing. The field itself still refuses text it cannot parse, with an untranslated message under the box; it carries no minimum and no maximum here, so every rule below is the draft validator's — see Numeric Input. Add and delete are draft operations too. Add Position appends an empty row and is disabled at 60; the row's delete button removes it from the draft with no confirmation and no request. An orange unsaved badge appears beside a table's title while the draft differs from what was last saved, compared row count first and then value by value. Save Table sends the whole list for that one table and is disabled while the draft is clean or while validation fails. Revert restores the draft from the last saved values. The validator mirrors the endpoint's own rules and reports the first violation as a line under the table: the per-table maximum, a fill in position … (or delete its row) line naming an empty or non-finite cell, a strictly-ascending check naming both offending positions with their values, and the 0 ≤ position < 360 range when a modular rotary axis reads that table. A failed save does not roll the draft back. The draft stays dirty and the badge stays up, so the work is not lost — the opposite of every other panel in the branch. Saving an empty table clears it. The endpoint accepts an empty list, and the axes assigned to that table then stop being indexing axes. The endpoint enforces the same four rules independently, so the panel's validation is live feedback rather than the gate. A save that passes is applied to the live table and the panel does not re-read: it marks the draft saved from what it sent. What a Freshly Switched Siemens Runner Shows Default3Axis — the seed the Siemens proxy clones — declares a linear X, Y and Z, a reference position and a velocity for each, a maximum spindle speed and six note-only OEM M-codes. It declares no MD30500 assignment and no entry in either position table. So a project that has just been switched to Siemens grows this node, opens it successfully, and finds it completely empty: the assignment caption in place of the axis table, and two titled tables with headers, no rows and an Add Position button. This leaf is also the only place the two lists appear. Parameters (Native) shows every row of the machine-data table's three parameter dictionaries, and the two position tables are not in any of them — they are separate list properties, so this panel is the whole editable surface for MD10910 and MD10930. The panel opens through the branch's two-layer empty gate: the shared \"No NC runner — load a project first.\" from the runner snapshot, then \"No Siemens machine-data table on the active runner.\" from its own read. The second line is also what a failed read leaves on screen, since the presence flag starts false and the failure path only raises a toast. Layout General Setup Control Tree — the left dock of /general-setup Controller Node Row Machine / Controller Group Row Indexing Position Tables Node Row — equipment/controller/machine/indexing-positions, between Subprogram Folders and Parameters (Native) Editor Row — the panel of the selected node Indexing Position Tables Panel — one column, gutter-spaced Description Caption — \"Global indexing position tables for coded-position programming (CAC/CIC/CDC/CACP/CACN). Row order is position-number order — row 1 is indexing position 1. Values are in the axis' native units (degrees for rotary, mm for linear) and must be strictly ascending. Which axis reads which table is MD30500, edited in Parameters (Native); an axis whose table is empty is not an indexing axis (its coded-position words stay unresolved).\" Assignment Table — dense, flat, bordered; display-only Header Row — Axis, Indexing assignment (MD30500) Data Row — the axis name in bold, with (wraps 0–360°) beside it on a modular rotary axis, then the assignment's label No-Assignment Caption — replaces the table when no axis carries an assignment Position Table Block — one per table, twice Title Row — Table 1 (MD10910) or Table 2 (MD10930), then either used by and the names of the axes assigned to it or not used by any axis, then an orange unsaved badge while the draft is dirty Table — dense, flat, bordered Header Row — Position #, Value, and an unlabelled action column Data Row — the 1-based position number in bold, the numeric cell, and a delete button that removes the row from the draft Validation Line — the first rule the draft breaks, in the negative colour Button Row — Add Position (disabled at 60 rows), then Revert and Save Table, both disabled while the draft is clean and Save Table also while validation fails No-Table Body — replaces everything above: \"No Siemens machine-data table on the active runner.\" Shared Empty State — replaces the whole body while the snapshot reports no runner: \"No NC runner — load a project first.\" Toast — negative, three seconds, the panel's context followed by the server's own message Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/SoftNcIndexingPositionsPanel.vue — this panel: the draft model over the two tables, the dirty comparison behind the badge, the validator that mirrors the endpoint's rules, the display-only assignment table with its four labels and its wrap note, and the save that marks the draft clean without re-reading. wwwroot-src/src/components/controlTree/softNcItemTypes.ts — the node's id, label and label key, and the snapshot flag it is pushed behind, between the subprogram and native leaves. wwwroot-src/src/api/softNcRunner.ts — the reader that parses the two tables and the axis rows, the whole-table replace and its documented refusals, and the snapshot flag the builder gates on. wwwroot-src/src/composables/useSoftNcRunner.ts — the shared runner snapshot the first empty layer reads. wwwroot-src/src/components/widgets/NumericInput.vue — the cell: the two-way binding this panel uses in place of a commit handler, the blur-and-Enter moment that binding emits on, the empty-to-null parse the validator then reports, and the untranslated parse message. wwwroot-src/src/components/controlTree/SoftNcEmptyState.vue — the shared no-runner line. wwwroot-src/src/components/controlTree/SoftNcNativeParamsPanel.vue — the sibling panel that owns the assignment: the integer per-axis section and the footer that adds a row by id and axis. wwwroot-src/src/i18n/en/softNc.ts — the node label, the description caption, the four assignment labels, the wrap note, the table titles, the used-by captions, the four validation messages and the absent-table line quoted above. wwwroot-src/src/i18n/en/common.ts — the shared Axis and Value column headers. Mech/SoftNcRunnerController.cs — the REST surface: the read that pairs the two tables with the per-axis assignments and reports presence from the Siemens table alone, the whole-table replace with its capacity, finite, ascending and one-revolution checks, the integer per-axis parameter write the assignment is edited through, and the brand switch whose sweep removes the table on leaving Siemens. HiAPI Engine HiMech/NcParsers/Dependencys/IIndexingPositionConfig.cs — the contract: 1-based position numbering, the native-unit and frame rules, the position count, the cyclic test, the number-to- coordinate lookup and the anchor search, and the rule that an axis whose table is empty is not a usable indexing axis. HiMech/NcParsers/Dependencys/Siemens/SiemensMachineDataTable.cs — the two position lists, their XML round-trip and the statement that the lookups do not validate the Siemens constraints, the MD30500 assignment dictionary, the equidistant spacing resolution over MD30501–MD30503, the five contract implementations, and the default seed that declares none of them. HiMech/NcParsers/Dependencys/Siemens/SiemensMachineDataTableProxy.cs — the get-or-create proxy: the seed serialized on the runner, the deep clone installed only into a project that has no table, and the deliberate refusal to implement the machine-config interfaces itself. HiMech/NcParsers/Dependencys/IMachineAxisConfig.cs — the axis contract, and the modular-rotary default that makes every rotary and spindle axis subject to the one-revolution rule. HiMech/NcParsers/SoftNcRunner.cs — the Siemens preset that carries the machine-data proxy, and the proxy resolution every read on this leaf goes through. HiMech/NcParsers/Syntaxs/SiemensSyntaxUtil.cs — the syntax list that wires the coded-position producer and its two write-stage consumers into the Siemens pipeline. HiMech/NcParsers/EvaluationSyntaxs/Siemens/SiemensAcIcSyntax.cs — the producer: it unwraps the five coded verbs only on usable indexing axes and stamps the per-word override, leaving the word untouched elsewhere. HiMech/NcParsers/LogicSyntaxs/CodedPositionUtil.cs — the shared resolution: position number to coordinate, the hold-on-failure semantics, and the diagnostics for an invalid number or a table that has gone missing between stages. HiMech/NcParsers/LogicSyntaxs/McAbcSyntax.cs, HiMech/NcParsers/LogicSyntaxs/IncrementalResolveSyntax.cs — the two write-stage consumers, rotary words and linear words. HiMech/NcParsers/LogicSyntaxs/McAbcCyclicPathSyntax.cs — the tail pass that turns the resolved directional approach into a path, and the one other syntax pass that reads the modular-rotary flag directly. See Also Machine and Controller Plane — the plane this leaf sits on, and which half of the project each of its neighbours is stored in Brand Matrix — the gate behind this node, why it is the machine plane's only single-brand row, and what every other flag probes Editing Contract — the per-cell commit rule the rest of the branch follows and this panel deliberately breaks Native Parameters — where the MD30500 assignment and the equidistant machine data this leaf only displays are actually edited"
  },
  "anatomy/general-setup/controller/machine/interface-parameters.html": {
    "href": "anatomy/general-setup/controller/machine/interface-parameters.html",
    "title": "Interface Parameters | HiAPI-C# 2025",
    "summary": "Interface Parameters Two leaves of the Controller branch's machine plane put the controller's non-axis parameters into domain vocabulary instead of parameter numbers: Controller Parameters and Canned Cycle (Peck). They live on the General Setup page at /general-setup under the Control-Tree ids equipment/controller/machine/parameters and equipment/controller/machine/canned-cycle. Each value they edit that is a row of the brand parameter table is also reachable as a raw numbered row on the sibling leaf, Parameters (Native); the values stored elsewhere are named below, and they reach no native form at all. Important Anatomy makes no claim that any id named here is stable across versions. The migration hop that keeps an older ?tree= value resolving is described in Tree Ids and Routes. Controller Parameters is ungated: the branch builder pushes it with the brand and the four per-axis leaves, so it exists wherever a runner resolves. Canned Cycle (Peck) is pushed behind the hasCannedCycle flag, which is true on all five shipped brand presets — see Brand Matrix. The Five Fields, and Which Brand Shows Which Controller Parameters renders at most five controls, in one column, in this fixed order. There is no tab, no group box and no scroll region; a field the brand does not have is not disabled but absent. Field the user reads Control Backed by Fanuc, Mazak Syntec Siemens Heidenhain Max spindle speed numeric, rpm, minimum 0 the brand parameter table #3741 Pr3741 MD35100 MP100 Cutter compensation startup / cancel type select — Type A / Type B / Type C the brand parameter table #5003 Pr5003 — — Tool-axis direction select — Z / Y / X the brand parameter table — — — MP101 GOTO — max jumps per N target † numeric, minimum 1 an iteration-guard dependency Fanuc guard Fanuc guard Siemens guard — WHILE/DO — max iterations per loop † numeric, minimum 1 an iteration-guard dependency Fanuc guard Fanuc guard Siemens guard — † The Fanuc-family spelling. Siemens spells both guard labels differently — the two pairs are below. The last two sit under a separator and the caption Macro loop guards (advanced), and that whole group is rendered only when at least one of the two guard values resolves. On Heidenhain neither does, so the separator, the caption and both fields are absent together; that brand shows two fields in total. The two guard labels are chosen from the brand marker, not from the dependency that answered. The Siemens spellings — GOTOF/GOTOB — max jumps per label and WHILE / FOR / REPEAT / LOOP — max iterations per loop — are used when the brand marker string reads Siemens, and the Fanuc spellings otherwise. Syntec and Mazak therefore read the Fanuc spellings, which is correct: both presets carry the Fanuc guard types. The label and the value are independent lookups, so a runner whose brand marker was edited apart from its dependency list can show one brand's wording over the other brand's guard. The three select options Type A / Type B / Type C are translated strings; the three tool-axis options Z, Y and X are literal letters written into the component and are the same in every locale. Visibility Is Null-Driven, Not Flag-Driven Which fields appear is decided per field, by a null in the read, and not by the shared runner snapshot the tree shape is built from. The reader answers one object with present plus five nullable numbers, computed by type-switching on the resolved dependencies: Max spindle speed is non-null for each of the four brand parameter-table types, so it is present on all five brands. A ControllerParameterTableBase subclass outside those four answers null, and the field disappears while present stays true. Cutter compensation type is non-null only for the Fanuc and the Syntec table. Tool-axis direction is non-null only for the Heidenhain table. Each guard is the Fanuc dependency's value if one resolves, otherwise the Siemens dependency's, otherwise null. The panel's own conditions are != null on those five keys. No snapshot flag decides a field on this leaf; the only one read at all is the shared no-runner guard. The snapshot's brand marker is read twice more, but only to choose between the two guard label pairs — never to show or hide anything. Three flags in the snapshot describe exactly these fields and are read by nothing. hasCutterComp, hasToolAxisDirection and hasIterationGuards are computed server-side, typed, defaulted and parsed in the client's API layer, and no component consults any of them. They remain a live part of the REST snapshot for any other client. Two notes about the third: hasIterationGuards probes the Fanuc and the Siemens jump-guard types only. The Heidenhain preset carries a jump guard of its own type, so the flag reports false for a brand that has one. That matches what the panel shows on the shipped presets — the reader probes the same two types, so the Heidenhain guard has no field either — while under-describing the runner. Its doc comment names the Fanuc GOTO / WHILE-DO guards alone while the code also matches the Siemens jump guard. The code is what ships. The panel's whole body — the guards included — is hidden behind present, which reports the parameter table and nothing else: \"No controller parameter table on the active runner.\" The guards live on separate dependencies with their own write endpoints, so a runner carrying guards but no parameter table would hide two reachable fields. All five brand presets carry a parameter-table proxy, so the combination does not arise on a shipped preset. Units: Edited Versus Stored Every value but one is stored in the unit it is edited in. Value Edited as Stored as Max spindle speed rpm rpm, in the table's system-parameter row Cutter compensation type one of three named options the option's index, 0 / 1 / 2, as a number in the same row set Tool-axis direction one of Z / Y / X 0 / 1 / 2 in the same row set Macro guards a plain count the same count, on the guard dependency Peck retraction clearance mm mm on Fanuc and Mazak, microns on Syntec, mm on the generic fallback Syntec is the one brand whose stored unit differs from the edited one, and the peck clearance is the one value it happens to. The Syntec table's accessor divides its stored row by 1000 on read and the write multiplies by 1000, so this leaf shows 5 on every brand while the native leaf shows 5000 under Pr4002 on Syntec and 5 under #4002 on Fanuc and Mazak. An operator copying a number off a real controller reads the native form; an operator entering a clearance in millimetres reads this one. The two are the same setting. The two select fields are the second unit hazard, in a milder form: the native leaf shows their stored number, 0, 1 or 2, with the brand table's own description of that number under the id, and never the words Type A or Z. Not every value reaches the native form at all. The two macro guards are properties of their own runner-owned dependencies rather than rows of any table, so they appear there on no brand; the peck clearance does the same on Siemens and Heidenhain, where the generic fallback supplies it. Peck Retraction Clearance Canned Cycle (Peck) is a single numeric field labelled Peck retraction clearance (G83), in millimetres, at zero or above, with a caption naming where the value is stored. Its model is PeckRetractionDistance_mm, and the read reports which implementation answered. Three can, and between them they cover every shipped preset: Caption the user reads Answered by Brands Stored in the Fanuc parameter table (#4002, mm). FanucParameterTable Fanuc, Mazak Stored in the Syntec parameter table (Pr4002, microns) — edited here in mm. SyntecParameterTable Syntec This brand takes the clearance per call (CYCLE83 / CYCL DEF); this value is the fallback used when a call omits it. FallbackConfig Siemens, Heidenhain That third caption describes an override the mapping does not implement. The Siemens and Heidenhain front-end syntaxes translate their own cycle vocabulary into the shared ISO cycle section, whose key set is fixed at X, Y, Z, R, Q, F, P and K — and none of those eight is a retraction clearance. The CYCLE83 mapping fills the R plane, the hole bottom Z and the first peck depth Q; the klartext cycle mapping fills the same three plus a bottom dwell and a feed, and folds the klartext set-up clearance into the R plane rather than keeping a slot of its own. The shared G83 expansion then reads the clearance from this dependency unconditionally. So on those two brands the value here is not a fallback for an omitted argument: it is the clearance every pecking cycle uses. An ICannedCycleConfig implementation outside those three answers a fourth source token, which no caption is written for: the field renders at the value that implementation supplies and the line under it is blank. It is the peck counterpart of the null a parameter table outside the four returns on the other leaf. Which storage answered also decides where the value lives. On Fanuc, Mazak and Syntec it is a row of the project's parameter table and appears in the native form; on Siemens and Heidenhain it is a field of a plain runner-owned dependency, so it appears in no native form and a brand apply returns it to the preset default — see Machine and Controller Plane. The value is consumed by two cycle expansions and they use it differently. In G83 it is the clearance the tool rapids down to above the previous stroke bottom before feeding deeper; in G73 it is the whole chip-break retract distance between strokes. The field's label names G83 only. G73 expands on Fanuc, Mazak, Syntec and Siemens; the Heidenhain syntax list registers the G83 expansion without it. What the Values Reach Four of the six values are read by the parsing pipeline; the other two are stored declarations. Peck retraction clearance drives the two cycle expansions above. Tool-axis direction is read where a Heidenhain PLANE SPATIAL … COORD ROT block is resolved: it decides which spatial angle may be non-zero for the rotation to count as purely about the tool axis, which is the only case where COORD ROT suppresses rotary positioning and rotates the coordinate system instead. The macro guards are soft caps with runtime counters. Above the cap the consuming block emits an iteration-limit warning and stops firing the jump or the loop back-edge, so a runaway macro ends as a diagnostic instead of an unbounded run. Each is keyed per source file and per target — per N target, per label or per loop — and the counters reset on the session-init edge while the cap does not. Max spindle speed and cutter compensation type are stored, edited and serialized, and no syntax or semantic in the shipped pipeline reads either. Cutter radius compensation itself is resolved, by the G41 / G42 / G40 pass over the motion sections; what that pass does not consult is the A / B / C startup-and-cancel vector style this field records. Defaults a Freshly Seeded Table Opens On Each brand's default table decides what the fields show once that brand's table is cloned fresh into a project; the guards are plain preset entries and are re-created at their type defaults on every apply. Value Fanuc, Mazak Syntec Siemens Heidenhain Max spindle speed 60000 24000 60000 60000 Cutter compensation type Type A Type A — — Tool-axis direction — — — Z GOTO jump cap 1000 1000 1000 — Loop cap 10000 10000 10000 — Peck retraction clearance 5 mm 5 mm (5000 stored) 5 mm (fallback) 5 mm (fallback) The table-backed values — the first three rows, and the peck clearance on the three brands whose parameter table stores it — are reached only by an apply that leaves the project holding no table of the incoming proxy's type: the outgoing brand's table is swept and the incoming proxy clones its seed in place of it. Fanuc and Mazak share one table type, so the hop between those two re-binds the project's existing table instead, and every value in it survives with its edits. The two guards and the fallback clearance are runner-owned and return to the preset's on every apply, whichever brands it runs between. The two caps differ by an order of magnitude on purpose: a jump is not the legitimate bulk-iteration primitive, so its cap stays tight, while loops are what generated drill grids and calibration sweeps are built from. Reading a Field Can Create Its Row Both readers reach the stored values through accessors that write a default into the table when the row is absent. Opening either leaf on a table whose max-spindle, cutter-comp, tool-axis or peck row was deleted from Parameters (Native) therefore re-creates that row at the type's default, in the live project-owned table, with no edit and no request from the user. On Heidenhain — which has neither a cutter-comp row nor a peck row — the max-spindle and tool-axis rows are the whole set. The native leaf's delete removes the row; the next read of this leaf puts it back. The guard dependencies have no such behaviour — their values are ordinary properties with field initializers. Editing a Field Both leaves follow the branch's shared commit, rollback and toast rules, which are Editing Contract. Four details are specific to these two leaves: The numeric fields commit on blur or on Enter, never per keystroke; their full contract is Numeric Input. The two selects commit on the pick. Each write is one field. Every control has its own endpoint and sends only its own value; no edit here resends a neighbouring field. A value the handler refuses is left on screen. Clearing a field parses to null and the handler returns before the request; a guard field additionally refuses anything that is not a whole number, and every numeric handler here refuses a non-finite one — the field accepts the words Infinity and NaN as text and turns them into numbers, and the handlers are what stop them. In each case the box keeps what was typed — blank, where the field was cleared — while the stored value stands, because nothing re-writes the box until the panel is remounted by selecting another node and coming back. A bound violation never reaches a handler at all. The numeric field itself refuses a value below its minimum and shows an untranslated Must be ≥ … under the box. Each handler carries a lower-bound test of its own — 1 on a guard, 0 on the peck clearance — but the field's own minimum is the same number and stops every finite value first, so those tests decide nothing. Layout General Setup Control Tree — the left dock of /general-setup Controller Node Row Machine / Controller Group Row Controller Parameters Node Row — equipment/controller/machine/parameters Canned Cycle (Peck) Node Row — equipment/controller/machine/canned-cycle Editor Row — the panel of whichever node is selected Controller Parameters Panel — one column, gutter-spaced Max spindle speed Numeric Field — dense, outlined, suffixed rpm, minimum 0 Cutter compensation startup / cancel type Select — dense, outlined; options Type A, Type B, Type C Tool-axis direction Select — dense, outlined; options Z, Y, X Guard Group — rendered only when at least one guard value resolves Separator Macro loop guards (advanced) Caption Jump-Guard Numeric Field — minimum 1; labelled GOTO — max jumps per N target or GOTOF/GOTOB — max jumps per label Loop-Guard Numeric Field — minimum 1; labelled WHILE/DO — max iterations per loop or WHILE / FOR / REPEAT / LOOP — max iterations per loop No-Table Block — replaces every field above: \"No controller parameter table on the active runner.\" Canned Cycle (Peck) Panel — one column, gutter-spaced Peck retraction clearance (G83) Numeric Field — dense, outlined, suffixed mm, minimum 0 Source Caption — one of the three sentences in the table above, or empty where a fourth implementation answered No-Config Block — replaces both: \"No canned-cycle config on the active runner.\" Shared Empty State — replaces either panel's whole body while the snapshot reports no runner: \"No NC runner — load a project first.\" Neither panel has a table, an add-row control, a delete control or a Save button. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/SoftNcControllerParamsPanel.vue — the five-field panel: the per-field != null conditions, the guard group's combined condition, the brand-marker choice between the two guard label pairs, the translated compensation-type options beside the literal tool-axis letters, and the three commit handlers with their null, non-finite and integer refusals beside the lower-bound tests the field's own minimum shadows. wwwroot-src/src/components/controlTree/SoftNcCannedCyclePanel.vue — the peck panel: the single field, the presence layer, and the caption chosen from the read's source token. wwwroot-src/src/components/controlTree/SoftNcEmptyState.vue — the shared no-runner line both panels open with. wwwroot-src/src/components/widgets/NumericInput.vue — the numeric field: the unit rendered as a suffix, commit on blur or Enter, the empty-text-to-null parse both panels reject, and the untranslated bound message that stops a value before it is emitted. wwwroot-src/src/components/controlTree/softNcItemTypes.ts — the two node ids and their labels: Controller Parameters among the unconditional machine leaves, Canned Cycle (Peck) behind the peck-provider flag. wwwroot-src/src/api/softNcRunner.ts — the two readers and their setters, the five nullable parameter keys, the peck source token, and the three snapshot flags that describe these fields and are declared, defaulted and parsed without a consumer. wwwroot-src/src/composables/useSoftNcRunner.ts — the shared runner snapshot the first empty layer reads. wwwroot-src/src/i18n/en/softNc.ts — the two node labels, the five field labels, the two guard label pairs, the compensation-type options, the macro-guard caption, the three peck source sentences and the two empty-state lines quoted above. Mech/SoftNcRunnerController.cs — the REST surface: the parameter read's type switches and its table-only presence flag, one write per field, the guard writes that fall back from the Fanuc dependency to the Siemens one, the peck read with its source token, and the peck write that converts to microns for the Syntec table. HiAPI Engine HiMech/NcParsers/Dependencys/ControllerParameterTableBase.cs — the base every brand table extends, and the raw system-parameter dictionary the first three fields are rows of. HiMech/NcParsers/Dependencys/Fanuc/FanucParameterTable.cs — the Fanuc and Mazak table: the max-spindle, peck-clearance and cutter-comp parameter numbers, the compensation-type enum with its three vector styles, the millimetre peck accessor, and the default seed. HiMech/NcParsers/Dependencys/Syntec/SyntecParameterTable.cs — the Syntec table: the same three parameter numbers, the micron peck row and the accessor that converts it, and the default seed. HiMech/NcParsers/Dependencys/Siemens/SiemensMachineDataTable.cs — the Siemens table: the max-spindle machine datum, and the absence of any compensation-type or peck member. HiMech/NcParsers/Dependencys/Heidenhain/HeidenhainParameterTable.cs — the Heidenhain table: the max-spindle and tool-axis-direction machine parameters and their default seed. HiMech/NcParsers/Dependencys/Fanuc/FanucParameterTableProxy.cs — the proxy shape all four brand tables share: the seed clone that fires only where the project holds no table of that type, and the pure take afterwards. HiMech/NcParsers/Dependencys/ICannedCycleConfig.cs — the peck-clearance contract and its three implementations. HiMech/NcParsers/Dependencys/Generic/FallbackConfig.cs — the runner-owned clearance the Siemens and Heidenhain presets carry, and its millimetre default. HiMech/NcParsers/Dependencys/Fanuc/FanucGotoIterationDependency.cs, HiMech/NcParsers/Dependencys/Fanuc/FanucWhileDoIterationDependency.cs, HiMech/NcParsers/Dependencys/Siemens/SiemensGotoIterationDependency.cs, HiMech/NcParsers/Dependencys/Siemens/SiemensLoopIterationDependency.cs — the four guards the two advanced fields write: their caps, their per-file counters and the session reset that clears the counters alone. HiMech/NcParsers/Dependencys/Heidenhain/HeidenhainGotoIterationDependency.cs — the fifth guard, the one the reader does not probe and no field edits. HiMech/NcParsers/SoftNcRunner.cs — the five brand presets: which parameter-table proxy, which guards and whether a fallback clearance each one carries. HiMech/NcParsers/LogicSyntaxs/CannedCycleSyntaxUtil.cs — the shared ISO cycle section: the fixed eight-key parameter set none of whose keys is a retraction clearance, and the modal merge that consumes them. HiMech/NcParsers/LogicSyntaxs/PeckDrillingCycleSyntax.cs — the G83 expansion, which reads the clearance from the dependency rather than from the block. HiMech/NcParsers/LogicSyntaxs/HighSpeedPeckCycleSyntax.cs — the G73 expansion that spends the same value as the chip-break retract distance. HiMech/NcParsers/Syntaxs/FanucSyntaxUtil.cs, HiMech/NcParsers/Syntaxs/MazakSyntaxUtil.cs, HiMech/NcParsers/Syntaxs/SyntecSyntaxUtil.cs, HiMech/NcParsers/Syntaxs/SiemensSyntaxUtil.cs, HiMech/NcParsers/Syntaxs/HeidenhainSyntaxUtil.cs — the five brand syntax lists, and which of them register both peck expansions against the one that registers the G83 expansion alone. HiMech/NcParsers/LogicSyntaxs/Siemens/SiemensModalCycleSyntax.cs — the CYCLE83 mapping onto the shared cycle section, and the arguments it drops. HiMech/NcParsers/LogicSyntaxs/Heidenhain/HeidenhainCannedCycleSyntax.cs — the klartext cycle mapping onto the same section. HiMech/NcParsers/LogicSyntaxs/Heidenhain/HeidenhainPlaneTiltSyntax.cs — the one consumer of the tool-axis direction: the pure-tool-axis test that decides whether COORD ROT suppresses rotary positioning. HiMech/NcParsers/PostLogicSyntaxs/RadiusCompensationSyntax.cs — the cutter radius compensation that is resolved, and that does not consult the stored startup-and-cancel type. HiGeom/Common/Collections/DictionaryUtil.cs — the get-or-create the table accessors read through, and therefore why a read re-creates a deleted parameter row. See Also Machine and Controller Plane — the plane these two leaves sit on, and which half of the project each of their values is stored in Brand Matrix — why one of the two leaves is gated and the other is not, and which brand resolves which parameter table Editing Contract — the fetch, commit, rollback and empty-layer rules these panels share with the rest of the branch Native Parameters — the same rows by number, in their raw stored units, including the peck clearance this page shows converted"
  },
  "anatomy/general-setup/controller/machine/m-code-declarations.html": {
    "href": "anatomy/general-setup/controller/machine/m-code-declarations.html",
    "title": "M-Code Declarations | HiAPI-C# 2025",
    "summary": "M-Code Declarations M-Code Declarations is the leaf that gives a machine's own M-codes a meaning the parser can act on — what each machine-specific (OEM or PLC) code does — and it carries beside them the tool-change trigger mode that decides whether a bare T word changes the tool by itself. It lives on the General Setup page at /general-setup under the Control-Tree id equipment/controller/machine/m-codes, grown while the runner snapshot reports a brand controller parameter table. Both the declaration map and the trigger flag are stored on that one table, so this leaf appears and disappears together with Parameters (Native), and the rows declared on it travel with the project rather than with the runner file, which carries only the preset seed a fresh project's table is cloned from. Important Anatomy makes no claim that any id named here is stable across versions. The migration hop that keeps an older ?tree= value resolving is described in Tree Ids and Routes. The One Object Behind Both Halves ControllerParameterTableBase implements IMCodeDeclarationConfig and IToolChangeTriggerConfig over its own storage, so the table every brand carries supplies the whole leaf: the declaration map keyed on the code as parsed, and the single trigger boolean. A third face, ISpindleControlConfig, reads the same map for spindle direction alone rather than keeping a second one, which is why one code is never half-recognized by two separate dictionaries. The tree gate and the panel's own second empty layer probe the same type. The branch builder grows the node while the snapshot's hasNativeTable flag is set, and the read answers a presence flag computed from the same resolved parameter table; every shipped brand preset carries one, so in practice the leaf is unconditional and the \"No controller parameter table on the active runner.\" line is reachable only on a runner assembled by hand or loaded from XML. Which brand satisfies which gate is Brand Matrix. Because the map is a member of the brand parameter table, and that table is the project's per-case copy rather than the runner's, declarations survive installing another runner file of the same brand — see Machine and Controller Plane for which half of a project each value on this plane is written into. What a Declaration Carries One row is one MCodeEffects, and a real OEM code is frequently composite, so the row records every effect the code performs rather than a single meaning. Column Effect What the code expands to Tool change IsToolChange M06 Spindle SpindleDirection M03 for CW, M04 for CCW, M05 for STOP Coolant CoolantMode M07 for Mist, M08 for Flood, M09 for Off Not-simulated note UnmodeledNote nothing — it raises one informational diagnostic per occurrence The two pickers each open on a dash, which is the null option: a declaration that touches neither the spindle nor the coolant carries neither. The note is free text and is itself an effect — a code whose real behaviour is a chip conveyor or a door interlock is declared with the note alone, and every occurrence then reports DeclaredMCode--UnmodeledEffects at message severity instead of the unknown-code warning. A declaration with no effect and no note is the fourth legal state and means consume this code silently, which the panel's hint says in as many words: \"A declaration with nothing set consumes its code silently.\" That fourth state is what a freshly declared row is. Declare writes a row whose tool-change box is clear, whose two pickers sit on the dash and whose note is empty, so the act of naming a code already silences it; the fields are then filled in against a live row. How a Declared Code Is Read MCodeExpansionSyntax rewrites the declared flag into the canonical ISO flags the ordinary consumers already understand, and it runs ahead of them: SpindleSpeedSyntax, CoolantSyntax and ToolChangeSyntax each then see the flag they know. Expanding once, early, is what lets a single composite code feed several consumers without any of them fighting over which removes the original flag. Three rules of the rewrite are visible in a program: The expansion sits at the declared flag's own position, and a repeat of the same declared code later in the block is dropped. Textual order therefore keeps deciding last-wins conflicts exactly as it did before any declaration existed — a composite code followed by a raw M05 still ends with the spindle stopped. A canonical flag that also appears raw and undeclared in the same block is not emitted twice. The raw occurrence keeps its position, so the expansion cannot reorder what the block already said. Undeclared codes are untouched. One that no other syntax consumes then reaches UnconsumedCheckSyntax, which reports it as Parsing--Unconsumed — the warning this leaf exists to answer. The spindle-only row takes a different path A declaration whose sole content is a spindle direction is deliberately not expanded. IsSpindleDirectionOnly marks it, the expansion skips it, and SpindleSpeedSyntax resolves it in place through TryResolveDirection(API). What separates the two paths is mechanism, not reach. The resolver is consulted before the built-in ISO mapping, so a spindle-only row overrides a canonical code where the code stands, with no rewrite at all — declaring M03 as CCW makes M03 turn the spindle counter-clockwise. Add any second effect to the same row and it leaves that path for the expansion, which arrives at the same place by rewriting: the declared flag is replaced by the ISO flags its effects name, so declaring M08 as Mist makes the block emit M07 instead. On either path a declaration over a canonical code wins against that code's built-in meaning. The split also reaches the project file. A spindle-only row serializes as the legacy <SpindleMCode> element so an older reader still resolves it; every other row serializes as <MCode> with one attribute per effect that is set. A row with nothing set writes an <MCode> element carrying only its code, so the silent-consume state round-trips. What the writer refuses The declare endpoint validates before it stores. An empty code is answered unsuccessfully; so is a spindle direction that is not CW / CCW / STOP and a coolant mode that is not Mist / Flood / Off, and those two answers quote the rejected value back alongside the set that was expected. A typo therefore cannot degrade into a declaration that consumes a code silently. The panel's two pickers cannot produce such a value; the guard is there for the other writers of the same table. A coolant mode that names no known mode can still arrive from a project file, because the XML reader keeps the attribute raw rather than normalizing it and write-then-read stays an identity. The expansion is where that surfaces: it reports DeclaredMCode--UnknownCoolantMode, skips the coolant half, and emits the rest of the declaration. The Tool-Change Trigger Mode The toggle above the table reads \"T word performs the tool change itself (turret / lathe)\" and writes ToolWordTriggersChange. It defaults off, which is machining-centre behaviour: a T word only pre-selects, the magazine rotates without moving a feed axis, and the trigger M-code performs the change. Turned on, ToolChangeSyntax treats a block carrying a T word and no tool-change flag as the change itself and records T as the triggering term. The test is per block: a block carrying both a T word and a tool-change flag is unaffected — the flag wins and M06 is recorded — so no single block is counted twice. Where the two words sit in different blocks — a T pre-select first, an M06 later — the mode counts the T block as a change on its own, and the M06 block then records a second one, its tool number arriving modally. The toggle therefore belongs on a machine whose T word really performs the change; on a machining centre it turns every pre-select into a change of its own. On the Siemens machine-data table the flag is not a field of its own. That table binds the property to its tool-change-mode row, MdToolChangeMode: present, the row decides — a stored zero means the T word changes the tool — and the toggle writes back into it as 0 or 1 rather than into the brand-neutral field; absent, the table behaves like every other brand. The write is skipped when the effective value already matches, so copying a table never rewrites a raw machine-data value of 2 down to 1. The same row is visible and editable by number on Parameters (Native), and the two forms are one storage. The Rows The read returns the declarations sorted by code as text, case-insensitively, not by numeric value. M106 therefore sorts ahead of M12, and M6 lands after M331. Keys are matched case-insensitively too, so m13 and M13 are one declaration and cannot both exist; re-declaring a code in a different spelling replaces its effects and leaves the spelling already stored on display. The Code cell is plain bold text with no editor — a code is changed by declaring the new one and deleting the old. Only one brand's default parameter table pre-declares anything. The Siemens machine-data default seeds six auxiliary codes — M12, M13, M22, M23, M330 and M331 — each carrying no effect and the same note, “machine-specific auxiliary function (OEM/PLC); the exact behavior depends on the machine”. Those recur often enough in real Siemens programs to be worth silencing with an explanation rather than a warning, and a machine table that knows their actual effects overrides the seeded note. On the other four brands the table opens empty. Editing, Adding and Removing Every cell commits on its own, and the write is the whole declaration: the handler merges the edited field into the row and sends all four values, so an edit rewrites the row from what the panel is currently showing. The checkbox and the two pickers commit on the click or the pick; the note cell commits through its field's native change event, which is this branch's third text-commit wiring and is recorded as such in Editing Contract — that page also carries the optimistic-write, rollback and toast rules these cells share with the rest of the branch. The footer holds a single field labelled M-code, hinted M106, and a Declare button. Enter in that field submits, which no other add-row footer in the branch does. A blank code raises the toast \"M-code must not be empty.\" locally and never reaches the server. A successful declare clears the field and re-reads the whole table, so the new row appears in sort position rather than at the end. Removal is the trash button at the end of each row. It carries no confirmation dialog, and the row leaves the list only after the server has answered — the delete is not optimistic. The removed code returns to what it was before the declaration: Parsing--Unconsumed wherever a program uses it, unless a shared or brand syntax already knew the code, in which case it goes back to that built-in meaning. What This Table Does Not Show The stored map is not the whole of what a machine honours, and three families of M-code behaviour live outside it. The canonical ISO codes. M06, M03 / M04 / M05 and M07 / M08 / M09 are consumed by the shared syntaxes with no declaration at all; this table exists for the codes those consumers do not already know. Declaring a canonical code is still legal and still honoured — a note-only declaration on M08, for instance, consumes the raw M08 for its own declaration while a composite code's flood half continues to emit M08. A brand's own M-function dialect. The Heidenhain preset's HeidenhainMFunctionSyntax owns M126 / M127 (shortest-path rotary traverse) and M140 (tool-axis retract) as brand meanings, not as declarations, so none of them is a row here. That preset's syntax list places the expansion ahead of the brand syntax precisely so a machine that redefines one of those codes can say so: a declaration for M126 is expanded and consumed before the brand meaning is reached, and the declaration wins. The Siemens tool-change M function. The Siemens machine-data table's MdToolChangeMCode row names the M function that performs a tool change, and the table overlays a tool-change declaration for it onto the view the parsers resolve — merged into a clone of any explicit declaration on the same code, so a note or coolant half is kept, and never written into the stored map. The panel reads the stored map, so that overlaid row is not on screen. A Siemens machine whose machine data names a non-standard trigger honours it in every program while this table lists nothing for it; the value lives on Parameters (Native) as the machine-data row, in the raw form an operator reads off the real controller. The overlay's own rules matter when the two views are compared: the raw number is zero-padded to the parsed flag form, so 6 becomes M06 and 106 becomes M106; a value that is not a positive whole number overlays nothing; and a code already declared as a tool change here is left exactly as stored. The trigger toggle above the table does not share that blind spot. It is read through the property the Siemens table overrides, so it shows the machine data's answer, while the rows beside it show only what was declared. The asymmetry is the single most useful thing to know about this leaf: the mode is the effective value, the table is the stored one. One further consequence of the overlay is invisible in both views. Spindle-only resolution also runs against the overlaid view, so a code that the machine data names as the tool-change trigger and that is also declared here with a spindle direction alone stops being spindle-only: it leaves the in-place resolver and is expanded instead, emitting both the tool change and the direction. Layout General Setup Control Tree — the left dock of /general-setup Controller Node Row Machine / Controller Group Row M-Code Declarations Node Row — equipment/controller/machine/m-codes Editor Row — M-Code Declarations Panel No-Runner Line — \"No NC runner — load a project first.\", the branch's shared empty state, shown while the snapshot reports no runner No-Table Line — \"No controller parameter table on the active runner.\", shown when the read itself reports no table T word performs the tool change itself (turret / lathe) Toggle Hint Caption — \"Declares machine-specific M-codes: a tool-change trigger other than M6, composite OEM codes (e.g. M13 = spindle CW + flood coolant), or known-but-unsimulated codes (note only, one info message per occurrence). A declaration with nothing set consumes its code silently. Undeclared codes keep the unconsumed warning.\" Declaration Table — dense, flat and bordered, one row per declared code Header Row — Code, Tool change, Spindle, Coolant, Not-simulated note, and an unlabelled action column Code Cell — bold plain text, not editable Tool change CheckBox Spindle Select — a dash, CW (M03), CCW (M04), STOP (M05) Coolant Select — a dash, Mist (M07), Flood (M08), Off (M09) Not-simulated note Field — placeholder e.g. chip conveyor forward Delete Button — a trash icon, no confirmation Add Row Footer M-code Field — placeholder M106; Enter submits Declare Button The panel mounts against one node and takes nothing from it: unlike the per-axis leaves it serves a single tree id, so it reads no role off the node's path. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/SoftNcMCodesPanel.vue — this panel: the two empty layers, the trigger toggle, the two option lists with their dash entry, the whole-declaration write behind every cell, the change-event note cell, the Enter-submitting add footer and the confirmation-free delete. wwwroot-src/src/components/controlTree/SoftNcEmptyState.vue — the shared no-runner line the panel opens with. wwwroot-src/src/components/controlTree/softNcItemTypes.ts — the node id, its label and label key, the snapshot flag it is grown behind, and the item type that binds it to the panel. wwwroot-src/src/api/softNcRunner.ts — the declaration row and snapshot shapes, the reader that coerces an empty string to a null field, the whole-declaration writer, the delete, and the trigger setter. wwwroot-src/src/composables/useSoftNcRunner.ts — the shared runner snapshot the first empty layer reads. wwwroot-src/src/i18n/en/softNc.ts — the node label, the toggle label, the hint, the column headers, the two option label sets, the note placeholder, the empty-code toast and the two empty strings quoted above. Mech/SoftNcRunnerController.cs — the REST surface: the read with its presence flag and its case-insensitive text ordering, the declare endpoint's direction and coolant validation, the delete, the trigger write, and the shared helper that answers a missing dependency with an unsuccessful body rather than an error status. HiAPI Engine HiMech/NcParsers/Dependencys/IMCodeDeclarationConfig.cs — the declaration contract: the map, the lookup that returns false for an undeclared code, and the declare and remove mutators whose stored effects are copied rather than aliased. HiMech/NcParsers/Dependencys/MCodeEffects.cs — the four effects, the empty and spindle-only predicates that partition the two consumption paths, and the coolant-mode normalizer. HiMech/NcParsers/Dependencys/IToolChangeTriggerConfig.cs — the trigger contract and the magazine-versus-turret distinction it encodes. HiMech/NcParsers/Dependencys/ISpindleControlConfig.cs — the narrower spindle face over the same storage, and the resolver the spindle-only rows take. HiMech/NcParsers/Dependencys/ControllerParameterTableBase.cs — the storage every brand inherits: the case-insensitive map, the overridable effective view, the virtual trigger property, and the XML round trip that writes a spindle-only row as the legacy element. HiMech/NcParsers/Dependencys/Siemens/SiemensMachineDataTable.cs — the two machine-data rows that change this leaf's meaning: the tool-change mode bound to the trigger property, the tool-change M function overlaid onto the effective view with its zero-padding rule, and the six auxiliary codes the default table pre-declares. HiMech/NcParsers/LogicSyntaxs/MCodeExpansionSyntax.cs — the rewrite: in-place expansion, the duplicate and raw-twin guards, the spindle-only skip, and the two diagnostics a declaration can raise. HiMech/NcParsers/LogicSyntaxs/ToolChangeSyntax.cs — the consumer of the expanded tool change and of the trigger mode, and the term it records for each. HiMech/NcParsers/LogicSyntaxs/SpindleSpeedSyntax.cs — the consumer that tries the machine map before the ISO defaults, which is what lets a spindle-only row remap a canonical code. HiMech/NcParsers/LogicSyntaxs/CoolantSyntax.cs — the consumer of the three expanded coolant flags. HiMech/NcParsers/LogicSyntaxs/Heidenhain/HeidenhainMFunctionSyntax.cs — the brand meanings a declaration can pre-empt on that preset. HiMech/NcParsers/InspectionSyntaxs/UnconsumedCheckSyntax.cs — the warning an undeclared code keeps, and the one a declaration removes. HiMech/NcParsers/Syntaxs/FanucSyntaxUtil.cs, HiMech/NcParsers/Syntaxs/SiemensSyntaxUtil.cs, HiMech/NcParsers/Syntaxs/SyntecSyntaxUtil.cs, HiMech/NcParsers/Syntaxs/MazakSyntaxUtil.cs, HiMech/NcParsers/Syntaxs/HeidenhainSyntaxUtil.cs — where the expansion sits in each brand's syntax list, and why the Heidenhain list anchors it earlier than the rest. HiMech/NcParsers/Keywords/Generic/IsoKeywords.cs — the canonical flag spellings the expansion emits, M06 among them. HiMech/NcParsers/Keywords/ICoolantDef.cs — the three coolant constants the picker's values map to. HiGeom/Numerical/SpindleDirection.cs — the direction enum behind the spindle column. See Also Machine and Controller Plane — the plane this leaf sits on, and which half of a project the declaration map is written into Brand Matrix — the flag that grows this node, and why it is never false on a shipped brand preset Editing Contract — the fetch, commit, rollback and toast rules this panel shares with the branch, and the two places it is recorded as departing from them"
  },
  "anatomy/general-setup/controller/machine/native-parameters.html": {
    "href": "anatomy/general-setup/controller/machine/native-parameters.html",
    "title": "Native Parameters | HiAPI-C# 2025",
    "summary": "Native Parameters Parameters (Native) is the machine plane's escape hatch: the brand parameter table rendered as the flat numbered form an operator reads off the real control, with no domain vocabulary and no unit conversion in between. It lives on the General Setup page at /general-setup under the Control-Tree id equipment/controller/machine/native, and it is one of the two leaves the hasNativeTable snapshot flag grows — the other, M-Code Declarations, edits a different part of the same object. Every value the domain-grouped leaves beside it edit that is a row of the brand parameter table is a row here; the ones stored elsewhere — the tool-change pose, the block-skip layers, the subprogram folders and the indexing position lists among them — reach no native form at all. Several rows here reach no domain-grouped face. Important Anatomy makes no claim that any id named here is stable across versions. The migration hop that keeps an older ?tree= value resolving is described in Tree Ids and Routes. The leaf is pushed behind hasNativeTable, which reports whether any ControllerParameterTableBase resolves in the runner's effective dependency list. All five shipped presets carry one, so the flag is a gate in code and unconditional in practice — see Brand Matrix. How a Parameter Is Addressed The table stores its numbers in three dictionaries, and the panel is those three dictionaries with a heading over each: Section heading the user reads Backing storage Cell System parameters SystemParams one value per id Axis parameters AxisParams one floating-point value per id per axis Axis parameters (integer) IntAxisParams one integer value per id per axis An id is a bare number in storage. What the panel prints in front of it is the brand's prefix, and that prefix is the whole of the addressing convention: Brand marker Prefix shown Table that answers Example row Fanuc # FanucParameterTable #1420 rapid traverse rate Mazak # the Fanuc table #1420 rapid traverse rate Syntec Pr SyntecParameterTable Pr1420 rapid traverse rate Siemens MD SiemensMachineDataTable MD32000 max axis velocity Heidenhain MP HeidenhainParameterTable MP1010 rapid traverse rate Mazak borrows the Fanuc table outright. The Mazak preset carries the Fanuc parameter-table proxy rather than one of its own, so the prefix resolves to # and every number on this leaf is a Fanuc parameter number under a Mazak brand badge. The prefix is not taken from the brand marker string but from the type of the parameter table that resolved, so the two cannot drift apart the way a brand-marker label can — see Brand Matrix. A ControllerParameterTableBase subclass outside those four resolves an empty prefix, and the ids then render bare. No shipped preset produces that. The prefix the panel renders comes from the leaf's own read of the parameter form. The shared runner snapshot carries a prefix field of its own, and nothing renders it. The caption under the id Each id cell carries the number in bold and, beneath it, a short usage caption — Rapid traverse rate (mm/min or deg/min), Axis type (0 linear / 1 rotary / 2 spindle), G54 X offset, Tool change M function code. The same text repeats as the cell's hover title. The caption is the brand table's own description of a well-known number, produced by DescribeSystemParam(API) and its two per-axis counterparts, and it travels down the wire with the row. It is therefore engine text, not an interface string: it is written in English in the brand table and belongs to no locale bundle, so it reads the same under every language the application offers. An id the brand table does not model has no caption at all, which is how a modelled row and a free extra are told apart on screen. Raw Values, Raw Units The caption at the top of the panel states the rule: \"Raw stored values in native units — no unit conversion is applied here. The interface-form nodes edit the same backing table.\" No cell carries a unit suffix, and none can: the unit belongs to the number, not to the column. What a cell means is whatever the brand stores at that address — millimetres or degrees on a stroke limit, mm/min or deg/min on a rapid rate, rpm on a spindle limit, an enumeration ordinal on an axis type, a count on a controlled-axis parameter. The peck clearance is the case where the two forms visibly disagree, and it ships. Canned Cycle (Peck) always speaks millimetres; the Fanuc-family table stores millimetres at #4002, and the Syntec table stores microns at Pr4002. A machine at a 5 mm clearance therefore reads 5 on Interface Parameters on every brand, and reads 5 here on Fanuc and Mazak but 5000 here on Syntec. The write endpoint converts on the way in; this leaf does not, which is the point of it — an operator copying from a real Syntec control reads the micron form. Two further asymmetries follow from where a value is stored rather than from its unit: On Siemens and Heidenhain the peck clearance has no row here at all. Those two presets supply it through a generic fallback config, a plain runner entry rather than a parameter table, so the interface leaf shows a field whose backing has no place in this form. On the Fanuc-family and Syntec tables the work-coordinate offsets are rows of this table. The G54–G59 triads start at #5221 and the G54.1 P1–P48 triads at #7001, both on a stride of 20, all in the System parameters section. That mixing is why the machine plane's parameter table is stored on the project rather than on the runner — see Machine and Controller Plane. On the Fanuc-family table those two address ranges are also what an NC program's #-variable read resolves against, so those rows are live in both directions. What Only This Leaf Reaches Most rows have a domain-grouped twin. These do not. The axis roster itself. Every per-axis leaf of the branch — Machine Limits (Stroke), Rapid Feedrates, Home / G28 Reference, Tool-Change Position — lists the axes named by the axis-type row of this table (#1006, Pr1006, MD30300, MP400), because AxisNames is that row's key set. None of those leaves can add an axis, rename one, remove one, or change one from linear to rotary; their columns are handed to them. Inside the Controller branch the axis-type row is editable here and nowhere else, through the footer with the section set to Axis (integer), the brand's axis-type number as the id, an axis name, and a value of 0 linear, 1 rotary or 2 spindle. The one other writer is outside the branch entirely: ConfigureByMachiningChain(API) stamps the machining chain's axis codes into the same row when a machine tool is attached to the project; an axis the chain does not name stays in the row. That call does not stop at the axis-type row: a chain axis it marks rotary also has its reference position set to 0 and its rapid rate to 36000 deg/min, whatever those two Axis parameters rows held. The inverse holds, with one exception. Deleting the axis-type row leaves the table with no named axes, so Machine Limits (Stroke), Rapid Feedrates and Home / G28 Reference have no rows left to draw. Tool-Change Position keeps its own: its reader falls back to the tool-change configuration's own axis keys when the axis set is empty, and every shipped preset seeds that configuration with X, Y and Z. Rows recovered that way carry no axis type and are reported linear. The Siemens indexing machine data, all four numbers. MD30500, the per-axis assignment that decides which axis consumes which position table, is shown on Indexing Position Tables as display-only text and is written here as an Axis parameters (integer) row; the REST surface carries no assignment writer at all. The equidistant definition — the numerator MD30501 and the offset MD30503 as axis parameters, the denominator MD30502 as an integer axis parameter — has no endpoint that reads or writes it and no panel that offers a cell for it: it is three ordinary rows on this leaf. The engine is its reader: an axis whose MD30500 is 3 resolves its station spacing from the trio, and Indexing Position Tables prints that axis' assignment as Equidistant (MD30501–MD30503), naming the three numbers it offers no cell for. The two position lists themselves are the mirror image, stored as list properties outside all three dictionaries and so absent from this form entirely. Numbers with no interface field. The controlled-axis count (#1020, Pr1020) is read by nothing in the web service. The Siemens fixed-point position MD30600, the G75 target, likewise. So is the Siemens tool-change M function MD22560, whose presence overlays a tool-change effect onto the named code in the declaration view the parsers resolve against. M-Code Declarations renders the stored map rather than that view, so the overlaid row is on no screen at all: the effect is honoured in every program the machine runs, and the one number that shows anywhere is this row. The Siemens tool-change mode MD22550 is a half case: where the row already exists, the T word performs the tool change itself toggle on M-Code Declarations writes it, and where it does not, that toggle writes a brand-neutral flag instead; creating the row is possible only here. Any number the model does not name. The three writers are get-or-create, so an id outside the brand's well-known set is accepted, stored, serialized into the project file and read back. It carries no usage caption, and the engine consumes only the numbers its brand table models — a free extra is a record, not a setting. A Fractional Number Has Three Fates The Axis parameters (integer) section is the one place on the branch where a value can be typed, accepted by the field, and silently discarded. The cell is the shared numeric widget, which commits on blur or Enter and carries no integer rule. Typing 2.5 parses cleanly: the widget clears its own error state, emits 2.5 to the panel, and rewrites its text to the parsed form. The panel's integer handler is where the value stops — it returns without assigning and without raising anything when the number is not whole. Because the bound value never changed, nothing pushes the stored integer back into the box. The cell goes on reading 2.5 over a table that still holds the old integer, with no error message, no toast and no console line. The row corrects itself only when the panel refetches: after an add, after a removal, or on a fresh mount when the selection leaves this leaf and comes back. The footer does not behave the same way. Add / Set with Axis (integer) selected truncates a fractional value toward zero and writes the truncation, so the same 2.5 becomes a stored 2; and the same button refuses a fractional Parameter id outright, with the message \"Enter a non-negative integer id and a value.\" That refusal belongs to the button, not to the box — the Parameter id field is the shared numeric widget with a minimum of 0 and no integer rule, so it accepts and keeps 2.5 the way any other cell does, and the one message answers an empty Value (raw) as well. Three controls, one number, three outcomes. Clearing any cell ends the same way for a different reason. An emptied field commits null, and all three handlers return early on null, so the box is blank and the stored value is untouched. There is no way to unset one cell of a table; the value stands until it is overwritten or its whole row is removed. The general rule for a box that disagrees with its model is Numeric Input; what is particular here is that the widget did nothing wrong — the panel accepted the commit and dropped it. Adding, Overwriting and Removing a Row The footer is one control set for both adding and overwriting, and the button says so: Add / Set. The write is get-or-create at every level — an unknown id creates its row, an unknown axis name creates its column — so setting an existing cell and creating a new one are the same request. The Axis field appears only while the section is not System, is free text, and is trimmed and checked for emptiness only. It is not validated against the machine's axes: any name is accepted and becomes a new column. A successful add re-reads the whole form. The footer's own fields are not cleared, and Enter does not submit — see Editing Contract for how the branch's add footers differ from one another. The two client-side refusals are the id, which must be a non-negative whole number, and, for the two per-axis sections, a non-empty axis name. Each raises a negative toast and sends nothing. Delete is per row, not per cell. The trailing button on a row of either per-axis table removes the id from that dictionary entirely — every axis column of it at once, not the cell it sits beside. A confirmation dialog comes first, titled Remove parameter and reading Remove <prefixed id> from the <section> section?, where the section word is the storage kind — system, axis, int-axis — rather than the heading printed above the table. The removal is not optimistic: the request is awaited and the whole form is re-read. A deleted well-known row can come back on its own. The brand tables' modelled accessors are get-or-create with a default, so a read through a sibling leaf re-materializes the row it wants. The clearest case is the maximum spindle speed: delete #3741 here, open Interface Parameters, and that read stores the brand's default back — 60000 on Fanuc, Mazak, Siemens and Heidenhain, 24000 on Syntec — so the row reappears at that value. The cutter-compensation type, the tool-axis direction and the peck clearance behave the same way. A free extra id has no accessor and stays deleted. What a Freshly Switched Brand Shows The seed each brand's proxy clones decides what the three tables open with. All five declare a linear X, Y and Z in the axis-type row, a reference position of zero per axis and a rapid rate per axis, so on every brand the Axis parameters section opens with two rows and the Axis parameters (integer) section with one. The System section is where they part company. Brand System parameters Axis parameters Axis parameters (integer) Fanuc, Mazak 166 rows — controlled axes, max spindle speed, peck retraction, cutter-comp type, and 162 seeded work-offset addresses at zero reference position, rapid rate axis type Syntec 166 rows — the same four under Pr numbering, the peck retraction in microns, and the same 162 offsets reference position, rapid rate axis type Siemens 1 row — max spindle speed reference position, max axis velocity axis type Heidenhain 2 rows — max spindle speed, tool-axis direction reference position, rapid rate axis type The 162 offset rows are SeedAllDefaults(API) writing every G54–G59 and G54.1 P1–P48 triad as zero, so that a managed address always has a value the way a real control with a fresh battery reads zero rather than nothing. They dominate the System section on the three brands that carry them, and their captions — G54 X offset, G54.1P12 Z offset — are what separates them from machine configuration in the same list. No brand seeds a stroke limit, so the positive and negative stroke-limit rows are absent from the Axis parameters section until Machine Limits (Stroke) or this leaf creates them. The Two Empty Layers, and Which One Is Reachable The panel opens through the branch's shared two-layer gate. The first layer is the shared \"No NC runner — load a project first.\" from the runner snapshot; the second is \"No controller parameter table on the active runner.\" from the leaf's own read — the same line M-Code Declarations and Interface Parameters show, and honest in all three, because every one of those reads reports presence from the same parameter-table lookup. Neither line is normally reached by navigating, because the node itself exists only while the snapshot reported a parameter table. The second line is also what a failed read leaves on screen: the presence flag starts false and the failure path only raises a toast. A failed write answers inside a success envelope — HTTP 200 carrying No ControllerParameterTableBase on the active runner — and surfaces as one negative toast, three seconds, the panel's localized context followed by that raw English sentence. The full rule is Editing Contract. Layout General Setup Control Tree — the left dock of /general-setup Controller Node Row Machine / Controller Group Row Parameters (Native) Node Row — equipment/controller/machine/native, the last leaf of the plane, after Indexing Position Tables Editor Row — the panel of the selected node Parameters (Native) Panel — one column, gutter-spaced Hint Caption — \"Raw stored values in native units — no unit conversion is applied here. The interface-form nodes edit the same backing table.\" System parameters Section Heading System Table — dense, flat, bordered Header Row — Id, Value, and an unlabelled action column Data Row — the prefixed id in bold over its usage caption (absent on a free extra), a numeric cell, and a delete button Axis parameters Section Heading Axis Table — dense, flat, bordered Header Row — Id, then one column per axis name, then an unlabelled action column Data Row — the prefixed id in bold over its usage caption, one numeric cell per axis column (blank where the row has no entry for that axis), and a delete button that removes the whole id Axis parameters (integer) Section Heading Integer Axis Table — the same shape as the Axis Table, over the integer dictionary Separator Add Row — one line, bottom-aligned Section Select — System / Axis (double) / Axis (integer) Parameter id Numeric Field — minimum 0 Axis Text Field — present only while the section is not System Value (raw) Numeric Field Add / Set Button — primary No-Table Body — replaces everything above: \"No controller parameter table on the active runner.\" Shared Empty State — replaces the whole body while the snapshot reports no runner: \"No NC runner — load a project first.\" Remove Dialog — Remove parameter over Remove <prefixed id> from the <section> section?, with a cancel Toast — negative, three seconds, the panel's context followed by the server's own message The axis columns of the two per-axis tables are computed independently of each other, and each is the union of the shared snapshot's axis names with every axis key present in that table's own rows. An axis created here therefore gets its column from the rows even before the shared snapshot is next refreshed, and an axis the snapshot knows about with no entry in a row shows an empty cell rather than being omitted. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/SoftNcNativeParamsPanel.vue — this panel: the three tables over the three dictionaries, the prefixed id column with its usage caption, the axis-column union, the three commit handlers with the integer test that drops a fractional value, the confirm-then-remove flow, and the add footer with its truncation and its two refusals. wwwroot-src/src/components/controlTree/softNcItemTypes.ts — the node's id, label and label key, and the snapshot flag it is pushed behind, last on the machine plane. wwwroot-src/src/api/softNcRunner.ts — the reader that parses the prefix and the three row families, the three per-cell writers and the three per-id removals, and the snapshot field carrying a prefix this panel does not use. wwwroot-src/src/composables/useSoftNcRunner.ts — the shared snapshot the first empty layer and the axis-column union read. wwwroot-src/src/components/widgets/NumericInput.vue — the cell: commit on blur or Enter, the parsed value written back into the box, and the absence of any integer rule. wwwroot-src/src/components/controlTree/SoftNcEmptyState.vue — the shared no-runner line. wwwroot-src/src/components/controlTree/SoftNcIndexingPositionsPanel.vue — the sibling that displays the MD30500 assignment this leaf writes, and points here for it. wwwroot-src/src/api/http.ts — the shared fetch helper that turns both a non-2xx status and a success: false body into one thrown error. wwwroot-src/src/i18n/en/softNc.ts — the node label, the raw-units hint, the three section headings, the three add-footer section options, the two footer refusals and the five error contexts — one read and four writes, the two per-axis savers sharing a context. wwwroot-src/src/i18n/en/common.ts — the shared Id, Value, Axis and Add / Set strings. wwwroot-src/src/i18n/en/dialog.ts — the remove dialog's title, its message, and the three storage kind words it interpolates. Mech/SoftNcRunnerController.cs — the REST surface: the read that orders each dictionary by id and attaches the brand's usage description to every row, the prefix computed from the resolved table's type, the three get-or-create writers and the three whole-row removals, the shared dependency wrapper that answers a missing table inside a success envelope, and the neighbouring readers this form's rows also feed — the three per-axis reads that take the axis-type row's key set bare, the tool-change read that falls back to its own configuration's keys when that set is empty, and the M-code read bound to the stored declaration map rather than the overlaid view. HiAPI Engine HiMech/NcParsers/Dependencys/ControllerParameterTableBase.cs — the three dictionaries this leaf is, the get-or-create bucket accessors, the role interfaces that let the domain-grouped leaves read the same rows, the axis-name set taken from the axis-type row, the three usage-description methods, the rotary-axis helper that writes type, reference position and rapid rate in one call, and the XML round-trip that persists every row including free extras. HiMech/NcParsers/Dependencys/Fanuc/FanucParameterTable.cs — the # vocabulary: the well-known numbers, the get-or-create defaults behind the modelled accessors, the macro-variable lookup over the work-offset address ranges, and the seed a fresh Fanuc or Mazak runner opens on. HiMech/NcParsers/Dependencys/Syntec/SyntecParameterTable.cs — the Pr vocabulary, and the peck clearance stored in microns with the conversion kept in its accessor. HiMech/NcParsers/Dependencys/Siemens/SiemensMachineDataTable.cs — the MD vocabulary: the indexing assignment, the three equidistant numbers this leaf alone edits and the spacing resolution that reads them, the tool-change mode, the tool-change M function with the read-time declaration overlay that never enters the stored map, the fixed-point position, and the seed that declares one system row. HiMech/NcParsers/Dependencys/Heidenhain/HeidenhainParameterTable.cs — the MP vocabulary and its two-row seed. HiMech/NcParsers/Dependencys/IsoCoordinateAddressMap.cs — the work-offset address scheme shared by the Fanuc and Syntec tables, the per-address description that captions those rows, and the seeding of every triad to zero. HiMech/NcParsers/Dependencys/IMachineAxisConfig.cs — the axis contract, and the axis-type enumeration a cell of the integer section stores. HiMech/NcParsers/Dependencys/Generic/ToolingMcConfig.cs — the tool-change pose, stored outside the three dictionaries, whose own X / Y / Z keys are what Tool-Change Position falls back to when the axis-type row is gone. HiMech/NcParsers/SoftNcRunner.cs — the five brand presets and which parameter-table proxy each carries, the Fanuc proxy inside the Mazak preset among them, the tool-change configuration every preset seeds, and the chain configuration that is the only other writer of the axis-type row and, on a rotary chain axis, of that axis' reference position and rapid rate. See Also Machine and Controller Plane — the plane this leaf sits on, and why the table it exposes is stored on the project rather than on the runner file Brand Matrix — the flag that grows this node, why it never reports false on a shipped preset, and why Mazak resolves the Fanuc table Editing Contract — the commit, rollback, confirm and toast rules this panel shares with the branch, and the add-footer details it differs on Interface Parameters — the same values in domain vocabulary, including the peck clearance this leaf shows in the brand's own unit Indexing Position Tables — the leaf that displays the MD30500 assignment and the equidistant definition that are written here"
  },
  "anatomy/general-setup/controller/machine/per-axis-tables.html": {
    "href": "anatomy/general-setup/controller/machine/per-axis-tables.html",
    "title": "Per-Axis Tables | HiAPI-C# 2025",
    "summary": "Per-Axis Tables Four leaves of the Controller branch's machine plane are one table each, keyed on the machine's axes: Machine Limits (Stroke), Rapid Feedrates, Home / G28 Reference and Tool-Change Position. They live on the General Setup page at /general-setup under the Control-Tree ids equipment/controller/machine/limits, equipment/controller/machine/rapid, equipment/controller/machine/home and equipment/controller/machine/tool-change; none of them is gated by a snapshot flag, so every brand grows all four. Two components serve them — one panel behind the first three, discriminating on the id's last segment, and a second behind Tool-Change Position — and the differences between those two components are what this page is mostly about. Important Anatomy makes no claim that any id named here is stable across versions. The migration hop that keeps an older ?tree= value resolving is described in Tree Ids and Routes. Where the Rows Come From Every row on all four leaves is one axis of the runner's machine-axis configuration, read as AxisNames through the proxy-resolved dependency list. On all five brand presets that configuration is the brand parameter table itself: ControllerParameterTableBase declares IMachineAxisConfig alongside IStrokeLimitConfig, IRapidFeedrateConfig and IHomeMcConfig, so one object supplies both the row set and three of the four value sets. Which brand carries which table is Brand Matrix. The table's axis set is a single parameter row: the per-axis integer bucket under the brand's axis-type number, whose keys are the axis names and whose values are the AxisType — linear, rotary or spindle. Adding an axis therefore means adding a key to that one row, and exactly one surface on this branch reaches it. Neither panel here has an add-row or delete-row control. Both render a fixed header over one <tr> per axis and nothing else. The four per-axis routes behind them write one axis' value and nothing more: the caller names an axis, and the endpoint writes into the stroke-limit, rapid-rate, home or tool-change store under that name. None of them touches the axis-type row, so none of them changes which rows the next read returns. Parameters (Native) edits the axis-type row itself, and is the one place on the branch that widens the axis set: its Add / Set footer takes a free-text axis name, so the section Axis (integer), the brand's axis-type number, a name and a value of 0 linear, 1 rotary or 2 spindle adds an axis, which then appears on all four leaves. Its grid cannot — the per-axis columns are the union of the axis names already present, so a cell can be written only for an axis that exists — and its delete button removes a whole parameter row, every axis cell of one number at once, rather than one axis. Axes arrive from the machining chain. Whenever the active runner suit or the chain changes, the project service re-binds the suit and calls ConfigureByMachiningChain(API), which walks the chain's axis codes and their transformers: a rotating transformer writes the axis as rotary — and, on a brand parameter table, writes its reference position as 0 deg and its rapid rate as 36000 deg/min — any other transformer writes the axis as linear, and every chain axis whose reference position is still unset is seeded to 0. That is the mechanism behind the description above the Home / G28 Reference table, \"Axes without a value are seeded to 0 when a machine tool attaches.\" The stamp adds rows and never removes one. The generic axis configuration carried by the CSV and CL runner suits is cleared before the walk; a brand parameter table is not, and keeps every axis it already held. An axis dropped from the chain therefore keeps its rows on all four leaves, and no surface removes it individually. The three-axis default table every brand preset seeds is why a project with no machine tool attached still shows X, Y and Z. Two values are the exception, and only on a rotary chain axis of a brand table: that branch of the walk is unconditional, so it rewrites the axis' reference position to 0 deg and its rapid rate to 36000 deg/min whether or not one was stored. The walk re-runs on every suit re-bind, so an edited Home Position or Rapid Rate on a rotary axis is back at those two numbers once the chain or the active suit changes. A linear axis' values, and every value on an axis the chain does not carry, are left untouched. The caption below the first three tables records the row half of that: \"Axis rows follow the Machine Tool chain; they cannot be added here.\" Where the chain itself is edited is Machine Tool. The Value Columns Each leaf renders the axis column, its own value column or columns, and a unit column. Leaf Value columns Empty cell means Machine Limits (Stroke) + Limit, − Limit no limit set for that axis and side Rapid Feedrates Rapid Rate never empty — see below Home / G28 Reference Home Position no reference position stored Tool-Change Position Stays put, Position see Stays Put The stroke-limit and home readers return an optional value and hand null straight through, so an unset cell is blank. The rapid reader does not: it returns the stored rate, or — when the axis has no rate of its own — the base class's fixed default, 20000 mm/min for a linear axis and 36000 deg/min for a rotary one. So a Rapid Rate cell is always a number, and a number in it is not proof that the axis has a row. A table cloned fresh from a brand's preset seed decides what the three leaves then open on, and all four brand defaults agree in shape: a linear X, Y and Z, a reference position of 0 on each, and a rapid rate per axis — and no stroke limit at all. Machine Limits therefore opens entirely blank on every brand, while Rapid Feedrates and Home / G28 Reference open populated. Whether a brand switch clones a fresh table or keeps the project's own is Machine and Controller Plane. The Unit Column The unit column's header is the translated label Unit; its cell text is not translated and does not come from the server. Each panel computes it in the browser from the row's rotary flag, using literal strings: Leaf Linear axis Rotary axis Machine Limits (Stroke) mm deg Rapid Feedrates mm/min deg/min Home / G28 Reference mm deg Tool-Change Position mm deg The flag itself is server-side, and it is the axis type rather than a separate setting: an axis stored as rotary or as spindle reports rotary, so a spindle-mode axis is labelled in degrees. The unit is a label, not a conversion. The base class writes a linear and a rotary rapid rate into the same per-axis cell and reads them back through the same lookup, differing only in the default returned when the cell is absent; the stroke-limit and home accessors are equally unit-blind. Nothing on these three leaves converts, so their numbers are the raw stored numbers, and the same values appear in Parameters (Native) under the brand's own parameter number: Role Fanuc, Mazak Syntec Siemens Heidenhain Axis type — the row set 1006 1006 30300 400 Reference position (home) 1240 1240 34010 410 Positive stroke limit 1300 1300 36100 420 Negative stroke limit 1320 1320 36110 430 Rapid rate 1420 1420 32000 1010 Mazak shares the Fanuc column because the Mazak preset carries the Fanuc parameter-table proxy; Siemens spends its rapid-rate role on the max-axis-velocity machine datum. Tool-Change Position is the exception on both counts: its values live on ToolingMcConfig, a plain runner-owned dependency rather than a parameter table, so they appear in no native form at all and a brand apply returns them to the preset defaults — see Machine and Controller Plane. Stays Put, and the Sentinel Behind It IToolingMcConfig stores one number per axis, and the contract gives one number a second meaning: NaN means the axis stays where it is during a tool change. The read splits that back into two fields — a stored NaN becomes the Stays put flag with no position, anything else becomes the position — and the panel renders the flag as a checkbox and the position as a numeric field disabled while the box is ticked. Writing goes the same way round. Ticking the box sends the stay flag and the reader writes NaN. Unticking it sends a position, and because the panel clears its own cell when the box is ticked, the position it sends on the way back is 0 — so unticking parks the axis at machine zero rather than restoring what was there before. A third state exists and is not the sentinel: an axis with no entry in the map at all. Its box is unticked and its Position cell blank, because the reader reports no position and no stay. At run time the two are indistinguishable — the tool-change motion overlays only those axes that carry a number and are not NaN onto the current pose, and leaves every other axis alone. So the machine stays put either way; the tick mark distinguishes only how that was recorded. The overlay has a vocabulary of its own, narrower than the table. X, Y and Z always take part; every other axis takes part only while the machine declares it rotary. A linear axis outside those three is stored, shown and editable on this leaf, and never moved. The preset default is exactly this mixture: X and Y carry the sentinel, Z carries 0, and no rotary axis carries an entry, which is why a rotary axis usually opens unticked and blank. Above the table sits Tool-change mechanism time, a single field in seconds bound to ToolingTime. It becomes the duration of the tool change step the runner emits, and it is the changer mechanism alone — the axis travel to and from the position is timed separately from the positions in the table. It is 0 on every brand preset, and it is written into the runner file only when non-zero. One Reader, Two Readings of Its Presence Flag All four reads answer the same shape: a present flag plus one row per axis. present reports whether the backing configuration resolved — stroke limit, rapid feedrate, home or tool change — and it is computed independently of the rows. Each reader builds the row list from the axis set whether or not that configuration resolved, and fills the value cells from an optional reference, so a missing configuration yields blank limit and home cells, a 0 rapid rate, and rows all the same. The two components read the answer differently, and this is the sharpest divergence between them. The axis-table panel discards present entirely. Its typed reader parses the flag; the panel assigns only the rows. Its second empty layer keys on the row count instead: with no axes it shows \"No machine axes yet — these rows are driven by the Machine Tool chain (MechBuilder). Attach a machine tool to edit per-axis values.\", and with axes it renders the table whatever the flag said. The tool-change panel reads present and, when it is false, shows \"No tool-change config on the active runner.\" What that costs: a runner that has axes but no stroke-limit, rapid-feedrate or home configuration renders a full, editable table of blank or zero cells, and every commit fails with a toast naming the missing dependency instead of the panel saying the table is absent. On the five shipped brand presets the state cannot arise, because the one object that supplies the axis set supplies all three configurations too. The reachable case is the mirror one, and it reaches the two panels differently: deleting the axis-type parameter row from Parameters (Native) empties the axis set, and the three axis-table leaves fall to the no-axes line while Tool-Change Position keeps its rows, because its reader falls back to the tool-change configuration's own axis keys when the axis set is empty. Rows recovered that way are reported as linear whatever they are. The tool-change flag itself is never false on a shipped preset: all five carry the tool-change configuration as a plain entry, so its empty line is reachable only on a hand-built or file-loaded runner. Above both layers sits the shared no-runner guard every leaf of the branch carries; it, and the commit, rollback and toast rules the four leaves share with the rest of the branch, are Editing Contract. Editing a Cell Numeric cells are the shared numeric field, so a value commits on blur or on Enter and never per keystroke — its full contract is Numeric Input. The Stays put checkbox commits on the click. Three details govern how these four leaves commit: The writes are per cell, not per row. Editing + Limit sends that side alone, and the endpoint leaves a side it was not sent unchanged. The branch's row-shaped editors do not agree on this: a tool-offset or work-coordinate edit resends the whole row, while Parameters (Native) writes one axis cell at a time as these four do. Clearing a cell writes nothing. An emptied field parses to null and the handler returns before the request, so the box is left blank on screen while the stored number stands, and the number returns when the panel is remounted by selecting another node and coming back. There is consequently no way to unset a stroke limit or a reference position from these panels; the only surface that removes one is the native leaf's whole-row delete. No cell is bounded. None of the four tables passes a minimum or a maximum to its fields, so a negative limit or a negative rapid rate is accepted and stored. The mechanism time is the one bounded field on the four leaves, at zero or above. What the Values Do When a Program Plays The stroke limits are checked at each played step against the chain's current machine pose while the session's stroke-limit check is on; a position past a configured limit is reported as a stroke-limit validation error anchored to that step, and pauses the player when pause-on-failure is set. The check walks a fixed axis vocabulary — X, Y and Z from the machine point, A, B and C from its orientation — so a limit stored against any other axis name is kept and shown here but never tested. Rapid-traverse timing has the same shape and the same six names: a G00 move is timed axis-by-axis at each axis' rate and takes the slowest, falling back to the same 20000 mm/min and 36000 deg/min defaults when no configuration answers. The reference positions reach further, but only at the start. The initializer that sets the machine pose at the first block writes every declared axis, reading each axis' stored reference and falling back to 0 for one that has none. The G28 reference return reads the same store through a narrower window: X, Y and Z for its linear stage, and A, B or C for its rotary stage — and a rotary letter only while the machine declares that axis rotary and a reference position is stored for it, an unconfigured one being reported as a validation error instead. So an axis outside the six canonical names still carries its stored reference into the pose at the first block, while its stroke limit, its rapid rate and its G28 return are all inert. Layout General Setup Control Tree — the left dock of /general-setup Controller Node Row Machine / Controller Group Row Machine Limits (Stroke) Node Row — equipment/controller/machine/limits Rapid Feedrates Node Row — equipment/controller/machine/rapid Home / G28 Reference Node Row — equipment/controller/machine/home Tool-Change Position Node Row — equipment/controller/machine/tool-change Editor Row — the panel of whichever node is selected Machine Limits (Stroke) / Rapid Feedrates / Home / G28 Reference Panel — one component, its role taken from the selected id's last segment Description Caption — \"Machine travel limits per axis (empty = no limit set). Motions beyond a limit raise a stroke-limit validation error.\", \"G00 rapid traverse rate per axis.\" or \"G28 first reference (home) machine coordinate per axis. Axes without a value are seeded to 0 when a machine tool attaches.\" Axis Table — dense, flat, bordered Header Row — Axis, then + Limit and − Limit, or Rapid Rate, or Home Position, then Unit Axis Row, one per axis Axis Name Label — bold, not editable Value Numeric Field, one per value column Unit Label — mm / deg, or mm/min / deg/min on Rapid Feedrates Footer Caption — \"Axis rows follow the Machine Tool chain; they cannot be added here.\" No-Axes Block — replaces the description, the table and the footer caption when the axis set is empty: a precision-manufacturing icon beside \"No machine axes yet — these rows are driven by the Machine Tool chain (MechBuilder). Attach a machine tool to edit per-axis values.\" Tool-Change Position Panel Tool-change mechanism time Numeric Field — suffixed s, minimum 0 Axis Table — dense, flat, bordered Header Row — Axis, Stays put, Position, Unit Axis Row, one per axis Axis Name Label — bold, not editable Stays put CheckBox Position Numeric Field — disabled while Stays put is ticked Unit Label — mm / deg Footer Caption — “Stays put” leaves the axis where it is during a tool change. No-Config Block — replaces the field, the table and the caption: \"No tool-change config on the active runner.\" Shared Empty State — replaces either panel's whole body while the snapshot reports no runner: \"No NC runner — load a project first.\" Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/SoftNcAxisTablePanel.vue — the panel behind the first three leaves: the role taken from the node id's last segment, the value columns and description per role, the unit strings computed from the row's rotary flag, the row-count empty layer that discards the read's presence flag, and the per-cell commit that returns on a cleared field. wwwroot-src/src/components/controlTree/SoftNcToolChangePanel.vue — the tool-change panel: the mechanism-time field, the Stays put checkbox that clears the position and sends 0 on the way back, the disabled position cell, and the presence-flag empty layer. wwwroot-src/src/components/controlTree/SoftNcEmptyState.vue — the shared no-runner line both panels open with. wwwroot-src/src/components/widgets/NumericInput.vue — the numeric cell: commit on blur or Enter, and the empty-text-to-null parse the panels reject. wwwroot-src/src/components/controlTree/softNcItemTypes.ts — the four node ids, their labels and label keys, and the two item types that bind them to the two panels. wwwroot-src/src/api/softNcRunner.ts — the four readers and their setters: the row shapes, the presence flag both panels receive, the per-side stroke-limit payload, and the stay-or-position tool-change payload. wwwroot-src/src/composables/useSoftNcRunner.ts — the shared runner snapshot the first empty layer reads. wwwroot-src/src/i18n/en/softNc.ts — the four node labels, the three descriptions, the column headers, the two footer captions and the two empty-state lines quoted above. wwwroot-src/src/i18n/en/common.ts — the shared Axis and Unit column headers. wwwroot-src/src/components/controlTree/SoftNcNativeParamsPanel.vue — the neighbouring leaf that edits the same parameter rows by number: the per-cell axis writes, the grid columns unioned from the existing axis names, the delete that drops a whole row, and the Add / Set footer whose free-text axis field is what widens the axis-type row. Mech/SoftNcRunnerController.cs — the REST surface: the chain-driven axis helper every reader builds its rows from, the four readers with their independently computed presence flags, the four per-axis writers that name an axis but never declare one, the native per-axis-integer route that does, the tool-change fallback to the tool-change configuration's own axis keys, the NaN sentinel write, and the rotary lookup the rapid write re-derives server-side. HiAPI Engine HiMech/NcParsers/Dependencys/ControllerParameterTableBase.cs — the one object behind three of the four leaves: the axis set as the keys of the axis-type row, the reference-position, rapid-rate and stroke-limit accessors over the per-axis buckets, the fixed rapid defaults, and the rotary configuration helper the chain walk calls, which writes the axis type, the reference position and the rapid rate together with no guard on the two values. HiMech/NcParsers/Dependencys/IMachineAxisConfig.cs — the axis contract and the axis-type enum whose rotary and spindle members both make a row rotary. HiMech/NcParsers/Dependencys/IStrokeLimitConfig.cs — the limit accessors, and the check itself with its fixed X/Y/Z and A/B/C vocabulary and its validation report. HiMech/NcParsers/Dependencys/IRapidFeedrateConfig.cs — the linear and rotary rate accessors. HiMech/NcParsers/Dependencys/IHomeMcConfig.cs — the reference-position accessors. HiMech/NcParsers/Dependencys/IToolingMcConfig.cs — the tool-change contract: the NaN sentinel and the mechanism time. HiMech/NcParsers/Dependencys/Generic/ToolingMcConfig.cs — the sole implementation: the per-axis map, the preset default of X and Y staying and Z at 0, and the serialization that omits a zero mechanism time. HiMech/NcParsers/Dependencys/Fanuc/FanucParameterTable.cs, HiMech/NcParsers/Dependencys/Syntec/SyntecParameterTable.cs, HiMech/NcParsers/Dependencys/Siemens/SiemensMachineDataTable.cs, HiMech/NcParsers/Dependencys/Heidenhain/HeidenhainParameterTable.cs — the parameter numbers in the table above and the three-axis default each brand opens on. HiMech/NcParsers/Dependencys/Fanuc/FanucParameterTableProxy.cs, HiMech/NcParsers/Dependencys/Syntec/SyntecParameterTableProxy.cs, HiMech/NcParsers/Dependencys/Siemens/SiemensMachineDataTableProxy.cs, HiMech/NcParsers/Dependencys/Heidenhain/HeidenhainParameterTableProxy.cs — the placeholders the brand presets actually carry: each clones its three-axis seed into the project's own dependency list when that list holds none, and resolves to the project's table when it does. HiMech/NcParsers/SoftNcRunner.cs — the chain walk that stamps axis codes, hands a rotary axis to the unconditional rotary helper on a brand table, and fills a missing reference position; and the five brand presets that decide which parameter table and which tool-change configuration a brand carries. HiNc/MachiningProcs/LocalProjectService.cs — where the chain walk is triggered from, why the generic axis configuration is cleared first and a brand table is not, and the per-step stroke-limit check that reads the limits through the proxy-resolved list. HiMech/MachiningProcs/MachiningSession.cs — the play loop that runs that check once per step and pauses on failure. HiMech/NcParsers/Semantics/LinearMotionUtil.cs — rapid-traverse timing: per-axis rates, the slowest axis, and the same six axis names the stroke check uses. HiMech/NcParsers/Initializers/HomeMcInitializer.cs — the reference positions written for every declared axis at the first block. HiMech/NcParsers/LogicSyntaxs/ReferenceReturnSyntax.cs — the G28 return: the three linear names it resolves a final position for, the three rotary letters it tests against the declared axes, and the validation error a rotary letter the machine has not declared raises. HiMech/NcParsers/LogicSyntaxs/ToolChangeMotionSyntax.cs — the overlay: X, Y and Z plus the declared rotary axes, of which only the ones carrying a non-NaN position move. HiMech/NcParsers/Semantics/ToolChangeSemantic.cs — the tool-change step that carries the mechanism time as its duration. See Also Machine and Controller Plane — the plane these four leaves sit on, and which half of the project each of their values is stored in Brand Matrix — why all four are ungated, and which table each brand resolves them through Editing Contract — the fetch, commit, rollback and empty-layer rules these panels share with the rest of the branch, and where they are recorded as departing from them"
  },
  "anatomy/general-setup/controller/machine/program-reading.html": {
    "href": "anatomy/general-setup/controller/machine/program-reading.html",
    "title": "Program Reading | HiAPI-C# 2025",
    "summary": "Program Reading Program Reading is the pair of Machine / Controller leaves that change how the runner reads a program rather than how the machine moves: which block-skip layers are active, and where a subprogram call goes looking for its file. Both live on the General Setup page at /general-setup, under the Control-Tree ids equipment/controller/machine/block-skip and equipment/controller/machine/subprograms. The pair is also unevenly branded — every shipped brand preset carries the subprogram-folder config, and one of the five carries no block-skip config at all. Important Anatomy makes no claim that any id named here is stable across versions. The migration hop that keeps an older ?tree= value resolving is described in Tree Ids and Routes. The Asymmetry Both nodes are grown behind a plain presence probe over the runner's proxy-resolved dependency list: hasBlockSkip is set when the list holds any IBlockSkipConfig, hasSubprogramFolders when it holds a SubProgramFolderConfig. Neither probe inspects a value. Brand preset Block-skip config Subprogram-folder config Fanuc yes yes Siemens yes yes Syntec yes yes Mazak yes yes Heidenhain no yes GenericBlockSkipConfig is the only implementer of the block-skip interface anywhere in the engine, and the Heidenhain preset's pipeline list is the one of the five that does not carry it. That single omission is what makes Block Skip / Delete the one node in the whole Controller branch that exists on four brands and not the fifth; every other gate on this plane is satisfied either by all five presets or by a Siemens-only table. Which flag each row answers to is Brand Matrix. The config is not the only thing missing there. The block-skip switches gate a parsing syntax, BlockSkipSyntax, and that syntax appears in the Fanuc, Siemens, Syntec and Mazak syntax lists and in no other — the Heidenhain list carries no block-delete parser, so on that preset the nine switches would have nothing to gate. The subprogram-folder config runs the other way: all five presets carry one, and five call statements across three brand families read the same two values. The node's own vocabulary is Fanuc's, because the storage is, but the setting is not Fanuc-only. Block Skip / Delete The panel is a caption over nine checkboxes and nothing else. The caption reads \"Enabled layers skip their /n-prefixed blocks (/ alone = layer 1).\", the first box is labelled \"Layer 1 (bare /)\" and the rest “Layer 2” through “Layer 9”. What a layer does to a block BlockSkipSyntax matches a leading / optionally followed by a single digit 1–9; a bare slash is layer 1. It then always writes a BlockSkip section recording the symbol and the layer, and always consumes the prefix out of the block's unparsed text — so the / itself never survives as residue for the downstream unrecognized-text check, whatever the switches say. What the switch decides is the block's body: Layer on — the remaining text is moved into Body and the unparsed text is cleared. Every downstream parsing syntax then sees nothing, so the block emits no NC act, and the run records BlockSkip--Skipped at message severity for that block. Layer off, or no config at all — the body stays null and the rest of the block parses exactly as an unprefixed one would. A runner with no block-skip config therefore simulates the whole program, which is the safe reading of an unknown machine setting. Ordering matters for one thing and is fixed in each brand's list: the comment and NC-embedded script syntaxes run before the block-skip syntax, so a comment on a skipped block — and any script embedded in it — still takes effect while the motion beside it does not. One value, seven spellings of the same range Layers 1 through 9 are the whole range, and no shared constant carries it. The bound is written out separately in the parsing syntax's regular expression, in the config's XML reader and again in its CSV setter, in its per-layer mutator guard, in the read endpoint that enumerates the layers, in the write endpoint that loops over them, and in the panel's checkbox repeat. A tenth layer is therefore seven edits, not one, and a partial change would be silent — a switch the panel offered but the config refused to store would simply never take. What a fully cleared set does not survive A freshly applied preset has layer 1 on and the other eight off. The stored form is a comma-separated list of the enabled layers, and an empty set serializes as an empty element. The reader treats a blank list and a missing element identically — both mean layer 1 only — so clearing every box and then reloading the project brings layer 1 back on. Every other combination round-trips exactly. The write Each box commits on the click, and the request is the whole enabled set rather than the one layer that changed: the panel sorts its set and sends it, and the endpoint walks 1 through 9 setting each layer to whether the payload names it. A failed write restores the previous set and raises a toast; the shared rules behind that shape are Editing Contract. On the brand that carries no config, the read answers not present with an empty layer list and any write is answered unsuccessfully with “No IBlockSkipConfig on the active runner” — but the node is not built there, so neither answer is reachable from the tree. Subprogram Folders Two plain text fields, labelled \"Internal folder (M98)\" and \"External folder (M198)\", hinted “Relative to the host NC file's folder; empty = that folder itself” and “Fanuc external-storage calls; empty = fall back to the internal folder”. They write InternalFolder and ExternalFolder; an empty or whitespace-only box is stored as null rather than as an empty string. Which call statements read these two values Preset Call statement Field it reads File-name chain, first match wins Fanuc, Mazak, Syntec M98 P_ L_ Internal O{P:D4}.NC, O{P}.NC, O{P:D4}, O{P}, {P:D4}.NC, {P}.NC Fanuc, Mazak, Syntec M198 P_ External, falling back to Internal when it is null the same chain Fanuc G65 / G66 macro call Internal the same chain Siemens name call (L9810, a named cycle) Internal {name}.SPF, {name}.MPF, {name} Heidenhain CALL PGM name Internal {name}.h, {name}.H, {name} Two consequences follow from the table, and both are invisible from the field labels. The External folder is inert on two brands. Only the Fanuc-family inliner, SubProgramCallSyntax, ever reads it — the Siemens and Heidenhain call syntaxes look up their callee through the Internal folder alone. The field is offered on every brand because the storage is brand-neutral, and it is honoured on the three that have an M198. The Internal folder is read by more than the M98 label says. On the Fanuc preset it also anchors both Custom Macro B lookups — FanucMacroCallSyntax for the G65 one-shot call and FanucModalMacroSyntax for the G66 modal — and on Siemens and Heidenhain it is the only subprogram root there is. Emptying it to fix an M98 path therefore moves the macro and named-call lookups with it. Each brand also brings its own file-name chain, and the chains are per-syntax properties rather than one shared list — the Fanuc chain is FilenamePatterns, a static array every Fanuc-family caller shares, while FilePatterns and FilePatterns are instance properties of their own call syntaxes and are re-writable from the runner file. Case matching is delegated to the host file system throughout, which is why the Heidenhain chain carries both .h and .H. Where a relative folder is anchored The resolver takes the folder as written. An absolute path is used unchanged. A relative path — and an empty one, which means the root itself — is combined with the base directory supplied by ProjectFolderDependency, and the machining session wires that dependency to the project's own root before each play. So the anchor is the project folder, not the folder the host NC file happens to sit in. A program played from a subfolder of the project resolves NC against the project root, not against its own neighbour of that name. The field's hint says otherwise, and so does the API summary on the two config properties the panel writes; the resolver is what runs. Two further conditions end the lookup before any pattern is tried: a relative folder with no base directory resolves to nothing, and so does a folder that does not exist as a directory. A missing file is an error on one family and a warning on the other The same empty result is reported at two different severities, and the split follows the call statement rather than the setting. Fanuc, Mazak, Syntec — an unresolved M98 / M198 raises SubProgramCall--FileNotFound at error severity, quoting the folder that was searched, and the call is consumed. Siemens, Heidenhain — an unresolved call raises SiemensCall--Skipped or HeidenhainCall--Skipped at warning severity and is consumed with no motion effect. That is deliberate: the common unresolved callee on those controls is an OEM or measuring cycle whose definition file ships with the machine and never travels with the program, so a hard error would fire on ordinary, correct programs. A resolved call is inlined: the callee is segmented through the runner's own segmenter and its blocks are prepended into the program ahead of the host block, each stamped with a record naming the call it came from. M98 with an L count above one inlines the same file that many times in series, each repetition its own segmentation pass. The nesting ceiling, and where there is none A self- or mutually-recursive callee re-captures its own call statement inside every inlined body, so a call path needs a rail of its own — no loop watchdog covers it. That rail is declared twice, independently, and is missing on the third path. Preset Ceiling Where it is declared Exceeded Siemens 32 frames DefaultMaxCallDepth SiemensCall--DepthLimitExceeded, consumed as a safe skip Heidenhain 32 frames DefaultMaxCallDepth HeidenhainCall--DepthLimitExceeded, consumed as a safe skip Fanuc, Mazak, Syntec none — — The two constants are separate const int declarations on separate classes that happen to hold the same number, each surfaced as its own writable MaxCallDepth property and each serialized into the runner file as its own element. Raising one raises nothing else. Both compare against the depth of the call stack already stamped on the host block, so the count is frames entered, not files listed. On the Fanuc-family inliner and on both Custom Macro B calls there is no depth comparison at all. None of them reads the host block's frame count before inlining, so none carries the recursion rail the Siemens and Heidenhain syntaxes declare. The depth itself is recorded either way — every inlined block is stamped with a pushed call-stack frame that the matching return statement pops — so what is missing is the comparison, not the count. The Heidenhain call syntax carries a second, unrelated ceiling for its section-repeat form: MaxRepetitions caps a REP literal at 65534, since the repeat re-scans the file once per repetition. What an empty Internal folder does not survive The config's default internal folder is NC — the layout where the main program sits beside an NC/ directory of subprograms — and that default is applied by the property itself, before the XML reader runs. The writer omits an element for a null folder, and the reader keeps whatever the property already holds when the element is absent. Clearing the Internal folder box therefore stores a null, writes no element, and reads back as NC the next time the project is opened. The External folder box has no such default and round-trips cleanly: cleared, it stores null, writes no element, and reads back null — which is the state the field's own hint describes, falling back to the internal folder. Editing and Storage Both panels open with the branch's two empty layers — the shared \"No NC runner — load a project first.\" line first, then the panel's own read reporting \"No block-skip config on the active runner.\" or \"No subprogram-folder config on the active runner.\" The first layer is a live guard against the snapshot emptying under a panel that is already mounted, which is what closing the project does. The second is unreachable by navigating: the node's gate and the panel's read probe the same dependency on the same resolved list, so the leaf exists only where the read is about to succeed. Their commit shapes differ, and both are recorded in Editing Contract: the block-skip boxes commit on the click and roll back on failure, while the two folder fields commit as a pair on blur or Enter of either one, compared against a saved snapshot of both rather than a per-field captured value — so editing one folder writes both, and a failure restores both. Both configs are plain runner-owned entries rather than proxies, so their values serialize with the runner and follow it. Installing a controller file replaces them outright, and a brand apply assigns a whole fresh preset, so an applied brand change returns both to that preset's defaults — layer 1 alone, and the NC internal folder with no external one. Selecting the brand already in force is not a route to that reset: the apply stays disabled until the selection differs from the runner's own brand. Which half of a project each value on this plane lands in is Machine and Controller Plane. Layout General Setup Control Tree — the left dock of /general-setup Controller Node Row Machine / Controller Group Row Block Skip / Delete Node Row — equipment/controller/machine/block-skip, grown while the snapshot reports a block-skip config Subprogram Folders Node Row — equipment/controller/machine/subprograms, grown while it reports a subprogram-folder config Editor Row — Block Skip / Delete Panel No-Runner Line — \"No NC runner — load a project first.\", the branch's shared empty state No-Config Line — \"No block-skip config on the active runner.\" Description Caption — \"Enabled layers skip their /n-prefixed blocks (/ alone = layer 1).\" Layer CheckBox Column — nine dense boxes in one column Layer 1 (bare /) CheckBox Layer 2 … Layer 9 CheckBoxes Editor Row — Subprogram Folders Panel No-Runner Line — the same shared empty state No-Config Line — \"No subprogram-folder config on the active runner.\" Internal folder (M98) Field — outlined and dense, hinted “Relative to the host NC file's folder; empty = that folder itself” — a hint the resolver contradicts, the anchor being the project root External folder (M198) Field — outlined and dense, hinted “Fanuc external-storage calls; empty = fall back to the internal folder” Every label above is a translated role string rather than a type name, so a locale change rewrites what is read without touching an id. Both panels mount against one node and take nothing from it: each serves a single tree id, so neither reads a role off the node's path. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/SoftNcBlockSkipPanel.vue — the block-skip panel: the two empty layers, the caption with its two code slots, the nine boxes and their layer-one label, and the whole-set write with its rollback. wwwroot-src/src/components/controlTree/SoftNcSubprogramPanel.vue — the folder panel: the two outlined fields, the blur and Enter bindings on both, the saved-snapshot guard that skips a redundant write, and the paired rollback. wwwroot-src/src/components/controlTree/SoftNcEmptyState.vue — the shared no-runner line both panels open with. wwwroot-src/src/components/controlTree/softNcItemTypes.ts — the two node ids, their labels and label keys, the snapshot flag each is pushed behind, and the item types that bind them to their panels. wwwroot-src/src/api/softNcRunner.ts — the two readers and their coercions, the layer-array writer, the paired folder writer, and the snapshot fields the gates read. wwwroot-src/src/api/http.ts — the envelope reader that turns an unsuccessful body into the error a panel's toast quotes. wwwroot-src/src/composables/useSoftNcRunner.ts — the shared snapshot both first empty layers read, and its once-per-session install. wwwroot-src/src/i18n/en/softNc.ts — the two node labels, the block-skip caption and layer labels, the four folder strings, the two empty-state lines and the error contexts. Mech/SoftNcRunnerController.cs — the REST surface: the two presence probes on the snapshot, the block-skip read that enumerates the nine layers and the write that sets each one, the folder read that substitutes an empty string for a null and the write that substitutes a null for a blank, the brand switch whose remark names both of these among the runner-owned values it resets, and the shared helper that answers a missing dependency with an unsuccessful body rather than an error status. HiAPI Engine HiMech/NcParsers/Dependencys/IBlockSkipConfig.cs — the block-skip contract: the per-layer query and mutator, and the stated safe default when the dependency is absent. HiMech/NcParsers/Dependencys/Generic/GenericBlockSkipConfig.cs — the only implementer: the layer-one default, the comma-separated stored form, the range filter repeated in its reader and its setter, and the blank-equals-absent rule behind the cleared-set round trip. HiMech/NcParsers/ParsingSyntaxs/BlockSkipSyntax.cs — the prefix parser: the layer regular expression, the always-recorded section, the body move that silences a block, and the message the skip reports. HiMech/NcParsers/Keywords/BlockSkip.cs — the recorded section: symbol, layer, and the body that is null exactly when the skip did not take effect. HiMech/NcParsers/Dependencys/Generic/SubProgramFolderConfig.cs — the two folders, the NC default applied by the property itself, the null fallbacks, and the writer that omits an element for a null. HiMech/NcParsers/EvaluationSyntaxs/SubProgramCallSyntax.cs — the Fanuc-family inliner: the internal-versus-external choice, the repetition loop, the file-not-found error, and the absence of any call-depth comparison. HiMech/NcParsers/EvaluationSyntaxs/MacroFileResolver.cs — the shared resolver: the Fanuc file name chain, the absolute-versus-relative anchoring, and the directory-exists precondition. HiMech/NcParsers/EvaluationSyntaxs/Fanuc/FanucMacroCallSyntax.cs, HiMech/NcParsers/EvaluationSyntaxs/Fanuc/FanucModalMacroSyntax.cs — the other two Fanuc readers of the internal folder: the G65 one-shot macro call, and the G66 modal that resolves the same file again on every motion block it fires on. HiMech/NcParsers/EvaluationSyntaxs/Siemens/SiemensSubProgramCallSyntax.cs — the name-call inliner: its own file-pattern chain, its own depth constant and property, and the safe-skip that answers an unresolved OEM cycle. HiMech/NcParsers/EvaluationSyntaxs/Heidenhain/HeidenhainSubProgramCallSyntax.cs — the klartext call inliner: the CALL PGM lookup through the same internal folder, the second depth constant, and the separate repeat ceiling. HiMech/NcParsers/Keywords/CallStack.cs, HiMech/NcParsers/EvaluationSyntaxs/SubProgramReturnSyntax.cs — the frame each inliner stamps on an inlined block, and the M99 return that pops it. HiMech/NcParsers/NcDiagnosticProgress.cs — the category and severity behind each diagnostic id named above. HiMech/NcParsers/Dependencys/SystemWired/ProjectFolderDependency.cs — the base directory a relative folder is anchored against, and the host-wired provider behind it. HiMech/MachiningProcs/MachiningSession.cs — where that provider is wired to the project root before a play. HiMech/NcParsers/SoftNcRunner.cs — the five brand presets, and which of them carries each of these two dependencies. HiMech/NcParsers/Syntaxs/FanucSyntaxUtil.cs, HiMech/NcParsers/Syntaxs/SiemensSyntaxUtil.cs, HiMech/NcParsers/Syntaxs/SyntecSyntaxUtil.cs, HiMech/NcParsers/Syntaxs/MazakSyntaxUtil.cs, HiMech/NcParsers/Syntaxs/HeidenhainSyntaxUtil.cs — the four lists that carry the block-skip parser and the one that does not, and which call syntax each preset runs. See Also Machine and Controller Plane — the plane these two leaves sit on, and the storage split that decides which of its values a brand apply resets and which it leaves alone Brand Matrix — the two flags that grow these nodes, what each one probes, and the brand sets they produce Editing Contract — the commit, rollback and empty-state rules these panels share with the branch, and the paired-field write recorded as one of its exceptions"
  },
  "anatomy/general-setup/controller/program-data/datum-tables.html": {
    "href": "anatomy/general-setup/controller/program-data/datum-tables.html",
    "title": "Datum Tables | HiAPI-C# 2025",
    "summary": "Datum Tables Datum Tables is the pair of Heidenhain per-case ledgers the Controller branch grows together: the preset rows a CYCL DEF 247 cycle selects, and the datum shift rows a CYCL DEF 7 cycle adds on top of the selected preset. Both live on the General Setup page at /general-setup under the Control-Tree ids equipment/controller/program-data/datum-presets and equipment/controller/program-data/datum-shifts — reached as ?tree=equipment/controller/program-data/datum-presets and ?tree=equipment/controller/program-data/datum-shifts — and the tree labels them Datum Presets (Q339) and Datum Shifts (D). One snapshot flag grows the pair, one component serves both nodes, and one of the two tables is also the object the Work Coordinates leaf edits. Important Anatomy makes no claim that any id named here is stable across versions. The migration hop that keeps an older ?tree= value resolving is described in Tree Ids and Routes. Two Nodes, One Component The branch builder pushes both nodes inside a single test on the snapshot's datum flag, so the two rows appear and disappear as a pair and never one without the other. That flag probes HeidenhainDatumTable over the runner's proxy-resolved dependency list, and only the Heidenhain preset carries it — which brand grows which leaf is Brand Matrix. Both nodes carry the same item type, so the editor row mounts the same component for either selection. The component takes its role from the last segment of the node id it is given: an id ending in datum-shifts makes it the shift editor, and anything else makes it the preset editor. The test is a suffix match with a preset default rather than an equality check over two known ids, so the preset role is what an unrecognised id falls to. Four things follow from that role, and nothing else in the panel differs between the two nodes. Decided by the role Datum Presets (Q339) Datum Shifts (D) Which array of the one read is rendered the preset rows the shift rows The index column's header Q339 D The description caption above the table \"Datum presets (CYCL DEF 247, Q339 = row). Rows 1–6 double as G54–G59.\" \"Datum shifts (CYCL DEF 7).\" The route segment its writes address preset shift One request serves both nodes. The read returns a presence flag together with both arrays, and the panel keeps one and discards the other. Selecting the sibling node changes the node id, which changes the editor row's remount key, so the component remounts and re-fetches the same payload for the other half. Reading the pair therefore costs two identical requests, and neither node can show a value the other's request had already returned. The preset and shift segments are the only two the panel ever sends; the endpoint's rejection of a third is one of the departures recorded in Editing Contract. What Each Table Holds Both tables are the same shape — an integer row number against an X / Y / Z translation — and both are seeded with rows 1 through 20 at zero when the table is constructed. What separates them is which klartext cycle reads which, and how the value is applied. Datum Presets (Q339) is the preset store. CYCL DEF 247 DATUM SETTING with Q339=N selects row N, and its translation becomes the block's active coordinate offset. The same parser claims the DIN/ISO spelling G247 Q339=+N and stamps the identical cycle record, so both dialects reach one store. Datum Shifts (D) is the shift store. CYCL DEF 7 with a #N row index reads row N, and the translation composes on top of the active preset rather than replacing it — the two land in separate entries of the block's transform chain. CYCL DEF 7 written with direct X / Y / Z values instead of a # index reads no table row at all. The two stores sit on one dependency and are two dictionaries of it, which is why one flag grows two nodes and one request answers for both. Neither store is a parameter table. HeidenhainDatumTable does not derive from the controller parameter base every brand's machine settings hang off, and the Heidenhain preset carries it as an entry of its own beside the machine-parameter entry. So no datum row has a native parameter number, and none of these values appears in Native Parameters — unlike the Fanuc and Syntec work coordinates, which are parameter addresses and do. Where the table is stored The Heidenhain preset does not carry a datum table. It carries HeidenhainDatumTableProxy, a get-or-create placeholder that installs a bare new table into the project's per-case list when that list holds none of the type, and resolves to the project's own table when it does. The proxy holds no seed and serializes as an empty element, so a controller file saved from the branch root carries none of these values, and installing a Heidenhain runner file over a Heidenhain project leaves the rows already edited exactly where they are. The plane's storage model in full is Program Data Plane. The Columns and the Axis Set Each leaf renders one dense markup table: the row-number column, three value columns, and an unlabelled action column. The row-number cell is bold plain text and cannot be edited. Its header is the role's literal — Q339 or D. The three value headers read X (mm), Y (mm) and Z (mm). Those three and the index literal beside them are hard-coded rather than translated, so they read the same under any locale, while the description caption, both empty bodies and the action button's tooltip are translated. The action column has no header text and holds one button per row. The axis set is fixed at three and does not follow the machine. A datum row is a three-component translation on both sides of the wire, so the columns are X, Y and Z whatever the machining chain declares — a fourth or rotary axis has no column here and no stored datum component. That is the opposite of the branch's Per-Axis Tables, whose rows are the chain's own axis names. The mm in the header is a label: nothing on the path from the stored translation to the cell converts anything. Rows are whatever the read returned, in row-number order. A table built by the proxy opens with twenty rows of zeros in each node; a table deserialized from a project file carries the rows that file holds. Editing a Row Every value cell is the shared numeric field, so it commits on blur or on Enter and never per keystroke; its parsing, its bounds behaviour and the second commit that follows Enter are Numeric Input. No cell here passes a minimum or a maximum, so a negative offset is accepted and stored. The write is the whole row. A commit assigns the new number into the local row and then sends that row's three components as they stand to the row's number; a failure restores the one component the handler captured and raises the branch's standard toast, though the request carried all three. That shape, the toast it ends in and what a failed write leaves behind are Editing Contract. A cleared cell parses to null, and Infinity or NaN parse to a non-finite number; the handler returns before the request in every one of those cases. Nothing is written and nothing is restored, so the cell is left blank — or showing the literal Infinity — while the stored number stands unchanged, until the panel is remounted by selecting another node and coming back. The action button is labelled with the single character 0 and carries the tooltip “Reset to zero”. It writes zeros into all three components of that row through a route of its own rather than through the row setter, and it is not a delete: the row stays, at zero. It is also the one write on these two leaves that is not optimistic — the request resolves first, and only then are the three local cells set to zero. No confirmation guards it. Neither leaf has an add control, a delete control, a draft or a save button, and the component declares no events at all, so no edit made here rebuilds the branch or marks anything dirty. The Preset Table Is Also the Work-Coordinate Table This is the pairing with Work Coordinates, and it holds for exactly one of the two tables. HeidenhainDatumTable implements IIsoCoordinateConfig, and the work-coordinate endpoint reads and writes through the first implementer of that interface in the runner's proxy-resolved list. On the Heidenhain preset the datum proxy is the second entry of the dependency list, immediately after the brand marker, and no other entry that preset carries implements the interface — the Heidenhain machine-parameter table does not. So on Heidenhain the object behind Work Coordinates is this datum table, and the snapshot's coordinate-kind field reports the Heidenhain arm for that same reason. The alias is narrow, and one-directional in coverage. Datum Presets (Q339) aliases. The ISO face maps G54 through G59 onto preset rows 1 through 6, in order, on both the read and the write, and enumerates no id outside that series — one for each of those six rows the table holds, which is all six unless a stored project table omits one of them. Editing the Q339 row 3 cells changes what Work Coordinates shows for G56, and an edit made on G56 changes row 3 — one instance, one cell, two faces. The row-zeroing button reaches the same cells. Datum Shifts (D) does not alias. Nothing on the ISO face touches the shift store: the id enumeration reads the preset dictionary only, and both the offset getter and the offset setter resolve to preset rows. The shift table has exactly one editing surface, the leaf on this page. Preset rows 7 through 20 have no work-coordinate face either. The ISO face reserves six rows for the G54 series and enumerates no id past G59, so fourteen preset rows and all twenty shift rows are reachable from this page and from nowhere else on the branch. The two faces are never on screen together — the editor row mounts one panel at a time — and each panel reads once on mount, so moving the selection between the two nodes is itself the refresh. What a mounted panel therefore does not see is Editing Contract. What a brand switch does to the pair The brand switch's carry option reads the outgoing runner's coordinate provider and writes the values into the incoming one, for the ids the incoming provider enumerates. On this table that means at most six values, landing in preset rows 1 through 6; a switch away from Heidenhain reads those same six rows out. No shift row is ever carried, and neither are preset rows 7 through 20. A switch away from Heidenhain then sweeps the datum table itself, because no other brand preset proxies it — both stores go, and switching back materializes a fresh table of zeros rather than restoring them. The staged select, its confirmation and the rest of that operation are Brand Switch. What the Rows Feed At run time both stores are read and neither is written. No syntax in the parse pipeline writes either dictionary — every writer is one of the four surfaces named below — so playing a program cannot change a datum row. The preset path. A CYCL DEF 247 block resolves its Q339 number — a literal, or the number a Q-expression evaluated to — looks the row up, and writes a synthetic coordinate id naming that row alongside the translation. The shared ISO coordinate syntax then keeps the offset alive on following blocks by re-resolving that synthetic id against the same table, which is how a mid-program edit to a row takes effect on the blocks after the declaration. A CYCL DEF 247 whose Q339 is not a number resolves nothing, leaves the active datum unchanged, and reports the validation warning \"CYCL DEF 247 without a literal Q339 preset number; the active datum is kept unchanged.\" A successful preset selection clears the active shift. That is the one path in the cycle handler that does not carry the previous block's shift forward. The shift path. A CYCL DEF 7 block carrying a # index reads that shift row and composes it as a second, separate transform entry, so preset and shift add rather than replace. On blocks with no cycle the shift is carried modally, and a numbered shift re-resolves from the table on every block, exactly as the preset does. A CYCL DEF 7 written with direct values carries them forward verbatim instead and needs no datum table at all; cancelling is a zero shift. A CYCL DEF 7 carrying neither form reports \"CYCL DEF 7 carries neither a #-table index nor direct X/Y/Z values; the active datum shift is kept unchanged.\" A G54 with axis words is not a table read. On the Heidenhain syntax list the datum-shift parser claims a G54 that is followed by at least one axis value and routes it into the direct-shift flow, which reads no row; a bare G54 is left alone and reaches the ISO path, where it resolves preset row So G54 means a table lookup or a literal shift depending on what follows it in the block. A row number that resolves to nothing yields a zero translation rather than an error, on both paths. And nothing is active at the first block: the Heidenhain preset's initializer seeds no coordinate section at all, unlike the Fanuc family's G54 and the Siemens cancel frame, so a program that issues no datum cycle and no G54 machines with no offset applied. Where Non-Zero Rows Come From Four surfaces put a value into these tables, and only the first is on this page. The two leaves themselves, per cell or per row. Work Coordinates, for preset rows 1 through 6 only, through the alias above. A brand switch onto Heidenhain with its carry option on, through that same ISO face and into the table the incoming preset resolves: at most six offsets, into preset rows 1 through 6 — Brand Switch. A project-load migration. Opening a project file that carries the superseded controller environment element and no per-case list populates the materialized per-case tables from that element, and the datum half runs only when the legacy brand element reads Heidenhain. It copies preset entries and shift entries by row number, overwriting a row it names and leaving every other row as seeded. The legacy work-coordinate table is replayed first, through the same ISO face that aliases onto preset rows 1 through 6, so where the two overlap the explicit datum copy is what stands. The superseded /controller route also carries datum preset and datum shift surfaces, over the separate environment model rather than over the runner — an edit made there does not reach the table on this page. That route's own anatomy is Legacy Controller Page. Layout General Setup Control Tree — the left dock of /general-setup Controller Node Row Program Data Group Row — equipment/controller/program-data Datum Presets (Q339) Node Row — equipment/controller/program-data/datum-presets Datum Shifts (D) Node Row — equipment/controller/program-data/datum-shifts Editor Row — the panel of whichever node is selected, one at a time Datum Presets (Q339) / Datum Shifts (D) Panel — one component, its role taken from the selected id's last segment No-Runner Body — \"No NC runner — load a project first.\"; the shared empty state, shown instead of everything below while the snapshot reports no runner Absent-Table Body — \"No Heidenhain datum table on the active runner.\"; shown instead of everything below while the panel's own read reports no table Description Caption — grey, one line: \"Datum presets (CYCL DEF 247, Q339 = row). Rows 1–6 double as G54–G59.\" or \"Datum shifts (CYCL DEF 7).\" Datum Table — dense, flat, bordered; no sort, no pagination, no column menu Header Row — Q339 or D, then X (mm), Y (mm) and Z (mm), then an unlabelled action column Datum Row, one per row the read returned, in row-number order Row Number Label — bold plain text, never editable Value Numeric Field, one per axis column — no minimum, no maximum, no unit suffix 0 Button — flat, dense, centred, tooltip “Reset to zero” Toast — negative, three seconds, the panel's context followed by the server's own message The panel carries no heading, no toolbar, no add row, no delete button, no toggle, no save button and no dialog. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/SoftNcDatumTablePanel.vue — the one component behind both leaves: the role taken from the node id's suffix with its preset default, the four things that role decides, the literal column headers, the whole-row cell commit with its non-finite guard, and the non-optimistic row reset. wwwroot-src/src/components/controlTree/softNcItemTypes.ts — the branch builder: the two node ids and label keys pushed together inside one flag test, and the single item type both carry. wwwroot-src/src/components/controlTree/PrimarySlavePanel.vue — the editor row: the remount key that makes a move between the two nodes a re-fetch, and the events this panel declares none of. wwwroot-src/src/components/controlTree/SoftNcEmptyState.vue — the shared no-runner line the panel opens with. wwwroot-src/src/components/widgets/NumericInput.vue — the value cell: commit on blur or Enter, the empty-text-to-null parse, and the infinity and NaN literals the panel's handler then rejects. wwwroot-src/src/api/softNcRunner.ts — the read that returns both tables and its row shape, the two role values, the per-row setter and the reset call, and the snapshot's datum flag. wwwroot-src/src/composables/useSoftNcRunner.ts — the shared snapshot the first empty layer reads. wwwroot-src/src/api/http.ts — the envelope helper that turns a success-flagged failure body into a thrown error. wwwroot-src/src/components/controlTree/SoftNcWorkCoordinatesPanel.vue — the second face on the preset rows: the same six cells addressed by coordinate id, and the caption that names the mapping. wwwroot-src/src/i18n/en/softNc.ts — the two node labels, the two descriptions, the absent-table body and the three error contexts. wwwroot-src/src/i18n/en/common.ts — the reset button's tooltip. Mech/SoftNcRunnerController.cs — the REST surface: the datum flag's probe in the snapshot builder, the read that returns both dictionaries ordered by row number, the per-row writer and the zeroing route behind one shared table-segment guard, the work-coordinate routes that reach the same object through the ISO interface, and the brand switch's capture-swap-carry-sweep. HiAPI Engine HiMech/NcParsers/Dependencys/Heidenhain/HeidenhainDatumTable.cs — the two dictionaries, their twenty seeded rows, the accessors both cycles read through, and the ISO face: the G54–G59 map onto preset rows 1–6, the synthetic preset ids it also resolves, and the id enumeration that stops at six. HiMech/NcParsers/Dependencys/Heidenhain/HeidenhainDatumTableProxy.cs — the seedless get-or-create placeholder the preset carries, and the bare table it installs into a project holding none. HiMech/NcParsers/Dependencys/IIsoCoordinateConfig.cs — the offset-provider contract whose first implementer the work-coordinate face resolves. HiMech/NcParsers/Dependencys/Heidenhain/HeidenhainParameterTable.cs — the other Heidenhain per-case table: it derives from the controller parameter base, which declares no coordinate contract, which is why the datum table is the preset's only implementer of one. HiMech/NcParsers/SoftNcRunner.cs — the Heidenhain preset's dependency list and the position of the datum proxy in it, the proxy resolution every read goes through, and the legacy per-case populate that fills both dictionaries by row number after replaying the legacy coordinate table. HiMech/NcParsers/ParsingSyntaxs/Heidenhain/CyclDefSyntaxs/HeidenhainDatumSettingSyntax.cs — the CYCL DEF 247 parser and the DIN/ISO G247 spelling it claims for the same cycle record. HiMech/NcParsers/ParsingSyntaxs/Heidenhain/CyclDefSyntaxs/HeidenhainDatumShiftSyntax.cs — the CYCL DEF 7 parser: the # row index, the direct-value form, and the axis-word test that decides whether a G54 becomes a direct shift or stays on the ISO path. HiMech/NcParsers/LogicSyntaxs/Heidenhain/HeidenhainCoordinateOffsetSyntax.cs — the resolver: the preset lookup and its synthetic id, the additive shift in its own transform entry, the modal carry that re-resolves a numbered shift from the table, the shift reset a successful preset selection performs, and the two validation warnings. HiMech/NcParsers/LogicSyntaxs/IsoCoordinateOffsetSyntax.cs — the G54-series path and the modal lookback that re-queries the table for the carried id. HiMech/NcParsers/LogicSyntaxs/CoordinateOffsetUtil.cs — the offset resolution and the translation composed onto the block's transform chain. HiMech/NcParsers/Syntaxs/HeidenhainSyntaxUtil.cs — the Heidenhain syntax list carrying both the ISO coordinate syntax and the datum-cycle syntax. HiMech/NcParsers/Initializers/StaticInitializer.cs — the Heidenhain initializer that seeds no coordinate section, against the Fanuc and Siemens ones that do. HiGeom/Geom/Vec3d.cs — the three-component translation a datum row stores, and the zero it defaults to. HiNc/MachiningProcs/MachiningProject.cs — the load path that wires the proxies and then runs the legacy per-case populate on a project carrying no per-case list. See Also Program Data Plane — the plane these two leaves sit on, where their table is stored, and the per-case tables beside them a brand switch keeps or sweeps Work Coordinates — the second face on the preset rows: the same six cells addressed as G54–G59, on the one brand where two nodes edit one object"
  },
  "anatomy/general-setup/controller/program-data/frames.html": {
    "href": "anatomy/general-setup/controller/program-data/frames.html",
    "title": "Frames | HiAPI-C# 2025",
    "summary": "Frames Frames is the Controller branch's Sinumerik settable-frame ledger: one row per $P_UIFR entry, each carrying the X / Y / Z translation HiNC stores for that frame. It lives on the General Setup page at /general-setup under the Control-Tree id equipment/controller/program-data/frames, reached as ?tree=equipment/controller/program-data/frames, and it is grown only while the active runner resolves a Siemens frame table — among the shipped brand presets, Siemens alone. That same table is the offset provider behind the ungated Work Coordinates (G54…) leaf on this brand, so the two nodes edit one object. Important Anatomy makes no claim that any id named here is stable across versions. The migration hop that keeps an older ?tree= value resolving is described in Tree Ids and Routes. What a Frame Is Here On a Sinumerik, $P_UIFR is an array of frames and each entry carries a translation, a rotation, a scale and a mirror. HiNC consumes the translation and nothing else, so SiemensFrameTable stores one Vec3d per frame id in Frames, with a second, axis-letter-keyed dictionary beside it for translation components on axes other than X, Y and Z. The table is a dependency in its own right rather than a section of the machine data, because $P_UIFR is not machine data on the control either: SiemensMachineDataTable holds the MD-numbered parameters — axis type, reference position, stroke limits — and carries no frame. That split is also why the frame table is the brand's ISO offset provider while the machine-data table is not. The array index is not the row key. Rows are keyed by the G-code that selects the frame, and the bridge that serves $P_UIFR accesses maps one onto the other: $P_UIFR index Frame id Row on this leaf 0 G500 none — the cancel frame is never stored 1–4 G54–G57 the four base rows 5–99 G505–G599 the extended tail An index outside 0–99 maps to no id at all, and the bridge drops the access rather than inventing a frame for it. Settable, and computed Four parts of the Sinumerik frame chain show up in this branch's behaviour, and only one of them is a row here. The settable frames are the table. Ninety-nine ids are allocated by the constructor — G54–G57 plus every id in ExtendedCoordinateSeries, which is G505 through G599 — each seeded to zero, matching a control where every $P_UIFR[n] is allocated with an initial value of zero. Every one is editable on this leaf. G500 is computed, not stored. The accessor answers a zero offset for it and drops a write, and the constructor deliberately keeps it out of the dictionary, so it is a row on neither this leaf nor Work Coordinates. The description above the table says as much: \"Settable frames ($P_UIFR, translation only); G500 cancels and stores nothing.\" The programmable frame — TRANS / ATRANS / ROT / AROT and their solid-angle forms, together with the CYCLE800 tilt that shares its slot — is computed per block from the program and has no table, no node and no stored value anywhere in this branch. A frame's rotation and fine-offset components reach neither this table nor the simulation. Only the TR component of a $P_UIFR access is bridged into the frame entry; a write to any other component is recorded on the block and reported as recognised-but-not-simulated by the Siemens system-variable catch-all. How the Chain Composes A frame word in a program selects one id. The Siemens coordinate syntax resolves that id's offset through GetEffectiveNcDependencyList(API), taking the first provider that answers, and writes the result twice: as the block's coordinate-offset section, and as one named entry in the block's program-to-machine transform chain. Entries in that chain are multiplied in the order they were written, so slot order is the whole of the composition rule. Two placements in the Siemens syntax list decide what a settable frame ends up doing. The programmable-frame entry is written first, deliberately. The tilt and programmable-frame syntaxes run ahead of the coordinate-offset syntaxes so their shared entry lands ahead of the settable frame's. That is what keeps a ROT turning the program coordinates inside the frame rather than turning the frame's own offset with them. Tool-height compensation is written between the two, and the kinematic pivot transform is written last so every frame-space operation is accumulated before the final inverse kinematics. Both coordinate syntaxes are registered, and they share one entry. The Siemens preset carries the ISO coordinate syntax and the Siemens one side by side; each writes the chain entry under the same name, and a repeated name is replaced in place rather than appended. So the G54–G59 vocabulary the ISO syntax recognises and the G500 and G505–G599 vocabulary the Siemens one adds resolve into a single slot. The Siemens syntax leaves the coordinate flag in place instead of consuming it, and falls back to the block's existing coordinate section and then to the previous block's, which is what carries a frame selection modally. Three codes bypass the composed transform for one block rather than changing it: G53, G153 and SUPA all reduce to the same one-shot machine-coordinate move, and the values on this leaf take no part in such a block. The word vocabulary is also wider than the table. The ISO syntax's own series adds G58, G59 and G59.1–G59.9, none of which the frame table allocates; such a word resolves to no offset from any provider and composes a zero translation. The Rows and the Columns The panel is a four-column table and nothing else — no toolbar, no add footer, no action column, no dialog. The Frame header is translated; X (mm), Y (mm) and Z (mm) are literals in the template and stay English under any locale. The id cell is bold plain text and cannot be edited. The row set is fixed. The branch exposes exactly two frame routes, a whole-table read and a per-id write; no third route adds, deletes or resets a row. The write itself is an unguarded assignment by key rather than an update of an existing row, so an id the table has never held would be seated as a new one — but no panel has a way to send such an id. A row exists because the table allocated it, and the ninety-nine allocated ids are the same ninety-nine whatever a project has done to their values. Nothing in the path sorts. The reader projects the dictionary as it enumerates it and applies no ordering, unlike the datum, retained-variable, R-parameter and tool-offset readers beside it, and the panel adds none of its own. What that yields depends on how the table was built. A table the proxy has just created lists G54–G57 first and then the extended tail, in construction order. A table read back from a project file lists the ids in the order the file names them — and the file is written sorted by id as text, not as a number. Plain string order puts G505 ahead of G54, because the third character decides that pair, and G54 ahead of G540, because the shorter of two strings that share a prefix comes first. So a saved and reopened table does not push the four base frames to either end: it interleaves them into the extended tail, as G505–G539, G54, G540–G549, G55, G550–G559, G56, G560–G569, G57, then G570–G599. Work Coordinates enumerates the same dictionary, so both leaves reorder together. Show all A Show all toggle sits at the right of the header strip. With it off, a row is listed only when its id matches G54 through G57, or when at least one of its three values is non-zero; with it on, every allocated id is listed. The test is the panel's own regular expression, evaluated in the browser over the rows the read returned — nothing about it reaches the server, and the toggle is a plain local flag that returns to off whenever the panel is remounted. Two details of that rule are worth reading against the sibling leaf. The toggle here is unconditional, so it renders even on a table with no extended rows at all. And the always-visible test here is narrower than the work-coordinate one, which admits G54 through G59 and any of them followed by a dot and one further digit. On the seeded table the two tests keep the same four rows visible, because the frame table allocates none of the ids where they differ. Two Nodes, One Table Warning On Siemens this leaf and Work Coordinates (G54…) are two faces of one instance, not two tables kept in step. The work-coordinate leaf resolves the first IIsoCoordinateConfig on the active runner; on this brand that is the frame table, because it is the only dependency the Siemens preset carries that implements that interface — the machine-data table included. A G54 edit made on either node is the same assignment into the same cell. This is the reciprocal half of the warning Work Coordinates carries. What the two leaves share, exactly: The row set. The work-coordinate reader enumerates the provider's own ids, which for this provider is the frame dictionary's key set. The two leaves therefore list the same ids in the same order, and gain or lose none independently. The X, Y and Z cells. Both leaves write the whole triad for one id, and both land in the same dictionary entry. Neither mutates the vector already sitting there: each write installs a fresh Vec3d over it, so a reference taken before the write still reads the old values. A value typed on one leaf is what the other shows at its next mount. The absence of G500. Neither leaf can show it, for the same reason: it is not in the dictionary the ids are enumerated from. What is not shared, and what a reader must not infer from the shared face: The per-axis translation components. A settable frame's translation on an axis letter other than X, Y or Z lives in the table's second dictionary, written and read only by the $P_UIFR bridge. Neither leaf returns it, and neither leaf disturbs it: both write a fresh Vec3d into the frame entry and leave the axis dictionary untouched, so a C-axis frame component set by a program survives every edit made from either panel. The row actions. The P0 and M0 buttons and the canvas marker belong to Work Coordinates. This leaf has no action column at all — but P0 and M0 write through the same provider, so pressing one there changes what this leaf shows. The presence gate. This leaf gates on the concrete frame table; the other gates on the ISO interface. On Siemens the two answers are one object and the leaves appear together; the empty lines they would show differ all the same — \"No Siemens frame table on the active runner.\" here, \"No work-coordinate table on the active runner.\" there. The write path. The work-coordinate route writes through the provider's coordinate accessor, which drops a G500 write; the frame route assigns into the dictionary by key and would store one. Neither is reachable from a panel, because both panels only ever send an id their own read returned. The caption. Work Coordinates picks its caption from the snapshot's coordinate-kind field and on this brand shows \"Stored as Siemens settable frames ($P_UIFR; G500 cancels and is always zero).\" — which is that leaf naming this one. This leaf's caption is fixed. Nothing reconciles the two views while both are in scope, and nothing needs to: the editor row mounts one panel at a time and each fetches once on mount, so moving the selection between the two nodes is itself the refresh. What a panel that stays mounted therefore never sees is described in Editing Contract. Editing a Frame Every value cell is the shared numeric field, so it commits on blur or on Enter and never per keystroke; its parsing, its bounds behaviour and the second commit that follows Enter are Numeric Input. No cell here passes a minimum or a maximum, and no cell carries a unit suffix — the millimetre is stated in the column header instead. The write is the whole row. A commit assigns the new number into the local row and sends that row's x, y and z as they now stand under the row's id. The optimistic shape, the single-cell rollback and the toast a failure raises are the branch's own and are described in the Editing Contract; what is this panel's is the guard in front of them. The numeric field can emit an empty value as null and the literals Infinity, -Infinity and NaN as non-finite numbers, and the handler returns before the request on all four. So a cleared cell stores nothing and clears nothing: the box shows blank while the stored number stands, and the number returns when the panel is remounted by selecting another node and coming back. No surface here renames a frame: the id is the write's route key and no route accepts a replacement for it. The panel reports no structural change either, so no edit on this leaf rebuilds the branch. What Survives, and What a Brand Change Destroys The table is per-case: SiemensFrameTableProxy stands in the runner's pipeline list and the real table lives on the project's PerCaseNcDependencyList, serialized inside the project file. That proxy carries no seed — it installs a freshly constructed table when the project holds none and takes the project's own table thereafter — so the runner file records only the placeholder, and a .Controller written from this project carries no frame values at all. The ownership rules the proxy pattern follows across the branch are Program Data. Two consequences follow for the values on this leaf. A same-brand runner install keeps them. The incoming preset's proxy re-binds to the table the project already holds rather than replacing it, and the sweep that follows keeps every per-case table the new runner resolves through a proxy. A switch to any other brand destroys them. No other preset proxies a frame table, so the sweep removes it, and switching back installs a fresh all-zero table rather than the one that was there. The brand switch's optional carry salvages a corner of it: the offsets are read from the outgoing provider before the swap and written into the incoming one afterwards, but only for ids the incoming provider already enumerates. No other shipped provider allocates a G5xx id — the Fanuc-family and Syntec tables enumerate G54–G59 and G54.1P1–G54.1P48, the Heidenhain datum table G54–G59 — so the carry keeps G54 through G57 and the whole extended tail is lost. What a switch keeps, resets and destroys elsewhere is Brand Switch; which leaf exists on which brand is Brand Matrix. What a Run Writes Back A played program does not only read this table; it writes into it, through a bridge with two halves. $P_UIFR[n,axis,TR]=… writes into it. A literal numeric assignment is routed into the table: an X, Y or Z component replaces that component of the frame entry, and any other axis letter lands in the per-axis dictionary. A non-literal right-hand side is left for the expression evaluator earlier in the same block, and a write to index 0 is consumed and ignored, mirroring the cancel frame's own rule. With no frame table on the runner the bridge is a no-op and the assignment stays visible as unconsumed residue. $P_UIFR reads come back out of it. The same mapping serves the read side, answering zero for an allocated frame's unset axis component and for every component of G500, and null — a fall-through to the next lookup in the chain — for an id the table does not hold. The table is deliberately not session-resettable. Settable frames are setting data on a real control: a $P_UIFR write survives reset and power-off, so a replayed session must see what the previous run left. The runner clears every session-resettable dependency on the fresh-session edge and this table is not among them, which means a value a run wrote is what this panel shows afterwards, and what the project file keeps. Which frame a program starts on is not stored in the table either. The Siemens preset's static initializer seeds the first block's coordinate id as G500, so an untagged Siemens program begins with no frame active and a zero offset until a frame word appears — unlike the Fanuc-family and Syntec presets, which begin on G54. Layout General Setup Control Tree — the left dock of /general-setup Controller Node Row Program Data Group Row — equipment/controller/program-data Frames (Siemens) Node Row — equipment/controller/program-data/frames; grown while the snapshot reports a Siemens frame table Editor Row — the panel of whichever node is selected Frames (Siemens) Panel No-Runner Body — \"No NC runner — load a project first.\"; the shared empty state, shown instead of everything below while the snapshot reports no runner Absent-Table Body — \"No Siemens frame table on the active runner.\"; shown instead of everything below while the panel's own read reports no table Header Strip Description Caption — \"Settable frames ($P_UIFR, translation only); G500 cancels and stores nothing.\", left-aligned and grey Show all Toggle — right-aligned, dense; always rendered Frame Table — dense, flat, bordered; no sort, no pagination, no column menu Header Row — Frame, X (mm), Y (mm), Z (mm). Only Frame is translated Frame Row, one per visible id — not clickable, and carrying no tooltip Frame Id Label — bold plain text, never editable Value Numeric Field, one per axis column — no minimum, no maximum, no unit suffix Toast — negative, three seconds, the panel's context followed by the server's own message The panel carries no heading, no add or delete control, no reset button, no save button and no unsaved marker. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/SoftNcFramesPanel.vue — the panel: the two empty layers, the fixed description and the unconditional Show all toggle, the four-column table with its two literal header spellings, the always-visible regular expression, and the whole-triad cell commit with its null and non-finite guard. wwwroot-src/src/components/controlTree/SoftNcWorkCoordinatesPanel.vue — the other node on this table: the same ids and values through the ISO reader, plus the wider always-visible test, the conditional toggle, the P0 and M0 actions and the canvas marker this leaf has none of. wwwroot-src/src/components/controlTree/softNcItemTypes.ts — the branch builder: this leaf's node id and label key, the snapshot flag it is pushed behind, and its position among the program-data children. wwwroot-src/src/components/controlTree/SoftNcEmptyState.vue — the shared no-runner line the panel opens with. wwwroot-src/src/components/widgets/NumericInput.vue — the value cell: commit on blur or Enter, the empty-text-to-null parse, and the infinity and NaN literals the panel's handler then rejects. wwwroot-src/src/api/softNcRunner.ts — the frames reader and its whole-triad setter, the shared offset-row shape and parser both leaves reuse, and the presence flag this leaf is gated on. wwwroot-src/src/api/http.ts — the envelope helper that turns a success: false body into a thrown error indistinguishable from a transport failure. wwwroot-src/src/composables/useSoftNcRunner.ts — the shared snapshot the first empty layer reads. wwwroot-src/src/i18n/en/softNc.ts — the node label, the description, the Frame column header, the absent-table line and the two error contexts. wwwroot-src/src/i18n/en/common.ts — the shared Show all label. Mech/SoftNcRunnerController.cs — the REST surface: the presence probe behind the node's gate, the unsorted frames reader with its zero fill, the per-id writer that assigns into the dictionary directly rather than through the coordinate accessor, the work-coordinate routes that share the same object on this brand, and the brand switch's capture-swap-carry-sweep with its accepted-id filter. HiAPI Engine HiMech/NcParsers/Dependencys/Siemens/SiemensFrameTable.cs — the table: the ninety-nine ids its constructor seeds, the cancel frame it keeps out of them, the coordinate accessors the work-coordinate leaf uses, the per-axis accessors the $P_UIFR bridge uses, the axis dictionary neither panel exposes, the deliberate absence of session-reset, and the id-sorted serialization that decides the row order after a reload. HiMech/NcParsers/Dependencys/Siemens/SiemensFrameTableProxy.cs — the seedless get-or-create placeholder: what the runner file records, and the fresh table it installs into a project holding none. HiMech/NcParsers/Dependencys/IIsoCoordinateConfig.cs — the offset-provider contract this table implements, which is what makes it the work-coordinate leaf's provider on this brand. HiMech/NcParsers/Dependencys/Siemens/SiemensMachineDataTable.cs — the MD table beside it, carrying no frames and implementing no offset-provider contract. HiMech/NcParsers/Keywords/Siemens/SiemensKeywords.cs — the cancel frame and the extended series the constructor seeds from. HiMech/NcParsers/Keywords/Generic/IsoKeywords.cs — the G54 series the ISO syntax recognises, wider than this table allocates. HiMech/NcParsers/SoftNcRunner.cs — the Siemens preset that carries the frame-table proxy as its first per-case entry, behind only the brand marker; the proxy resolution every read goes through; and the session-reset sweep this table is deliberately outside of. HiMech/NcParsers/ISessionResettable.cs — the marker the table does not carry, and the difference between session state and setting data it draws. HiMech/NcParsers/NcRunnerSuit.cs — the per-case list the table hangs off and the proxy wiring that installs it. HiMech/NcParsers/LogicSyntaxs/CoordinateOffsetUtil.cs — the resolver that walks every provider and takes the first non-null answer, the coordinate section it writes, and the translation it composes. HiMech/NcParsers/LogicSyntaxs/Siemens/SiemensCoordinateOffsetSyntax.cs — the frame-word path: the vocabulary it detects, the flag it leaves in place, the modal lookback, and the zero fallback when nothing answers. HiMech/NcParsers/LogicSyntaxs/IsoCoordinateOffsetSyntax.cs — the sibling registered beside it on this preset, writing the same chain entry from the G54–G59.9 vocabulary. HiMech/NcParsers/LogicSyntaxs/Siemens/SiemensProgrammableFrameSyntax.cs — the computed programmable frame, and the entry it shares with the tilt cycle ahead of the settable frame's. HiMech/NcParsers/Syntaxs/SiemensSyntaxUtil.cs — the slot order that decides the composition: tilt and programmable frame, tool height, the two coordinate syntaxes, then the pivot transform. HiMech/NcParsers/Syntaxs/TransformationUtil.cs — the transform chain: in-order multiplication, replacement of a repeated entry in place, and the pivot entry that must stay last. HiMech/NcParsers/LogicSyntaxs/MachineCoordSelectSyntax.cs — the one-shot codes that bypass the composed transform, widened on this preset to G153 and SUPA. HiMech/NcParsers/EvaluationSyntaxs/Siemens/SiemensUifrWritingSyntax.cs — the write half of the $P_UIFR bridge: the literal-only rule, the ignored cancel-frame index, and the no-op when no frame table resolves. HiMech/NcParsers/EvaluationSyntaxs/Siemens/SiemensUifrVariableLookup.cs — the read half. HiMech/NcParsers/EvaluationSyntaxs/Siemens/SiemensVariableKey.cs — the index-to-id map behind both halves, and the TR-only key pattern. HiMech/NcParsers/EvaluationSyntaxs/Siemens/SiemensSystemVariableSyntax.cs — where a non-TR frame component goes instead: recorded on the block, reported unsupported, never reaching the frame table. HiMech/NcParsers/Initializers/StaticInitializer.cs — the Siemens preset's first-block coordinate id, and the two brands that differ from it. HiMech/NcParsers/Dependencys/IsoCoordinateAddressMap.cs — the Fanuc-family id set the brand switch's carry intersects this table against. HiMech/NcParsers/Dependencys/Heidenhain/HeidenhainDatumTable.cs — the third id set the same carry can meet. See Also Program Data Plane — the plane this leaf sits on, and the ownership rules that decide what a runner install keeps and what a brand switch sweeps Work Coordinates — the other node on this table, where the same ids are edited as G54 offsets, with the row actions and the canvas marker this leaf has none of"
  },
  "anatomy/general-setup/controller/program-data/index.html": {
    "href": "anatomy/general-setup/controller/program-data/index.html",
    "title": "Program Data Plane | HiAPI-C# 2025",
    "summary": "Program Data Plane Program Data is the second of the Controller branch's two plane stems: the coordinate, offset and variable tables that belong to the workpiece rather than to the control, edited one leaf at a time. It lives on the General Setup page at /general-setup under the Control-Tree id equipment/controller/program-data, and each of its leaves takes that id plus one segment — work-coordinates, tool-offsets, siemens-tool-offsets, tool-names, datum-presets, datum-shifts, frames, retained-variables, r-parameters. The stem is not gated: it is part of the branch builder's return value rather than a conditional entry, so it appears wherever a runner resolves and always carries the two leaves no flag guards. Important Anatomy makes no claim that any id named here is stable across versions. The migration hop that keeps an older ?tree= value resolving is described in Tree Ids and Routes. Selecting the stem shows the shared group editor: its own introduction over a clickable list of its children. The introduction reads \"Data that travels with the workpiece / project — work-coordinate offsets (G54…), tool offsets and the brand-specific per-case tables. Kept on the project even when the runner file is swapped.\" Every leaf below follows the branch's shared editing rules — one read on mount, per-control commit, capture-assign-await-restore on failure, a dense markup table with no sort and no pagination, and the two empty layers. Those rules, and the places this plane departs from them, are Editing Contract. Where the Data Actually Lives The stem's introduction names a storage location, and here — unlike the machine stem's own introduction — it holds for every leaf. What it does not say is that the location is not a file. One list, inlined in the project NcRunnerSuit carries the runner beside the project's own PerCaseNcDependencyList, and serializes the two side by side. The runner half can be written to a side file; the per-case half never is — the suit writes it as a nested element with no file reference of its own, so it lands inside whatever file the owning project writes. Every table this plane edits is an entry of that one list. No panel and no endpoint reads or writes a table by reaching into that list by name. The one place that addresses the list directly is the sweep that follows a runner swap, and it removes whole entries rather than editing any value in one. A brand preset's pipeline list carries an INcDependencyProxy in place of each of these tables, and every read and write resolves through GetEffectiveNcDependencyList(API), which substitutes the project's table for the placeholder. That is also what the snapshot flags probe, so the tree grows a leaf for the concrete table and never for the proxy — Brand Matrix. The proxies on this plane carry nothing ToolOffsetTableProxy and its siblings — the Siemens $TC_DP, frame and R-parameter proxies, the Heidenhain datum proxy and the Fanuc-family retained common variable proxy — are get-or-create placeholders with no seed. Each serializes an empty element, and on wiring installs a bare new instance into the per-case list when the project holds none of that type; an existing table is left untouched. Two consequences follow. A controller file written from the branch root's Object-Management menu carries none of the values edited on this plane: the seedless proxies write an empty element, and the one proxy on this plane that does carry a seed — the brand parameter-table proxy standing behind the work coordinates on the Fanuc family and Syntec — serializes the fixed seed it was constructed with rather than the table the panels have been editing. And a table this plane loses is not recoverable from a preset: a fresh instance is what the proxy makes. Which store a work coordinate lands in Work Coordinates is the one leaf whose backing object changes with the brand. The panel reads and writes the first IIsoCoordinateConfig in the effective list, and the caption above its table names which one answered. Brand Backing object Ids the table lists Caption above the table Fanuc, Mazak FanucParameterTable G54–G59 and G54.1P1–G54.1P48 \"Stored in the Fanuc parameter table (#5221+ / #7001+).\" Syntec SyntecParameterTable G54–G59 and G54.1P1–G54.1P48 \"Stored in the Syntec parameter table (Pr5221+ / Pr7001+).\" Siemens SiemensFrameTable G54–G57 and G505–G599 \"Stored as Siemens settable frames ($P_UIFR; G500 cancels and is always zero).\" Heidenhain HeidenhainDatumTable G54–G59 \"G54–G59 map onto Heidenhain datum preset rows 1–6.\" An id appears only where the store actually holds it. A Fanuc-family or Syntec table yields an id whose parameter address is present, and every one of those default tables seeds all of them at zero; the Siemens frame table seeds G54–G57 and the extended series, and has no G58 or G59 row at all; the Heidenhain table yields one id per preset row 1–6 that exists. G500 is never a row — the frame table refuses to store it and does not seed it. That caption is the panel's only statement of where a value went, and it is selected from the snapshot's work-coordinate kind rather than from the brand marker. The one setting that is not in the list The Tool Offsets leaf's Set ideal offset dependent on tool house toggle is not a dependency. It writes IsIdealOffsetDependentOnToolHouse, an element the project serializes beside the runner suit. It therefore stays with the project like everything else on this plane, but by a different route — and, being outside the per-case list, it is untouched by the sweep that follows a runner swap. How This Differs From the Machine Plane The machine plane's ownership is split. Several of its leaves are plain instances the runner owns outright — the tool-change position, the block-skip layers, the subprogram folders, and on Siemens and Heidenhain the peck clearance — and an install replaces them with the incoming runner's; the rest are rows of the brand parameter table and are stored on the project. One leaf holds both halves: Controller Parameters, where the macro loop guards are runner-owned fields sitting beside table rows. Which side of that line a machine-plane field falls on is Machine and Controller Plane. This plane has no such split. Nothing on it is a plain runner-owned instance: every leaf resolves a per-case table through a proxy, so every value it edits is stored on the project. That is what makes the two introductions' phrasing load-bearing rather than decorative — and it is why installing a controller file of the brand already in force changes nothing here at all: each of that brand's proxies takes the table the project already holds rather than installing a fresh one over it. The same install does return the machine plane's runner-owned settings to the incoming file's values. The one crossing runs the other way. On Fanuc, Mazak and Syntec the work coordinates are rows of the same brand parameter table whose other rows the machine plane's per-axis leaves and native parameter form edit. A single object straddles both stems there, which is exactly why that table is per-case at all: the two planes could not otherwise be separated. The Plane's Leaves Ordered as the branch builder pushes them: the two ungated leaves first, then each gated leaf or gated pair behind the snapshot flag that grows it. Which brands satisfy each flag is Brand Matrix; the column that page does not carry is the last one here. Node segment Label the tree shows Gate Backing table work-coordinates Work Coordinates (G54…) ungated the brand's ISO coordinate provider, per the table above tool-offsets Tool Offsets, read as Tool Offsets (ISO G43 H) where the Siemens table resolves ungated; label switched by hasSiemensToolOffsets ToolOffsetTable siemens-tool-offsets Tool Offsets ($TC_DP) hasSiemensToolOffsets SiemensToolOffsetTable, its cutting-edge map tool-names Tool Names hasSiemensToolOffsets SiemensToolOffsetTable, its name map datum-presets Datum Presets (Q339) hasDatums HeidenhainDatumTable, its preset rows datum-shifts Datum Shifts (D) hasDatums HeidenhainDatumTable, its shift rows frames Frames (Siemens) hasFrames SiemensFrameTable retained-variables Retained Common Variables hasRetainedVariables RetainedCommonVariableTable r-parameters R Parameters hasRParameters SiemensRParameterTable Every label above is a translated role string rather than a type name, so the tree renders the translation and a locale change rewrites the rows without touching an id. Two leaves stand on every brand: Work Coordinates (G54…) and Tool Offsets. They are the builder's unconditional entries, and every brand preset satisfies them — each carries an ISO coordinate provider of its own, and all five proxy the generic tool-offset table. The remaining leaves are pushed inside a flag test, and each of those flags is satisfied by one brand family only. Fewer tables than leaves Two flags grow two leaves each, because two leaves edit two halves of one object. Tool Offsets ($TC_DP) and Tool Names are the cutting-edge map and the name map of a single Siemens tool-offset table, which is why there is no separate tool-name flag and why the two nodes appear and disappear together. Datum Presets (Q339) and Datum Shifts (D) are the preset rows and the shift rows of a single Heidenhain datum table, served by one component that reads its role from the node id's last segment. The work coordinates then fold two more leaves together, on the two brands where the ISO provider is a table this plane already lists. On Siemens, Work Coordinates and Frames (Siemens) are two views of one frame dictionary — the same ids, the same X/Y/Z translations, edited through two panels. On Heidenhain, the G54–G59 rows of Work Coordinates are preset rows 1–6 of Datum Presets (Q339), so editing one changes what the other shows. Datum Shifts has no such alias, and the Siemens frame table's per-axis translation components beyond X/Y/Z are reachable from neither panel. The two tool-offset ledgers disagree on the sign of wear Where both are present the difference matters more than the labels suggest. On the generic table an effective value is the ideal minus the wear; on the Siemens $TC_DP table it is the geometry plus the wear. That is why the Siemens panel spells the addition out in a footnote below its table, and says in its own description that a shortened tool is entered as negative wear, while the generic panel states no sign rule at all. The relabel of the ungated leaf to Tool Offsets (ISO G43 H) exists so that the two are not read as one ledger. What a Brand Change Does Here A brand switch replaces the whole runner with the target brand's preset and then removes every per-case table the new runner references through no proxy. This plane is where that sweep lands: the machine plane's project-owned parameter table is one entry, and every other entry the sweep can reach is a table edited here. The staged select, its confirmation and the rest of the control are Controller Brand; what follows is the outcome for this plane alone. Tool Offsets survives every switch. All five presets proxy the generic tool-offset table, so the sweep's keep-set always contains it. Its rows, its tool numbering and the tool-house dependence toggle beside it come through a brand change unchanged; only the leaf's label can change. Every other table on the plane is brand-bound and is removed the moment the target brand proxies none of it — the Siemens $TC_DP table with its tool-name map, the Siemens frame table, the Siemens R-parameter table, the Heidenhain datum table, and the Fanuc-family or Syntec parameter table that holds the work coordinates. Switching back does not restore what was removed; the proxy makes a fresh instance instead, empty for the tool-offset, tool-name, R-parameter and retained-variable tables, and zero-filled for the frame and datum tables that seed a row set in their constructor. The Fanuc and Mazak presets proxy the same parameter table, so a switch between those two brands sweeps nothing here: the work coordinates and every other row of that table stay where they are. Retained Common Variables spans a family rather than a brand. Fanuc, Syntec and Mazak all proxy it, so it survives any switch among those three and is removed on a switch to Siemens or Heidenhain. Work coordinates are the one set of values a switch can carry across. The brand panel's Carry work-coordinate XYZ (G54…) into the new brand's table checkbox is on by default; the switch reads every id the outgoing providers exposed and, after the swap, writes each back only to a provider on the incoming runner that lists it — never to a provider that would merely accept it. The Fanuc-family and Syntec presets expose the same set — G54–G59 and all forty-eight G54.1 P offsets on the brand table, every address seeded, plus the extended G59.1–G59.9 on the brand-neutral table behind it — so a switch between Syntec and either of Fanuc and Mazak carries every one of them. A switch into Siemens carries only G54–G57, the frame table listing no G58, no G59, no G59.x and no G54.1 P id at all; a switch into Heidenhain carries G54–G59 and drops the forty-eight G54.1 P offsets and the nine G59.x. No other table's values are carried, and the carry is skipped for a table the swap re-bound rather than replaced — which is the Fanuc-to-Mazak case. The banner shown before the apply says as much in one line: \"Switching brand replaces the whole runner with the {brand} preset. Machine settings reset to that preset's defaults and the old brand's program-data tables are removed — switching back does not restore them.\" An Object-Management Load, Paste or XML apply runs the same install and the same sweep, so a controller file of another brand takes this plane through the identical outcome without the carry option. Both writes are refused while an NC program is playing. Layout General Setup Control Tree — the left dock of /general-setup Controller Node Row Machine / Controller Group Row — the plane beside this one Program Data Group Row — equipment/controller/program-data Work Coordinates (G54…) Node Row Tool Offsets Node Row — reads Tool Offsets (ISO G43 H) where the Siemens $TC_DP table resolves Tool Offsets ($TC_DP) Node Row — grown while the snapshot reports a Siemens tool-offset table Tool Names Node Row — grown on the same flag Datum Presets (Q339) Node Row — grown while it reports a Heidenhain datum table Datum Shifts (D) Node Row — grown on the same flag Frames (Siemens) Node Row — grown while it reports a Siemens frame table Retained Common Variables Node Row — grown while it reports a retained common variable table R Parameters Node Row — grown while it reports a Siemens R-parameter table Editor Row — the panel of whichever node is selected Program Data Group Panel Intro Caption — the stem's introduction line Child List — one bordered, separated row per leaf above, each showing the leaf's label in the theme's primary colour with a right chevron; a click selects that leaf The stem's own editor holds no field, so nothing on this plane is edited from the group row itself. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/softNcItemTypes.ts — the branch builder: the program-data stem's id, label key and intro key, the two leaves it pushes unconditionally, the snapshot flag each further leaf is pushed behind in the order the table above lists them, and the tool-offsets relabel. wwwroot-src/src/components/controlTree/GroupInfoPanel.vue — the stem's editor: the intro caption and the clickable child list that selects a leaf. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — builds the equipment/controller root this stem hangs from, inside the equipment group. wwwroot-src/src/api/softNcRunner.ts — the snapshot shape the builder reads its flags from, and the typed wrappers over each leaf's reader and writers. wwwroot-src/src/composables/useSoftNcRunner.ts — the shared snapshot the leaf panels gate on, the brand switch with its carry option, and the Object-Management install that regrows the branch. wwwroot-src/src/components/controlTree/SoftNcWorkCoordinatesPanel.vue — the one panel that reads the snapshot's work-coordinate kind, the caption it selects from it, and the extended-row filter. wwwroot-src/src/components/controlTree/SoftNcToolOffsetsPanel.vue — the generic ledger: the tool-house dependence toggle, the refresh it enables, and the Siemens caveat gated on the brand string rather than on the table flag. wwwroot-src/src/components/controlTree/SoftNcSiemensToolOffsetsPanel.vue and wwwroot-src/src/components/controlTree/SoftNcToolNamesPanel.vue — the two leaves over one Siemens table: the cutting-edge rows and the name map. wwwroot-src/src/components/controlTree/SoftNcDatumTablePanel.vue — the one component behind both Heidenhain leaves, choosing its role from the node id's last segment. wwwroot-src/src/components/controlTree/SoftNcFramesPanel.vue — the settable-frame table and its own always-visible set, narrower than the work-coordinate panel's. wwwroot-src/src/components/controlTree/SoftNcRetainedVariablesPanel.vue and wwwroot-src/src/components/controlTree/SoftNcRParametersPanel.vue — the two sparse variable tables, and the vacant entry a cleared cell writes. wwwroot-src/src/components/controlTree/SoftNcEmptyState.vue — the shared no-runner line every leaf on this plane falls back to. wwwroot-src/src/api/equipmentSetup.ts — the canvas marker id a work-coordinate row click writes, outside this branch's own REST surface. wwwroot-src/src/i18n/en/softNc.ts — the stem's introduction line, every leaf label in the table above, the work-coordinate storage captions and the brand-switch warning. wwwroot-src/src/i18n/en/common.ts — the shared column and action labels these tables reuse. Mech/SoftNcRunnerController.cs — the plane's REST surface: the presence flags, the per-table readers and writers, the brand switch with its work-coordinate carry, and the sweep of per-case tables the new runner references through no proxy. Mech/EquipmentSetupDisplayController.cs — the marked-coordinate id a work-coordinate row click stores, on the user configuration rather than on the project. HiAPI Engine HiMech/NcParsers/NcRunnerSuit.cs — the suit: the per-case list this plane's tables live in, the serialization that inlines it with no file reference, and the proxy wiring that materialises a table into a project holding none of that type. HiMech/NcParsers/SoftNcRunner.cs — the five brand presets as literal dependency lists, showing which proxies each brand carries, and the proxy resolution every read on this plane goes through. HiMech/NcParsers/Dependencys/INcDependencyProxy.cs — the maker-and-taker contract, and why a proxy's resolved data is never written into the runner. HiMech/NcParsers/Dependencys/Generic/ToolOffsetTableProxy.cs — the seedless get-or-create shape the Siemens, Heidenhain and Fanuc-family per-case proxies on this plane all repeat. HiMech/NcParsers/Dependencys/Fanuc/FanucParameterTableProxy.cs — the contrasting seeded proxy, and its own account of why the Fanuc-family table mixes machine configuration with the per-case work-coordinate offsets. HiMech/NcParsers/Dependencys/IIsoCoordinateConfig.cs and HiMech/NcParsers/Dependencys/IsoCoordinateAddressMap.cs — the interface the work-coordinate panel edits through, and the address arithmetic that decides which ids a Fanuc-family or Syntec table lists. HiMech/NcParsers/Dependencys/Generic/ToolOffsetTable.cs — the generic ledger every preset proxies, and the subtraction that makes an effective value ideal minus wear. HiMech/NcParsers/Dependencys/Siemens/SiemensToolOffsetTable.cs — the cutting-edge map and the name map behind two leaves, and the addition that makes an effective value geometry plus wear. HiMech/NcParsers/Dependencys/Siemens/SiemensFrameTable.cs — the settable frames: the ids the constructor seeds, the ISO coordinate implementation the work-coordinate leaf shares, and the per-axis translation components neither panel exposes. HiMech/NcParsers/Dependencys/Siemens/SiemensRParameterTable.cs and HiMech/NcParsers/Dependencys/Fanuc/RetainedCommonVariableTable.cs — the two persistent variable tables, their accepted id ranges, and the vacant entry a valueless element preserves across a save. HiMech/NcParsers/Dependencys/Heidenhain/HeidenhainDatumTable.cs — the preset and shift rows behind two leaves, and the mapping that aliases G54–G59 onto preset rows 1–6. HiMech/MachiningProcs/MachiningActRunnerConfig.cs — the tool-house dependence flag, the one setting on this plane stored outside the per-case list. HiNc/MachiningProcs/LocalProjectService.cs — the facade setter every install and brand switch assigns through, and the proxy re-binding that materialises the incoming brand's per-case tables. HiNc/MachiningProcs/MachiningProject.cs — where the suit and the runner configuration hang off the project, and the load path for a project file carrying the per-case list. Pages Ordered by the first node each page owns, as the plane lists them. Work Coordinates — The one uniform face over four brand storage models, its P0 and M0 row actions, and the row click that marks a coordinate on the canvas Tool Offsets — The generic ISO ledger: ideal against wear, the renameable tool number, and what tool-house dependence takes over Siemens Tool Offsets — The $TC_DP cutting-edge table and the tool-name map beside it, two leaves over one object Datum Tables — The Heidenhain preset and shift rows, one component serving both, and the preset rows the work coordinates alias Frames — The Siemens settable frames, the ids they seed, and what the work-coordinate leaf shows of the same table Persistent Variables — The retained common variables and the R parameters: sparse tables, accepted ranges, and the difference between vacant and deleted See Also Controller Branch — the branch this plane is half of, its runner root and the machine plane beside it Machine and Controller Plane — the other plane, whose ownership splits between the runner and the project where this one does not Brand Matrix — which brand satisfies each gate named above, and what each flag actually probes Editing Contract — the commit, rollback and rendering rules every leaf on this plane inherits, and the panels that depart from them Work Coordinates — the ungated leaf whose backing object changes with the brand, and the only values a brand switch can carry Tool Offsets — the other ungated leaf, and the one table on this plane that survives every brand switch Siemens Tool Offsets — the second tool-offset ledger, whose presence relabels the first Datum Tables — the two Heidenhain leaves, and the preset rows the work coordinates share Frames — the Siemens frame table, read by two leaves of this plane at once Persistent Variables — the two variable tables a program's arithmetic reads, kept on the project rather than reset with the session"
  },
  "anatomy/general-setup/controller/program-data/persistent-variables.html": {
    "href": "anatomy/general-setup/controller/program-data/persistent-variables.html",
    "title": "Persistent Variables | HiAPI-C# 2025",
    "summary": "Persistent Variables Persistent Variables is the pair of program-variable ledgers the Controller branch grows for one brand or the other, and no shipped preset carries both: the Fanuc-style retained common variables and the Sinumerik R parameters. Both live on the General Setup page at /general-setup under the Control-Tree ids equipment/controller/program-data/retained-variables and equipment/controller/program-data/r-parameters — reached as ?tree=equipment/controller/program-data/retained-variables and ?tree=equipment/controller/program-data/r-parameters — and the tree labels them Retained Common Variables and R Parameters. They share a page because no preset shows both: each node is grown by a flag that one set of brand presets satisfies and the other set does not. Important Anatomy makes no claim that any id named here is stable across versions. The migration hop that keeps an older ?tree= value resolving is described in Tree Ids and Routes. Two Nodes That Exclude Each Other The branch builder pushes each of the two nodes inside a test of its own, one snapshot flag each, and each flag is a single type probe over the runner's proxy-resolved dependency list — RetainedCommonVariableTable behind one and SiemensRParameterTable behind the other. Which brand satisfies which gate is Brand Matrix; the short answer is that the Fanuc, Syntec and Mazak presets carry a retained-common-variable proxy, the Siemens preset carries an R-parameter proxy, and the Heidenhain preset carries neither. The exclusion is a property of the five preset lists, not a rule in the builder. Nothing in the tree code forbids the two rows from standing together; no shipped preset simply carries both entries, and the brand select can produce nothing but a preset. A runner composed by hand or loaded from a controller file whose pipeline list named both tables would grow both rows, each with its own working panel — and the Object-Management menu on the branch root, described in Controller Branch, installs such a file without inspecting what its pipeline names, so that route is open from inside the branch. The two panels are separate components rather than one component discriminating on the node id, so neither reads the node it was given. What they share is a shell: the same three-state body, the same dense table, the same footer, and the same commit, rollback and toast rules the whole branch follows — Editing Contract. What Each Ledger Is Retained Common Variables RetainedCommonVariableTable models the Fanuc-style ISO controller's common variables in the retained range #500–#999 — the range a real control keeps in non-volatile memory across a power cycle, which is why the model stores it with the project rather than with the run. It is the range, not the whole macro-variable surface: the table answers a #nnn lookup only for 500 through 999 and returns nothing for any other key, so an out-of-range reference falls through to the next lookup in the evaluator's chain. The neighbouring ranges are deliberately elsewhere, and none of them has a node on this branch. #1–#33 are call-frame locals bounded by a macro call rather than by a power cycle. #100–#499 are the non-retained commons, carried block to block in the per-block dataflow and cleared on the block that ends the program. #1000 and above are read-only or computed from runtime state rather than stored here: some resolve against other dependencies — the brand parameter table behind the work-coordinate addresses, the tool offset table behind #2001–#2200 — and some come from the block's own record, which is where the position variables are read and where a system-control write is recorded rather than emulated. The type name and the tree label both say common variable rather than macro variable, because the model reserves “macro” for Custom Macro B's call frame. The hint above the table is the one string in the leaf that says Retained macro variables instead. R Parameters SiemensRParameterTable models the Sinumerik arithmetic variable surface R0–R999 — the R63=100.5 and C=R61 of a Siemens program. On the control these sit in retentive memory and survive both program end and a power cycle, and the model keeps them the same way: stored with the project, not reset with the session. The table answers an Rn key in the canonical uppercase form the Siemens expression parser produces, and a lowercase rn from a raw capture resolves as well. Every other key returns nothing. Addressing and Ranges Retained Common Variables R Parameters Node id equipment/controller/program-data/retained-variables equipment/controller/program-data/r-parameters Snapshot flag hasRetainedVariables hasRParameters Backing table RetainedCommonVariableTable SiemensRParameterTable Brands Fanuc, Syntec, Mazak Siemens Key column header Variable Parameter Key cell reads # then the number R then the number Accepted ids 500–999 0–999 Bounds on the add field minimum 500, maximum 999 minimum 0, maximum 999 Absent-table body \"No retained common variable table on the active runner.\" \"No R-parameter table on the active runner.\" Each range is a pair of constants declared on the table type, and four separate places enforce it. The panel refuses an add whose id is not a whole number inside the range and says so in a toast of its own. The numeric field carrying that id rejects a finite value outside its bounds before the panel ever sees it — the infinity and NaN literals the field also parses skip the bounds test entirely and are stopped by the panel's whole-number check instead. The write endpoint compares the id against the same two constants and answers unsuccessfully with the range spelled out in the message. And behind all three, the table's own writer ignores an out-of-range id — the guard that holds for a caller reaching the table directly rather than through the endpoint, which is how a run writes. The endpoint's guard is not reachable from a project this app wrote. The rows a panel writes to came from the table, the add path is already filtered, and the serializer drops an out-of-range key on the way out, so no file the app saves carries one. Loading applies no such filter: a project file edited by hand can carry an id outside the range, the read lists it and the panel shows it, and editing that row's value is the one way a reader meets the endpoint's range message. No range is narrowed by machine data. The R range in particular is the fixed pair 0–999 on the table type; the endpoint reads no value from the Siemens machine-data table before accepting an id, so the parameter count a real control would allocate does not constrain what this leaf accepts. Neither table is dense. A row exists for an id that has been written, and for no other, so a thirty-row table and a four-row table are equally normal and the numbers in the key column need not be contiguous. A project that has never written one shows an empty table body under the header, because the proxy that materialises the table installs a bare instance carrying nothing — Program Data Plane covers the seedless proxies this plane is built from. The read returns the rows in ascending id order and the panel never re-sorts: an edit leaves a row where it is, a delete removes it in place, and only the re-read that follows an add re-orders anything. What Persists, and What Clears Both tables are per-case entries of the project's own dependency list, reached through a get-or-create placeholder in the runner's pipeline list. The runner file records only an empty placeholder element, so the values are written into the project file rather than into a controller asset. Four things in the runtime could plausibly discard what these tables hold. Three of them leave both tables alone; the fourth removes a table outright rather than clearing it. A new session does not clear them. The session-init edge that rebuilds the syntax pipeline sweeps every dependency and syntax declaring session-scoped state — iteration counters, index allocators — and calls each one's reset. Neither table declares any, so both are skipped. A power reset does not clear them. The power-reset command sweeps the proxy-resolved dependency list for dependencies declaring a volatile subset and then resets the session state, dropping the per-block dataflow. None of the dependencies a brand preset carries declares a volatile subset, so what a power reset actually discards is the dataflow — which is where the non-retained commons live — while every value in these two tables stands. Program end does not clear them. The syntax that models a control's M02 / M30 reset empties the block's volatile dictionary and cancels an active modal macro. It writes into the block's own record and reaches no dependency at all, so neither table is in its path. A brand switch removes the whole table rather than clearing it. The sweep that follows a runner swap keeps exactly the per-case tables the new runner resolves through a proxy, so a switch to a brand that proxies neither drops the table outright, and switching back materialises a fresh empty one rather than the values that were there. Retained Common Variables is the wider of the two: all three of Fanuc, Syntec and Mazak proxy it, so it survives any switch among those three and is removed on a switch to Siemens or Heidenhain. R Parameters survives only a Siemens-to-Siemens re-flash. What a switch keeps, resets and destroys across the whole plane is Program Data Plane. A run writes into the same table These are not a snapshot of what a program did — they are the store the program uses. Each brand's syntax list carries a reading syntax that consumes a literal assignment out of the parsed block and writes it straight into the table: #500 = 1.234 on the three Fanuc-style brands, R63 = 100.5 on Siemens. No mirror is kept in the per-block dataflow; the table is the single source of truth. A non-literal right-hand side is resolved to a literal earlier in the same block by the expression normaliser and then lands by the same route, so #600 = #500 + 1 reaches the table as well. Reads run the other way through the same object: each table is a variable lookup on the effective dependency list, so an expression naming an id in range reads whatever the leaf shows. Two consequences follow for a reader of this leaf. A played program changes what the table holds, and because no panel in the branch is pushed at, the change appears only when the panel is remounted by selecting another node and coming back. And because the table is written into the project file, those run-time writes are what the next load of that project starts from — once the project is saved. Nothing in the branch and nothing on the run path saves on its own: a panel edit and a run-time write alike stand in memory until an explicit save, and closing the project without one discards them. Vacant is a value, and it fails loud A stored null is a vacant entry, and so is a missing key — the table reads the two identically. Vacant is not zero. An expression that evaluates a vacant id does not fall back to a number: the evaluator returns a failure carrying the code Variable--Vacant and a message naming the key, which is what the R-parameter hint means by reporting an error instead of silently using 0. Vacant and deleted are different operations even though they read the same at run time. Clearing a cell keeps the key with a null value; the delete button drops the key. The distinction survives a save, because a vacant entry is written as an element carrying an id and no value while a deleted one is written as nothing at all — so a vacant row comes back as a row, and a deleted one does not come back. The Editor Body Above the table sits a one-line hint, and it is the only prose either panel shows. Both render the literal text <vacant> inside it as inline code. Retained Common Variables: \"Retained macro variables #500–#999 (power-off safe). Empty = <vacant>. #100–#499 are volatile and live in the run's dataflow, not here.\" R Parameters: \"Sinumerik R parameters R0–R999 (retentive). Empty = <vacant> — a program reading a vacant R parameter reports an error instead of silently using 0.\" The table below it has three columns. The first is the key — headed Variable or Parameter — rendered bold as plain text and not editable, which is the branch's rule for a key column. The second is headed Value and holds the shared numeric field. The third carries the row's delete button under a blank header, so the branch's shared Actions heading does not appear on either leaf. Editing a value A value cell is the shared numeric widget, so it commits on blur or on Enter and never per keystroke; its parsing, its bound behaviour and the double commit an Enter can cause are Numeric Input. No value cell is bounded — neither panel passes a minimum or a maximum to it — so any finite number is accepted and stored, negatives included. These two panels are the branch's only pair that commits a null. Every other numeric handler in the branch treats a cleared cell as no edit and returns before the request; here the null is sent, because vacating an entry is a real state of both tables and there is no other control that reaches it. Clearing the cell is therefore how a row is made vacant while keeping its key. The handler is otherwise the branch's ordinary optimistic write — assign, send, and on failure put the captured value back and raise the toast — and it carries no finiteness test. The widget parses Infinity and -Infinity as values, and neither survives JSON encoding: the request body reaches the server carrying a null, and the entry is set vacant. The cell keeps showing Infinity until the panel is remounted, so that is the one place in the table body where the screen and the store disagree after a write the server accepted. A typed NaN takes the same route to vacant, and the cell renders it as empty, which is what a vacant entry looks like anyway. Adding and removing a row The footer under the table is the branch's fielded add form: a numeric field for the id — labelled Variable # (500–999) or Parameter # (0–999) — a second numeric field labelled Value, and a primary Add / Set button. Both fields are the same numeric widget as the value cells, so what they hold reaches the panel on blur or Enter rather than per keystroke, and neither input submits on Enter. The button label's second word is the accurate one: the write is an upsert. Entering an id the table already lists overwrites that row's value rather than adding a second row. Leaving Value empty creates the row vacant. A successful add is followed by a full re-read of the table, which is what puts the new row in ascending order; the two fields keep what was typed in them. Two refusals sit in front of that write, and they read differently. An id outside the field's own bounds is rejected inside the widget, which shows its message under the box, emits nothing and leaves the rejected text on screen — so the panel still holds the id the field last committed to it. On a panel that has committed none, that is nothing at all, and pressing Add / Set reports the panel's own message: \"Variable number must be an integer in 500–999.\" or \"Parameter number must be an integer in 0–999.\" The panel's message is also what a fractional id produces, since the panel requires a whole number and the field does not. A field that has already committed a valid id keeps it, and nothing clears either field after an add. So an out-of-range id typed over one the field already accepted is the second place on these leaves where the screen and the store part company: the box shows the rejected number, the panel still holds the earlier id, and Add / Set upserts that earlier id with whatever the value field holds — no message of any kind, and the re-read that follows leaves the rejected number in the box. Removal is one icon button per row, with no label, no tooltip and no confirmation dialog: the click sends the delete, and the row is filtered out of the panel's list once the request resolves. The branch guards some of its deletions with a confirmation dialog; neither of these two leaves is among them. The endpoint removes the key and reports success whether or not the key was there. What the Surface Covers A third table of the same shape exists in the engine and has no node. HeidenhainQParameterTable holds the Heidenhain persistent Q parameters — the free range Q0–Q99 and the permanent QR0–QR499, in two stores of its own — and the Heidenhain preset carries a proxy for it beside the two documented above. It is materialised into the project's per-case list exactly as they are, is serialized into the project file the same way, is swept by a brand switch away from Heidenhain the same way, and is read and written during a run by the Heidenhain reading syntax that routes Qn and QRn assignments by id range. What it has no part in is this branch. The snapshot the tree is built from declares no flag that probes it, the branch's REST surface declares no route that reaches it, and the branch builder mints no node for it. The Controller branch's editable persistent-variable surface is the two tables named above; a Heidenhain project's Q parameters are set and read by the program that runs, and are carried by the project file between runs. Layout General Setup Control Tree — the left dock of /general-setup Controller Node Row Program Data Group Row — equipment/controller/program-data Retained Common Variables Node Row — equipment/controller/program-data/retained-variables; grown while the snapshot reports a retained common variable table R Parameters Node Row — equipment/controller/program-data/r-parameters; grown while the snapshot reports a Siemens R-parameter table Editor Row — the panel of whichever node is selected Retained Common Variables Panel No-Runner Body — the shared \"No NC runner — load a project first.\"; shown first Absent-Table Body — \"No retained common variable table on the active runner.\" Editor Body Hint Caption — \"Retained macro variables #500–#999 (power-off safe). Empty = <vacant>. #100–#499 are volatile and live in the run's dataflow, not here.\" Variable Table — dense, flat, bordered Header Row — Variable, Value, and a blank third heading Variable Row, one per stored id Variable Number Label — bold plain text, # then the number, not editable Value Numeric Field — unbounded; cleared commits vacant Delete Button — a bin icon, flat and dense, no label and no confirmation Add Row Footer Variable # (500–999) Numeric Field — minimum 500, maximum 999 Value Numeric Field — unbounded; left empty adds the row vacant Add / Set Button — primary, unelevated R Parameters Panel — the same shell with the Siemens strings No-Runner Body — the shared \"No NC runner — load a project first.\" Absent-Table Body — \"No R-parameter table on the active runner.\" Editor Body Hint Caption — \"Sinumerik R parameters R0–R999 (retentive). Empty = <vacant> — a program reading a vacant R parameter reports an error instead of silently using 0.\" Parameter Table — dense, flat, bordered Header Row — Parameter, Value, and a blank third heading Parameter Row, one per stored id Parameter Number Label — bold plain text, R then the number, not editable Value Numeric Field — unbounded; cleared commits vacant Delete Button — a bin icon, flat and dense, no label and no confirmation Add Row Footer Parameter # (0–999) Numeric Field — minimum 0, maximum 999 Value Numeric Field — unbounded; left empty adds the row vacant Add / Set Button — primary, unelevated Neither panel opens a dialog, and neither carries a select, a toggle or a Show all control. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/SoftNcRetainedVariablesPanel.vue — the #500–#999 ledger: the hint with its vacant slot, the three-column table, the value handler that sends a null without a finiteness test, the unconfirmed delete, and the add form with its whole-number and range check. wwwroot-src/src/components/controlTree/SoftNcRParametersPanel.vue — the R0–R999 ledger: the same shell with the Siemens strings, the R-prefixed key cell, and the add field bounded from 0. wwwroot-src/src/components/controlTree/softNcItemTypes.ts — the branch builder: the two node ids, their labels and label keys, the two flags each is pushed behind, and the item types binding them to the two panels. wwwroot-src/src/api/softNcRunner.ts — the two readers, their identical row shape with a nullable value, the two setters and the two removers, and the two snapshot flags the builder tests. wwwroot-src/src/api/http.ts — the helper that turns a success-flagged failure body into a thrown error, which is how an out-of-range write would reach a panel. wwwroot-src/src/components/widgets/NumericInput.vue — the value and add fields: commit on blur or Enter, the empty-text-to-null parse both panels forward, the infinity and NaN literals it also accepts, and the bound rejection that shows a message and emits nothing. wwwroot-src/src/components/controlTree/SoftNcEmptyState.vue — the shared no-runner line both panels open with. wwwroot-src/src/composables/useSoftNcRunner.ts — the shared snapshot the first empty layer reads, and the events that re-read it. wwwroot-src/src/i18n/en/softNc.ts — the two node labels, the two hints, the two absent-table bodies, the two add-field labels, the two invalid-id messages and the error contexts each panel prefixes its toast with. wwwroot-src/src/i18n/en/common.ts — the shared Value column label and the Add / Set button label. Mech/SoftNcRunnerController.cs — the REST surface: the two flag probes in the snapshot builder, the two reads that order rows by ascending id and report presence from the table alone, the two upsert writers with their range guards, the two removers, and the sweep of per-case tables the new runner references through no proxy. HiAPI Engine HiMech/NcParsers/Dependencys/Fanuc/RetainedCommonVariableTable.cs — the #500–#999 store: the range constants, the nullable dictionary that makes vacant a value, the writer that ignores an out-of-range id, the variable lookup that answers only in range, and the serialization that keeps a vacant entry as a valueless element. HiMech/NcParsers/Dependencys/Fanuc/RetainedCommonVariableTableProxy.cs — the seedless get-or-create placeholder the three Fanuc-style presets carry, the bare table it installs into a project holding none, and the legacy element name an older project file still deserializes through. HiMech/NcParsers/Dependencys/Siemens/SiemensRParameterTable.cs — the R0–R999 store: the range constants and the reason the upper one is 999, and the lookup that accepts an uppercase or lowercase R key. HiMech/NcParsers/Dependencys/Siemens/SiemensRParameterTableProxy.cs — the matching seedless placeholder carried by the Siemens preset alone. HiMech/NcParsers/Dependencys/Heidenhain/HeidenhainQParameterTable.cs — the third table of the same shape: the free and permanent Q stores, the ranges each accepts, and the system and volatile ranges it deliberately declines. HiMech/NcParsers/Dependencys/Heidenhain/HeidenhainQParameterTableProxy.cs — its placeholder in the Heidenhain preset, seedless like the other two. HiMech/NcParsers/SoftNcRunner.cs — the five brand presets as literal dependency lists, which is where the mutual exclusion of the two nodes is actually decided, and the proxy resolution every flag probe and every read goes through. HiMech/NcParsers/NcRunnerSuit.cs — the per-case list these tables live in, and its inline serialization beside the runner. HiMech/NcParsers/Dependencys/INcDependencyProxy.cs — the maker-and-taker contract, and why a proxy's resolved table is never written into the runner file. HiMech/NcParsers/ISessionResettable.cs — the session-scoped contract neither table implements, and its own statement of the boundary between session state and persistent state. HiMech/NcParsers/Dependencys/IPowerResettable.cs — the volatile-subset contract a power reset sweeps, which no dependency of any brand preset declares. HiMech/NcParsers/LogicSyntaxs/ProgramEndCleanSyntax.cs — the program-end clear that empties the block's volatile dictionary and names the retained range as untouched. HiMech/NcParsers/EvaluationSyntaxs/VolatileVariableReadingSyntax.cs — the #100–#499 range that has no node here: the per-block dictionary it carries forward, and the session that bounds it. HiMech/NcParsers/Dependencys/Fanuc/FanucPositionVariableLookup.cs and HiMech/NcParsers/EvaluationSyntaxs/Fanuc/FanucSystemControlVariableSyntax.cs — the two #1000-and-up groups no dependency answers: the position variables read from the previous block's record, and the system-control writes recorded on the block rather than emulated. HiMech/NcParsers/EvaluationSyntaxs/RetainedCommonVariableReadingSyntax.cs — the run-time writer for the retained range: the literal assignment it consumes and writes straight into the table, with no mirror kept. HiMech/NcParsers/EvaluationSyntaxs/Siemens/SiemensRParameterReadingSyntax.cs — the same shape for Rn assignments. HiMech/NcParsers/EvaluationSyntaxs/Heidenhain/HeidenhainQParameterReadingSyntax.cs — the same shape for Qn and QRn, routing by id range into the free store, the permanent store, a read-only warning or the volatile dataflow. HiMech/NcParsers/EvaluationSyntaxs/VariableEvaluatorSyntax.cs — the normaliser that resolves a non-literal right-hand side to a literal before the reading syntaxes run, and the lookup chain these tables join. HiMech/NcParsers/EvaluationSyntaxs/Evaluation/IVariableLookup.cs and HiMech/NcParsers/EvaluationSyntaxs/Evaluation/NcExpressionEvaluator.cs — the lookup contract both tables implement, and the vacant failure an expression raises instead of reading zero. HiMech/NcParsers/Syntaxs/FanucSyntaxUtil.cs, HiMech/NcParsers/Syntaxs/SyntecSyntaxUtil.cs, HiMech/NcParsers/Syntaxs/MazakSyntaxUtil.cs, HiMech/NcParsers/Syntaxs/SiemensSyntaxUtil.cs and HiMech/NcParsers/Syntaxs/HeidenhainSyntaxUtil.cs — the five syntax lists, each carrying the reading syntax for its brand's persistent variable range. HiNc/MachiningProcs/LocalProjectService.cs — the facade setter every install and brand switch assigns through, and the power reset that sweeps volatile subsets and then drops the session dataflow. HiNc/MachiningProcs/SessionShell.cs — the scriptable power-reset entry point over that service call. See Also Program Data Plane — the plane both leaves sit on: where their tables are stored, the seedless proxies that make them, and what a brand switch keeps or sweeps beside them"
  },
  "anatomy/general-setup/controller/program-data/siemens-tool-offsets.html": {
    "href": "anatomy/general-setup/controller/program-data/siemens-tool-offsets.html",
    "title": "Siemens Tool Offsets | HiAPI-C# 2025",
    "summary": "Siemens Tool Offsets Siemens Tool Offsets is the Sinumerik $TC_DP ledger — one offset row per cutting edge of a tool, addressed by the tool number and the edge number together — plus the tool-name map that resolves a string tool call to a tool number. It occupies two leaves of the Controller branch on the General Setup page at /general-setup, under the Control-Tree ids equipment/controller/program-data/siemens-tool-offsets and equipment/controller/program-data/tool-names, and those two ids are the whole of what this page owns. Both are grown by one snapshot flag over one backing object, which is why one page carries them. Important Anatomy makes no claim that any id named here is stable across versions. The migration hop that keeps an older ?tree= value resolving is described in Tree Ids and Routes. Both panels follow the branch's shared rules — one read on mount, per-control commit, the capture-assign-await-restore write, the two empty layers, and a dense markup table with no sort and no pagination. Those rules, and the places these two panels depart from them, are Editing Contract. What is these leaves' own is everything below. Two Nodes Over One Table The tree labels differ, the panels differ, and the object behind them does not. Node id Tree label Which half of the object equipment/controller/program-data/siemens-tool-offsets Tool Offsets ($TC_DP) Edges — the offset rows equipment/controller/program-data/tool-names Tool Names ToolNames — the name map The branch builder pushes both inside a single test of the snapshot's Siemens tool-offset flag, so they appear and disappear together and there is no separate tool-name flag anywhere in the snapshot. The flag itself is a type probe for SiemensToolOffsetTable over the proxy-resolved dependency list, and the Siemens preset is the only shipped brand list that carries the proxy for it — Brand Matrix. The same flag does one more thing: it relabels the ungated generic offset leaf one row above from Tool Offsets to Tool Offsets (ISO G43 H), without touching that leaf's id. The two ledgers are present together on a Siemens project and an unqualified label would blur them into one — see Tool Offsets. Each panel reads only its own half. The $TC_DP panel reads and writes rows; the Tool Names panel reads and writes name mappings; neither reports the other's edits, and neither re-reads when the other writes. The presence flag both receive is the same one — whether the table object resolved — so the Tool Names panel's absent-table line, \"No Siemens tool-name table on the active runner.\", names a table that is not a type of its own. The Key Has Two Parts ISiemensToolOffsetConfig addresses an offset by a tool number and a cutting edge number together, where IToolOffsetConfig — the contract behind the generic ledger — takes a single integer. That is the structural difference between the two ledgers, and it is why one tool can carry several rows: a tool with more than one usable edge stores an offset per edge, and the program selects among them with the D word after the tool is mounted. The pair is the dictionary key, and both halves are rendered as bold plain text with a hard-coded letter prefix — T on the tool cell and D on the edge cell. Neither is editable and no rename route exists on either half of the object, so a key cannot be corrected in place. Neither can a chosen one be asked for: the $TC_DP add accepts no target pair — it mints the next tool, or the next edge of the tool it is given — so arriving at a particular pair means growing the table up to it and deleting what was stepped through. Only the tool-name half takes a typed key. That same server-side minting is why nothing on this leaf can create a duplicate. An unconfigured pair is not an error. The interface contract returns 0 for a pair the table has no row for, and the try-form is the only reliable miss signal, because 0 is itself a legal stored offset — a distinction that decides the fallback below. The Columns Ten labelled columns: the two key columns, then eight value columns in millimetres over the four geometry components and their four wear counterparts. Column header $TC_DP index Stored as Read by the pipeline Tool T — the key's tool number the tool the offsets belong to Edge D — the key's edge number the D word Length 1 (Z) 3 Length1_mm the height path Length 2 (X) 4 Length2_mm nothing Length 3 (Y) 5 Length3_mm nothing Radius 6 Radius_mm nothing Length 1 Wear 12 WearLength1_mm the height path Length 2 Wear 13 WearLength2_mm nothing Length 3 Wear 14 WearLength3_mm nothing Radius Wear 15 WearRadius_mm nothing The table declares accessors for all three length components and for the radius, and the shipped pipeline calls exactly one of them: the try-form that returns length 1 plus its wear. The radius accessor and the direction-indexed length accessor are called by nothing in it. Radius compensation reads the generic ledger's radius by a single offset number, so a radius entered here changes nothing that plays. Length 2 and Length 3 are stored, serialized and handed back unchanged, and no consumer reads them. The axis letters in the three length headers are part of the header string and not a binding. Length 1 is the component the height path consumes whatever axis the machine calls it; the other two are indexed positionally by an accessor nothing calls. There is no unit column and no conversion — every field is a plain millimetre double, written and read back as typed. None of the eight numeric cells passes a bound, so a negative value is accepted and stored, which the sign convention below makes load-bearing rather than incidental. The fields the row carries but does not interpret A row also holds VerbatimDpFields, a bag keyed by $TC_DP index for every index outside the eight above. Nothing interprets those values and no cell edits them; they exist so that a full controller dump survives a load and a save unchanged. The panel shows only their count, as a small grey +N beside the row's action buttons with a tooltip explaining that the fields are stored and saved with the project and not used by the simulation. The row write sends the whole row object including that count, and the endpoint assigns only the eight doubles, so the bag survives every edit made here. The two halves stay separate on both sides of serialization. Writing an index into the row routes a consumed index onto its typed property and every other index into the bag, and the serializer filters the consumed indices back out of the bag before writing, so an index cannot end up stored twice and shadow its own typed value on the next load. The element the table writes carries one Edge entry per key with the eight components as named attributes and the bag as DP-indexed ones, and one ToolName entry per mapping; the reader accepts both spellings of a component, so a DP-indexed geometry value lands on the typed property rather than in the bag. The Sign Convention On this table an effective value is the geometry plus the wear. The height the pipeline reads is length 1 added to length-1 wear, and the radius and per-direction accessors add their wear the same way. A positive wear therefore lengthens the compensation, and a tool that has worn shorter is recorded as a negative wear value. The panel states the addition twice: the description above the table ends \"Wear adds onto geometry (enter a shortened tool as negative wear).\", and the footnote below it reads \"All values in mm. Effective length 1 = Length 1 (Z) + Length 1 Wear; same for the other columns.\" Warning The generic ledger one node above uses the opposite convention. On ToolOffsetTable an effective value is the ideal minus the wear — FullHeight_mm is the ideal height less the axial wear and FullRadius_mm the ideal radius less the radial wear — and that panel states no sign rule at all. On a Siemens project both leaves are present at once, so the same wear number typed into the two ledgers moves the tool in opposite directions. See Tool Offsets, which carries this warning from the other side. The two conventions are not a defect to reconcile: each matches the control whose vocabulary its table borrows. What makes the pair sharp is that they meet — the fallback below reads a height out of the subtracting table and uses it where an adding table's height was expected. How a D Word Resolves The Siemens height path consumes a standalone D word from the block and writes the same downstream state as the ISO G43 path: a tool-height compensation section marked with the term D, and a translation of the effective height composed into the program-to-machine transform chain. Both brands' paths compose that entry under one source key and replace it in place, so the two are mutually exclusive on a file that mixes the dialects. Resolution runs in this order. D0 cancels. The section is written with an offset of 0 and an identity transform, with no table lookup and no diagnostic. The active tool number comes from the block's tool-change section, or from the previous block's when this one carries none. A numeric tool id is taken as it stands. A string tool id is resolved through the tool-name map on this same table. An unmapped name raises an unsupported warning and leaves the tool number at 0. The (T, D) pair is looked up here. A configured row answers with length 1 plus its wear. A pair with no row falls back to the generic ledger, described next. A block that carries no D word re-resolves the previous block's edge modally, and only while that previous section is still owned by the D term; a section already claimed by an ISO term on the same block, or carried modally from one, is left to the ISO path. The modal re-resolve deliberately raises no diagnostic — the warnings below are attached to blocks that spell a D word out, so a single missing row reports once instead of on every block that inherits it. What a missing row falls back to For a (T, D) pair this table has no row for — and equally when no Siemens offset table resolves at all — the height is taken from the generic tool-offset table's height for the tool number, through the single-integer contract the ISO G43 H path already reads. Every Siemens runner carries that table, so the fallback always has a source. It exists so that an unfilled per-case $TC_DP table follows the tool-house-fed ledger instead of resolving 0 and machining the whole program one tool length low. Both arms report. A fallback that finds a usable height raises a configuration warning naming the missing pair and the millimetre value it used instead. A fallback that finds NaN — the sentinel the generic ledger's tool-house refresh writes for a tool whose tip length does not resolve — raises a configuration warning of its own and degrades to 0 rather than composing a non-finite translation. Both carry the code SiemensToolOffset--TcdpRowMissing. The fallback crosses the sign boundary. What it reads out of the generic table is that table's own effective height, ideal minus wear; what it substitutes is a $TC_DP height, geometry plus wear. A project that keeps wear in both places therefore compensates in one direction while the row exists here and in the other once it does not. An unresolved tool name reaches the same fallback with the tool number left at 0, and the generic table's own panel cannot create a row 0 — its tool-number cell takes a minimum of 1 and refuses anything below it, and its add route mints from 1 upward — so the height resolves to 0. What the Tool-Name Map Is For Siemens programs may name a tool as a string rather than a number, as in the T=\"D16R3Z6\" form the panel's own hint quotes. The act chain the simulation builds is keyed by integer tool id, so the string has to become a number before anything can use it, and this map is the only surface in the engine that performs that translation. Lookup is case-insensitive: the map is constructed with an ordinal case-insensitive comparer. Two consumers read it, and they fail differently. The tool change itself. The tool-change semantic resolves a string tool id through this map before it emits a tooling step. An unmapped name raises a ToolChange--NameUnresolved warning and emits no step at all, so the tool change is not simulated rather than simulated with the wrong tool. The D word. The height path resolves the same name for its own (T, D) lookup and, on a miss, raises SiemensToolOffset--ToolUnresolved and carries on with tool number 0. Both consumers reach the map through the concrete Siemens table rather than through an interface, so a runner that resolves no such table resolves no tool name either, whatever its brand marker says. The map's own panel is a two-column table over a name and a tool number. The name is the key and is rendered as bold plain text; the tool number is a numeric cell with a minimum of 1. Row order is the server's — the read sorts the keys case-insensitively. The panel never sorts, and its add path re-reads the whole table rather than appending a row locally. Its footer is an Add / Set pair of fields, and the verb is both: the write is an upsert keyed on the name. Entering a name that already exists overwrites that mapping's number instead of adding a second row. Because the underlying dictionary keeps the key it already holds when a value is assigned, a name entered in different casing updates the existing row and the re-read redisplays the casing that was stored first. Row Life Cycle The two leaves spell adding and deleting differently, and the difference is which side mints the key. The $TC_DP table's adds are fieldless toolbar and row buttons, because the server mints both halves of the key. Add Tool in the toolbar sends no tool number and the endpoint takes the highest tool present plus one — or 1 on an empty table — with edge 1. The per-row button, tooltipped \"Add a cutting edge for T{tool}\", sends that row's tool number and the endpoint takes that tool's highest edge plus one. Neither half of the key fills a gap: a deleted middle tool or edge is stepped over rather than reused. Either way the panel appends a locally zeroed row for the returned pair and re-sorts by tool then edge; those zeros mirror the fresh row the server actually inserted rather than standing in as a placeholder. The Tool Names table's add is the footer pair described above, since its key is typed rather than minted. A blank name is refused before any request with \"Tool name must not be empty.\", and a number that is not a positive integer with \"Tool # must be a positive integer.\"; a successful write clears both fields and re-reads the table. The endpoint refuses a blank name a second time. Deletion is guarded on one leaf and not the other. A $TC_DP row opens a confirmation dialog first — Remove tool offset row over \"Remove the offset row for (T{tool}, D{edge})?\" — and the row is filtered out locally once the request resolves; deleting a pair the table no longer holds answers unsuccessfully with a message naming it. A tool name deletes on the click with no dialog and no undo, and a name the map does not hold answers unsuccessfully with a message naming it. Cell edits differ from both. Every numeric cell on the $TC_DP table sends the whole row — all eight components — and rolls back only the one cell it captured on failure. The Tool Names number cell sends the mapping it belongs to. Neither panel commits a cleared cell: an emptied field parses to null and the handler returns before the request, so the box is left blank on screen while the stored number stands and returns on the next remount. The tool-number cell additionally drops a non-integer silently, while a value below 1 is refused inside the numeric widget itself, which marks the box and emits nothing. What Materializes the Table Three of the writes re-wire the runner suit's dependency proxies before resolving the table: the $TC_DP row write, the $TC_DP add, and the tool-name write. The proxy is a get-or-create placeholder, so that wiring installs a bare table into the project's per-case list when it holds none, and the write then lands on a real table instead of answering that one is missing. The reads and the two deletes do not re-wire. Neither panel reports a structural change and neither refreshes the shared snapshot, so a table created by one of those writes does not re-evaluate the flag or regrow the branch. In practice the guard never fires from these leaves: the suit wires its proxies when it is deserialized and on every runner assignment, and the nodes are built only after the flag already read true. When the Tables Are Absent Both leaves carry the branch's two empty layers. The shared one renders \"No NC runner — load a project first.\" while the snapshot reports no runner. Each panel's own read then gates on whether the Siemens table resolved, and renders \"No Siemens tool-offset table on the active runner.\" or \"No Siemens tool-name table on the active runner.\" when it did not. That second layer is not reachable by navigating, because the flag that grows either node is the same probe the reads answer with. It is a live guard for a table that goes away under a mounted panel. A failed write answers inside a success envelope, and the sentence it carries depends on the route. The four that resolve the table through the shared dependency helper — the row upsert, the row delete and the two tool-name routes — answer with the type name, No SiemensToolOffsetTable on the active runner; the $TC_DP add builds its own envelope instead and answers word for word with the $TC_DP panel's own absent-table line. Either way the panel shows its localized context followed by the sentence the server sent. The table is stored on the project rather than in the runner file. It reaches the pipeline as a seedless proxy in the Siemens preset's dependency list and resolves to the concrete table on the project's per-case list, so a controller file saved from the branch root carries none of these rows. A brand switch away from Siemens removes it along with the two nodes, and a switch back creates an empty one rather than restoring what was there — Program Data Plane. Layout General Setup Control Tree — the left dock of /general-setup Controller Node Row Program Data Group Row Tool Offsets ($TC_DP) Node Row — equipment/controller/program-data/siemens-tool-offsets Tool Names Node Row — equipment/controller/program-data/tool-names Editor Row — the panel of whichever node is selected Tool Offsets ($TC_DP) Panel No-Runner Body — \"No NC runner — load a project first.\"; shown instead of everything below Absent-Table Body — \"No Siemens tool-offset table on the active runner.\"; shown instead of the body Description Caption — \"Sinumerik $TC_DP tool offsets, one row per (tool T, cutting edge D). A D1 word in the program reads this table; when a row is missing, playback falls back to the generic Tool Offsets table and reports a warning. Wear adds onto geometry (enter a shortened tool as negative wear).\", with D1 set in code style Toolbar — right-aligned Add Tool Button — primary, add icon Offset Table — dense, flat, bordered Header Row — Tool T, Edge D, Length 1 (Z), Length 2 (X), Length 3 (Y), Radius, Length 1 Wear, Length 2 Wear, Length 3 Wear, Radius Wear, then an unlabelled action column Offset Row, one per (tool, edge) pair, ascending by tool then edge Tool Cell — bold plain text, prefixed T Edge Cell — bold plain text, prefixed D Eight Numeric Fields — the four geometry components, then their four wear components; no bounds and no unit suffix Add-Cutting-Edge Button — flat, playlist_add icon, tooltipped \"Add a cutting edge for T{tool}\" Delete Button — flat, delete icon Verbatim-Field Badge — a grey +N; shown only where the row carries unconsumed $TC_DP fields, tooltipped that they are stored and saved with the project and not used by the simulation Footnote — \"All values in mm. Effective length 1 = Length 1 (Z) + Length 1 Wear; same for the other columns.\" Remove-Row Confirmation Dialog — Remove tool offset row, \"Remove the offset row for (T{tool}, D{edge})?\", with a cancel button Tool Names Panel No-Runner Body — \"No NC runner — load a project first.\" Absent-Table Body — \"No Siemens tool-name table on the active runner.\" Hint Caption — \"Maps the tool names written in the NC program (T=\"D16R3Z6\") to tool numbers. Names are case-insensitive. An unmapped name cannot mount a tool and its D word resolves no offset.\", with the call form and the D word set in code style Name Table — dense, flat, bordered Header Row — Tool Name, Tool #, then an unlabelled action column Name Row, one per mapping, ordered case-insensitively by name Name Cell — bold plain text Tool Number Numeric Field — minimum 1 Delete Button — flat, delete icon, no confirmation Add Row Footer Tool name Text Field Tool # Numeric Field — minimum 1 Add / Set Button — primary; the only submit path, since neither field submits on Enter Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/SoftNcSiemensToolOffsetsPanel.vue — the $TC_DP panel: the eight unbounded numeric cells, the whole-row write with its finite-value guard, the two add buttons and the local append-and-sort, the confirmed delete, and the verbatim-field badge. wwwroot-src/src/components/controlTree/SoftNcToolNamesPanel.vue — the tool-name panel: the plain-text key column, the bounded tool-number cell, the unconfirmed delete, and the Add / Set footer with its two client-side refusals and its full re-read. wwwroot-src/src/components/controlTree/softNcItemTypes.ts — the branch builder: the single flag test that pushes both node ids, their labels and label keys, and the relabel it applies to the generic offset leaf at the same time. wwwroot-src/src/api/softNcRunner.ts — the typed wrappers: the row and mapping shapes with their presence flags, the whole-row upsert, the add that returns a minted pair, the two deletes, and the name-keyed upsert with its URL encoding. wwwroot-src/src/composables/useSoftNcRunner.ts — the shared snapshot behind the first empty layer and behind the tree's flag test. wwwroot-src/src/components/controlTree/SoftNcEmptyState.vue — the shared no-runner line both panels open with. wwwroot-src/src/components/widgets/NumericInput.vue — the numeric cell: commit on blur or Enter, the minimum rejected inside the widget, and the empty-text-to-null parse both panels drop. wwwroot-src/src/components/controlTree/SoftNcToolOffsetsPanel.vue — the neighbouring generic ledger, its subtracting sign rule, and the Siemens caveat it shows from the brand string. wwwroot-src/src/i18n/en/softNc.ts — the two node labels, the description and the hint, the ten column headers, the footnote, the two absent-table lines, the add-strip refusals and the error contexts. wwwroot-src/src/i18n/en/common.ts — the shared Tool # header and the Add / Set label. wwwroot-src/src/i18n/en/dialog.ts — the $TC_DP remove-row dialog's title and message, a different key pair from the generic ledger's. Mech/SoftNcRunnerController.cs — the REST surface: the snapshot probe behind both nodes, the ordered reads whose presence flag is the table object itself, the row upsert that assigns the eight components and leaves the verbatim bag alone, the add that mints a tool or an edge, the two deletes with their refusals, the name upsert with its blank-name refusal, and the proxy re-wire the three writes run first. HiAPI Engine HiMech/NcParsers/Dependencys/Siemens/SiemensToolOffsetTable.cs — the object both leaves edit: the pair-keyed row dictionary, the case-insensitive name map and its lookup, the additive effective values, the row type with its typed components and verbatim bag, and the serializer that keeps a consumed index out of the bag. HiMech/NcParsers/Dependencys/Siemens/ISiemensToolOffsetConfig.cs — the two-key offset contract: the try-form that is the only miss signal, and the direction-indexed and radius accessors nothing calls. HiMech/NcParsers/Dependencys/Siemens/SiemensToolOffsetTableProxy.cs — the seedless get-or-create placeholder the Siemens preset carries, and the bare table it installs into a project holding none. HiMech/NcParsers/SoftNcRunner.cs — the five brand presets, of which only the Siemens list carries that proxy, and the proxy resolution every read of the table goes through. HiMech/NcParsers/NcRunnerSuit.cs — the per-case list this table is stored in, and the proxy wiring the three writes re-run. HiMech/NcParsers/LogicSyntaxs/Siemens/SiemensToolOffsetSyntax.cs — the D path: the cancel arm, the modal ownership rule, the tool-number resolution through the name map, the fallback onto the generic ledger with its two warnings, and the suppression of both on a modal re-resolve. HiMech/NcParsers/LogicSyntaxs/ToolHeightOffsetSyntax.cs — the ISO sibling, and the shared composition of the height as one replaceable entry of the transform chain. HiMech/NcParsers/Semantics/ToolChangeSemantic.cs — the other consumer of the name map: the string tool id it resolves, and the tooling step it declines to emit when the name is unmapped. HiMech/NcParsers/PostLogicSyntaxs/RadiusCompensationSyntax.cs — the radius side, which reads the generic single-integer table rather than this one. HiMech/NcParsers/Dependencys/Generic/ToolOffsetTable.cs — the fallback source: the subtracting effective values, and the zero it answers for an offset number it does not hold. HiMech/NcParsers/Dependencys/Generic/ToolOffsetTableProxy.cs — the placeholder every brand preset carries, which is why the fallback always resolves a table on Siemens. See Also Program Data Plane — the plane both leaves sit on, where this table is stored, and what a brand switch does to it Tool Offsets — the generic ledger one node above, whose label this table's presence changes and whose wear convention is the opposite of the one stated here"
  },
  "anatomy/general-setup/controller/program-data/tool-offsets.html": {
    "href": "anatomy/general-setup/controller/program-data/tool-offsets.html",
    "title": "Tool Offsets | HiAPI-C# 2025",
    "summary": "Tool Offsets Tool Offsets is the Controller branch's brand-neutral offset ledger — one row per integer offset number, each carrying a height and a radius split into an ideal (geometry) component and a wear component. It lives on the General Setup page at /general-setup under the Control-Tree id equipment/controller/program-data/tool-offsets, and that one id is the whole of what this page owns. The leaf is ungated: every brand preset proxies the table behind it, so the node is grown wherever a runner resolves — Brand Matrix. Important Anatomy makes no claim that any id named here is stable across versions. The migration hop that keeps an older ?tree= value resolving is described in Tree Ids and Routes. The panel follows the branch's shared rules — one read on mount, per-control commit, the capture-assign-await-restore write, the two empty layers, and a dense markup table with no sort and no pagination. Those rules, and the places this panel departs from them, are Editing Contract. What is this leaf's own is everything below. One Node, Two Labels The node id never changes, and the tree label does. The branch builder pushes this leaf unconditionally, then chooses its label from the snapshot's Siemens tool-offset flag: Condition Label the tree row reads No SiemensToolOffsetTable resolves Tool Offsets One does Tool Offsets (ISO G43 H) Among the shipped presets only Siemens carries that table, so only Siemens sees the second label — and it sees it beside a second offset leaf, Tool Offsets ($TC_DP), grown from the same flag. The qualifier exists so that the two ledgers do not read as one row of the tree; the id under it is equipment/controller/program-data/tool-offsets either way, so an existing deep link is unaffected by which label is showing. Which flag grows which leaf, and what that flag probes, is Brand Matrix. A second, independent Siemens signal appears inside the panel. While the runner's brand marker reads Siemens, an orange caption sits above the toolbar: \"On Siemens this table serves the ISO G43 H path only — it is not the Sinumerik tool-offset ledger. D tool calls read the Tool Offsets ($TC_DP) table; when a (T, D) row is missing there, playback falls back to this table's height for the tool number and reports a warning.\" The label is chosen from the table flag and the caption from the brand string. Those are computed from different things and can disagree — one of the departures catalogued in Editing Contract. What a Row Holds The table is the Fanuc Memory C layout: the H number and the D number address the same row, so one row carries both the length and the radius of one offset. Column Stores Read by Tool # the offset number, the row's key the H word, the D word, or the Heidenhain tool number Ideal Height (mm) the tool's length before wear the height side Axial Wear (mm) accumulated length wear the height side Ideal Radius (mm) the cutter's radius before wear the radius side Radial Wear (mm) accumulated radius wear the radius side There is no unit column and no unit conversion: ToolOffsetRow stores four plain millimetre doubles, and the panel writes and reads them unchanged. No cell is bounded except the key, which takes a minimum of The panel renders no description caption above its table: the Siemens caveat is the only line it shows there, and the only other prose it carries is the closing caption the tool-house dependence turns on below the table. The key column is the branch's one renameable key, and the rename is guarded on both sides of the wire: the panel refuses a value already present in its own rows with the toast \"Tool id {id} already exists.\" and re-reads the table, and the endpoint refuses the same case with a message naming the existing id. Below 1 never reaches either — the numeric widget rejects the bound itself, marks the box and emits nothing. A non-integer that the widget does emit is dropped by the handler with no request and no message at all. The Sign Convention On this table an effective value is the ideal minus the wear. FullHeight_mm is the ideal height less the axial wear and FullRadius_mm the ideal radius less the radial wear, and those two are exactly what IToolOffsetConfig hands every consumer. A positive wear therefore shortens the compensation and a negative wear lengthens it. Nothing in the panel states this: the four column headers name the components and no footnote names the operation, which is why the rule belongs here. An offset number the table holds no row for is not an error either: both getters answer 0 for it, and neither the ISO height path nor the radius side reports the miss — a mistyped H is a zero-length compensation that plays to the end of the program without a warning. Warning The neighbouring Siemens ledger uses the opposite convention. On SiemensToolOffsetTable an effective value is the geometry plus the wear, and that panel prints the addition in a footnote under its own table. On a Siemens project both leaves are present at once, so one wear number entered in the two ledgers moves the tool in opposite directions. See Siemens Tool Offsets. How the height reaches the machine The height side is consumed as a translation, not as a property of the tool. On a G43 block the ISO tool-height syntax reads the effective height for the H number and composes it into the program-to-machine transform chain as a translation of that many millimetres along the current tool orientation; G44 negates the same number and G49 writes zero. The G43.4 RTCP path reads the same number for the same H word and re-aims it through the machine kinematics. On Heidenhain there is no cancel word: a TOOL CALL block reads the effective height for the tool number and adds the block's DL delta to it, and the result composes into the same chain entry. Nothing on that path reads the tool the project actually carries. The modelled tool assembly's own spindle-buckle-to-tool-tip length is what decides where its tip sits once the machine has moved by the compensation, so the stored ideal height and the modelled tool's length are two independent numbers that have to agree for the programmed contour to land on the workpiece. Making them agree is the entire purpose of the tool-house dependence below, which writes SpindleBuckleToToolTipLength straight into the ideal column. How the radius reaches the path The radius side is read by the G41/G42 radius-compensation syntax against the D number, and it is signed rather than absolute. A negative effective radius — a radial wear larger than the ideal radius — is accepted, and it offsets the path to the opposite of the programmed side. On the first block of a compensation move the parser raises a validation warning for that case on Heidenhain only, mirroring the look-ahead check a TNC control performs; the other brands take it silently. The macro-variable window On the Fanuc, Mazak and Syntec syntax lists a variable lookup maps #2001 through #2200 onto the effective height of offsets 1 through 200, so a macro program can read the same subtraction the G43 path applies. It is a read: the lookup exposes no writer, and neither the Siemens nor the Heidenhain syntax list registers it. Where a blank cell comes from A cleared numeric cell is not a stored value — the panel drops a null or a non-finite edit before sending anything, so clearing a cell leaves the number on the server and the box repopulates on the next remount. A blank cell that arrives from the server is a different thing: it is NaN, which the numeric widget renders as empty text. The tool-house refresh is what writes one, for a tool whose tip length does not resolve. Only the Siemens $TC_DP fallback tests for it — a NaN height there is reported as a configuration warning and degrades to zero — while the ISO G43 path composes whatever the table returned. Tool-House Dependence Above the table sits the toggle Set ideal offset dependent on tool house. It is the one setting this leaf edits that is not a dependency at all: it writes IsIdealOffsetDependentOnToolHouse, a project-level element serialized beside the runner suit, so it is untouched by a runner install and by the sweep that follows a brand switch. Its stored default is on; the reader answers off when no project is loaded, which is a fallback rather than the model's own default. With the dependence on, the panel hands three things over: The two ideal columns become read-only, and a closing caption says so: \"Ideal columns mirror the Tool House; only the wear columns are editable.\" Read-only is a screen guarantee only — the write is row-scoped, so the ideal values ride along on every wear edit, and the endpoint writes all four components unconditionally. That the two ideal cells still commit on Enter is one of the panel's catalogued departures from Editing Contract. The Tool # cell is replaced by bold plain text, so the key cannot be renamed. Row CRUD disappears: the Add button is not rendered and each row's delete button becomes a grey em dash. A Refresh from Tool House button appears next to the toggle in their place. The table does not otherwise track the tool library Offset number and tool id are independent integers, and with the dependence off nothing reconciles them. A row may name a number the project's tool library has never held, and the library may hold tools with no row; neither state is reported anywhere on this panel, and both are stored and played as written. The library itself is edited on Tool House Page. The refresh is what imposes a one-to-one mapping, and it does so in both directions. The refresh is destructive, and it is not only a button One endpoint backs both the button and the toggle, and it runs three steps. For every tool in the project's library it writes the ideal height from that tool's spindle-buckle-to-tool-tip length — NaN where the length does not resolve — and, where the cutter is a milling cutter, the ideal radius from the largest radius on its cutter profile; a row is created for a library tool that had none. It then deletes every row whose number is not in the library. The wear columns are never touched. The engine carries the same three steps of its own, as UpdateIdealByToolHouse(API), and that copy is what playback calls. The two agree step for step and part company only on a missing library: the engine method returns without doing anything, while the endpoint answers unsuccessfully with “No tool house available”. Three consequences deserve stating plainly. There is no confirmation. The dialog that guards a single delete button does not guard this, and there is no undo. Turning the toggle on runs it immediately. Enabling the dependence is two server calls in one attempt: the flag write, then the refresh. A project with no tool library fails the second with “No tool house available” after the first has already committed, and the panel's local toggle springs back while the server-side flag stays on — the two-call rollback recorded in Editing Contract. Turning the toggle off writes the flag and stops there — no refresh, and no re-read. Playback runs it too. While the flag is on, starting an NC program refreshes the table from the library before the first block, so a hand-typed ideal value is replaced whether or not the panel was ever opened, and an empty library at that moment empties the table. No panel is told: what is on screen is whatever the last read returned until the selection moves away and back. Row Life Cycle The add and the delete are the two flows the branch spells one way here and another way elsewhere. Add is a fieldless toolbar button, because the server mints the key: the endpoint takes the highest existing number plus one — or 1 on an empty table — inserts an all-zero row and returns the number, and the panel appends that row locally rather than re-reading. All four zeros are the server's actual new-row values, not a screen placeholder. Delete opens a confirmation dialog first, titled Remove tool offset over \"Remove the offset row for tool #{id}?\", and filters the row out locally once the request resolves. Deleting a number the table no longer holds answers unsuccessfully with a message naming it. Rename is optimistic and re-sorts the rows ascending once the write returns; a failure restores the previous number. Every other cell is a per-cell handler that sends the whole row. When the Table Is Absent The leaf carries both of the branch's empty layers. The shared one renders \"No NC runner — load a project first.\" while the snapshot reports no runner. The panel's own read then gates on whether a ToolOffsetTable resolved, and renders \"No tool-offset table on the active runner.\" when it did not — which hides the dependence toggle along with the table, since the whole body sits behind that guard. A failed write answers inside a success envelope. The row write, the delete, the rename and the refresh all go through the branch's shared dependency helper and carry No ToolOffsetTable on the active runner, which the panel shows as its own context followed by that sentence. Add does not use that helper: it tests the table itself and answers No tool-offset table on the active runner — the panel's own absent-table line, less its full stop. The dependence write reaches neither string, because what it writes is a project-level element rather than the table; it is the one route on this leaf that answers a coded payload instead, and it reports no project loaded. That second layer is hard to reach. ToolOffsetTableProxy is a seedless get-or-create placeholder: on wiring it installs a bare table into the project's per-case list whenever the project holds none, and the suit wires its proxies when it is deserialized and again on every runner assignment. Layout General Setup Control Tree — the left dock of /general-setup Controller Node Row Program Data Group Row Tool Offsets Node Row — equipment/controller/program-data/tool-offsets; reads Tool Offsets (ISO G43 H) while a Siemens $TC_DP table resolves Editor Row — the panel of whichever node is selected Tool Offsets Panel No-Runner Body — \"No NC runner — load a project first.\"; shown instead of everything below Absent-Table Body — \"No tool-offset table on the active runner.\"; shown instead of the body Siemens Caveat Line — orange caption, shown while the brand marker reads Siemens, with G43 H and D set in code style Toolbar Set ideal offset dependent on tool house Toggle Refresh from Tool House Button — flat, refresh icon; only while the dependence is on Add Button — primary, add icon, right-aligned; only while the dependence is off Offset Table — dense, flat, bordered Header Row — Tool #, Ideal Height (mm), Axial Wear (mm), Ideal Radius (mm), Radial Wear (mm), then an unlabelled action column Offset Row, one per offset number, ascending Tool Number Cell — a numeric field with a minimum of 1, or bold plain text while the dependence is on Ideal Height, Axial Wear, Ideal Radius and Radial Wear Numeric Fields — the two ideal ones read-only while the dependence is on Delete Button — or a grey em dash while the dependence is on Dependent Footnote — \"Ideal columns mirror the Tool House; only the wear columns are editable.\"; only while the dependence is on Remove-Row Confirmation Dialog — Remove tool offset, \"Remove the offset row for tool #{id}?\", with a cancel button Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/SoftNcToolOffsetsPanel.vue — the panel: the dependence toggle and its two-call enable, the refresh button, the read-only ideal columns, the renameable key with its duplicate guard, the confirmed delete, the locally appended add, and the Siemens caption gated on the brand string. wwwroot-src/src/components/controlTree/softNcItemTypes.ts — the branch builder: this leaf's id, its two labels and label keys, and the snapshot flag that switches between them. wwwroot-src/src/api/softNcRunner.ts — the typed wrappers: the row shape with its presence and dependence flags, the whole-row write, the add that returns a minted number, the rename, the delete, and the refresh call. wwwroot-src/src/components/widgets/NumericInput.vue — the numeric cell: commit on blur or Enter, the minimum rejected inside the widget, the empty-text-to-null parse the panel drops, and the NaN that renders as an empty box. wwwroot-src/src/components/controlTree/SoftNcEmptyState.vue — the shared no-runner line the panel opens with. wwwroot-src/src/composables/useSoftNcRunner.ts — the shared snapshot behind that first guard and behind the tree's choice of label. wwwroot-src/src/components/controlTree/SoftNcSiemensToolOffsetsPanel.vue — the neighbouring ledger on Siemens, and the footnote in which it states the opposite sign rule. wwwroot-src/src/i18n/en/softNc.ts — the two node labels, the Siemens caveat, the four column headers, the dependent footnote, the duplicate-key toast, the absent-table line and the panel's error contexts. wwwroot-src/src/i18n/en/common.ts — the shared Tool #, Add, toggle and refresh labels. wwwroot-src/src/i18n/en/dialog.ts — the remove-row dialog's title and message. Mech/SoftNcRunnerController.cs — the REST surface: the reader with its presence and dependence flags, the whole-row write, the add that mints the next number, the delete and the rename with their refusals, the project-level dependence write, and the refresh with its drop of rows the library no longer holds. Common/ApiError.cs — the coded no-project payload the dependence write answers with, the one answer on this leaf that can be re-rendered in the application locale. HiAPI Engine HiMech/NcParsers/Dependencys/Generic/ToolOffsetTable.cs — the ledger itself: the four stored components, the subtraction that makes an effective value ideal minus wear, the integer-keyed row dictionary, and the tool-house update with its row creation and its row removal. HiMech/NcParsers/Dependencys/Generic/ToolOffsetTableProxy.cs — the seedless get-or-create placeholder every brand preset carries in place of the table, and the bare instance it installs into a project holding none. HiMech/NcParsers/Dependencys/IToolOffsetConfig.cs — the single-integer offset contract the consumers read through, and the pointer to the Siemens tool-and-edge contract beside it. HiMech/NcParsers/Dependencys/Siemens/SiemensToolOffsetTable.cs — the neighbouring ledger, and the addition that makes its effective values geometry plus wear. HiMech/NcParsers/SoftNcRunner.cs — the five brand presets, each of which carries the tool-offset proxy, and the proxy resolution every read of the table goes through. HiMech/NcParsers/LogicSyntaxs/ToolHeightOffsetSyntax.cs — the ISO height path: the H word, the G43 / G44 / G49 arms, and the translation along the tool orientation both brand siblings compose through. HiMech/NcParsers/LogicSyntaxs/G43p4RtcpSyntax.cs — the RTCP path that reads the same height for the same H word and re-aims it through the kinematics. HiMech/NcParsers/LogicSyntaxs/Heidenhain/HeidenhainToolOffsetSyntax.cs — the TOOL CALL path: the tool number as the offset id, the DL delta added to the table height, and the absence of a cancel word. HiMech/NcParsers/LogicSyntaxs/Siemens/SiemensToolOffsetSyntax.cs — the D path's fallback onto this table when the $TC_DP map has no row, its warning, and the NaN case it degrades to zero. HiMech/NcParsers/PostLogicSyntaxs/RadiusCompensationSyntax.cs — the radius side: the D word, the signed offset that flips the compensated side when it goes negative, and the Heidenhain-only warning for that case. HiMech/NcParsers/Dependencys/Fanuc/FanucToolOffsetVariableLookup.cs — the read-only macro window onto the effective heights, and the address range it answers for. HiMech/NcParsers/Syntaxs/FanucSyntaxUtil.cs, HiMech/NcParsers/Syntaxs/MazakSyntaxUtil.cs and HiMech/NcParsers/Syntaxs/SyntecSyntaxUtil.cs — the three syntax lists that register that window. HiMech/MachiningProcs/MachiningActRunnerConfig.cs — the tool-house dependence flag, its stored default and the element the project serializes it as. HiMech/MachiningProcs/MachiningSession.cs — the play loop's refresh of the table from the library before the first block, run whenever the flag is on. HiMech/Machining/MachiningToolHouse.cs — the tool-id-keyed library the refresh walks. HiMech/Machining/IMachiningTool.cs — the tool contract the library's entries answer to, and where the spindle-buckle-to-tool-tip length the refresh reads is declared. HiMech/Milling/MillingTools/MillingTool.cs — the assembly walk behind that length, and the NaN it answers when the walk does not resolve. HiNc/MachiningProcs/LocalProjectService.cs — the facade that owns the library and the runner suit, and the entry point the play-time refresh reaches this table through. HiNc/MachiningProcs/MachiningProject.cs — where the library, the runner configuration and the suit hang off the project, and the load path that leaves the library unset when the project file names none. See Also Program Data Plane — the plane this leaf sits on, where its table is stored, and what a brand switch does to the tables beside it Siemens Tool Offsets — the $TC_DP ledger that appears next to this one on Siemens, and whose wear convention is the opposite of the one stated above"
  },
  "anatomy/general-setup/controller/program-data/work-coordinates.html": {
    "href": "anatomy/general-setup/controller/program-data/work-coordinates.html",
    "title": "Work Coordinates | HiAPI-C# 2025",
    "summary": "Work Coordinates Work Coordinates is the Controller branch's G54 ledger: one table of coordinate ids against an X / Y / Z machine offset, edited through whichever offset provider the active runner resolves. It lives on the General Setup page at /general-setup under the Control-Tree id equipment/controller/program-data/work-coordinates, reached as ?tree=equipment/controller/program-data/work-coordinates, and no snapshot flag gates it — every runner grows it. The face is the same on all five brands; what sits behind it is a different object on each, and on two of them that object is also the subject of a node of its own. Important Anatomy makes no claim that any id named here is stable across versions. The migration hop that keeps an older ?tree= value resolving is described in Tree Ids and Routes. The Discriminator The panel does not probe the runner. It reads one field of the shared runner snapshot, workCoordinateKind, and uses it for exactly one thing: the grey caption above the table. The field is a type switch over the first IIsoCoordinateConfig in the runner's proxy-resolved dependency list, and it has six arms. Arm Provider matched Brands that reach it Caption the panel shows fanuc FanucParameterTable Fanuc, Mazak \"Stored in the Fanuc parameter table (#5221+ / #7001+).\" syntec SyntecParameterTable Syntec \"Stored in the Syntec parameter table (Pr5221+ / Pr7001+).\" siemens SiemensFrameTable Siemens \"Stored as Siemens settable frames ($P_UIFR; G500 cancels and is always zero).\" heidenhain HeidenhainDatumTable Heidenhain \"G54–G59 map onto Heidenhain datum preset rows 1–6.\" generic any other implementer, i.e. IsoCoordinateTable none \"Brand-neutral work-coordinate table.\" none nothing resolved none \"Brand-neutral work-coordinate table.\" Two arms answer for no shipped preset, and they answer alike because the caption's switch falls through to one default for both. generic needs the brand-neutral table to be the FIRST provider the runner resolves. The Fanuc, Mazak and Syntec presets do carry that table — seeded with the nine G59.x ids — but always behind their brand table, so the arm is reachable only from a runner composed by hand or deserialized from a file that put the brand-neutral table first. Which brand carries which dependency is Brand Matrix. none has two producers, and a different guard stops each of them. The snapshot's early return leaves the field's default in place when no runner resolves at all — the same string the client's empty snapshot carries — and the shared no-runner guard then replaces the whole body. The type switch's own null arm answers none for a runner that does resolve but carries no offset provider; that state reports a runner, so what replaces the body is the absent-table guard instead, because the lookup that answered none is the one the panel's own read reports absent. Neither path reaches the caption. The brand marker plays no part here. workCoordinateKind is derived from the resolved object's type, while the badge on the branch root reads a free-form string, so a marker edited to say something else changes the badge and leaves this caption exactly where it was. The Row Inventory Every row is one id from the provider's own id enumeration, and each provider enumerates a different set. That is the whole reason the row counts differ: the endpoint asks the resolved provider what ids it has and fills each row from its offset accessor, substituting a zero triad for a null answer. Brand Provider Ids enumerated Always visible Hidden while all-zero Fanuc, Mazak Fanuc parameter table, then the extended table G54–G59, G54.1P1–G54.1P48; G59.1–G59.9 the six G5x rows and the nine G59.x rows the 48 G54.1P rows Syntec Syntec parameter table, then the extended table G54–G59, G54.1P1–G54.1P48; G59.1–G59.9 the six G5x rows and the nine G59.x rows the 48 G54.1P rows Siemens Siemens frame table G54–G57, G505–G599 the four G5x rows the 95 G5xx rows Heidenhain Heidenhain datum table G54–G59 all six none — brand-neutral table (standalone) G54–G59, G59.1–G59.9 all fifteen none The extended table on the three ISO presets is the brand-neutral table seeded with the nine G59.x ids only; a standalone brand-neutral table (a runner built without a brand table) seeds all fifteen. Three consequences of that column are worth reading twice. Siemens seeds no G58 and no G59 row. The frame table's constructor seeds G54, G55, G56 and G57 plus the extended G505–G599 series, and nothing else, and no panel on the branch can add an id to the set. A G58 in a Siemens program resolves through the same ISO path as on any other brand, finds no frame, and falls back to a zero offset. Fanuc and Syntec enumerate an id only while at least one of its three parameter addresses is present. IsoCoordinateAddressMap maps G54–G59 onto #5221 with a stride of 20 and G54.1 P1–P48 onto #7001 with the same stride, three consecutive addresses per entry, and both brand tables seed all 162 of them with zero at construction. So all 54 rows exist from the first read; the enumeration rule bites only a table whose addresses have been removed. Native Parameters is the surface that removes one — its row delete drops a system-parameter address outright, and dropping all three of an entry's addresses removes that row from this leaf. The same form is where those addresses are visible under their own numbers, each annotated with the component it holds. Heidenhain shows six ids for a twenty-row table. The datum table seeds preset rows 1–20 and shift rows 1–20, and its ISO face aliases only preset rows 1–6 onto G54–G59. Rows 7–20, and every shift row, have no id here at all. G500 is a row on no brand. The frame table treats it as the cancel frame: reads answer a zero offset, a write through the coordinate accessor is dropped, and it is deliberately not stored in the frame dictionary, so it never reaches the id enumeration — which is why the Siemens caption names a code the table below it never shows. Two Nodes, One Table Warning On Siemens and on Heidenhain this leaf is a second face on an object that already has a node of its own. The Siemens frame table is edited here and under Frames (Siemens); the Heidenhain datum preset table is edited here and under Datum Presets (Q339). These are not two copies kept in step — they are one instance, and a write through either node lands in the same cell. The aliasing is exact, and its two halves are addressed differently. Siemens. This leaf reads and writes through the ISO interface, so the payload is keyed by the G-code id. Frames reads and writes the frame dictionary directly, keyed by the same string. Both panels render the same id set with the same values, and a G54 edit made on either is the same assignment. The two routes part on one id only: this leaf's write goes through the coordinate accessor and drops a G500, where the frame route would assign it into the dictionary — an id neither panel ever sends. Nor are the three value columns the whole of what the frame table holds: they are the X / Y / Z translation, while the translation components for other axis letters live in a second dictionary that only the $P_UIFR bridge writes and neither panel exposes. What does differ between the two panels is furniture — this leaf carries the Actions column with P0 and M0, and Frames has no counterpart for it. Heidenhain. This leaf's G54…G59 rows are preset rows 1–6. Datum Tables shows the same six cells under the Q339 column, alongside rows 7–20 and the whole datum-shift table, which this leaf cannot reach. So the aliasing is one-directional in coverage: everything on this leaf is on that one, and most of that one is not here. Nothing in the branch reconciles the two views while both are in scope, and nothing needs to: the editor row mounts one panel at a time and each panel fetches once on mount, so moving the selection from one node to the other is itself the refresh. What that costs, and what a mounted panel therefore never sees, is Editing Contract. Which Rows Show A row is always visible when its id reads G5, one digit in 4–9, and optionally a dot and one more digit. Every other row is hidden unless one of its three values is non-zero, or the Show all toggle is on. That rule is the panel's own regular expression, evaluated in the browser over the rows the read returned; nothing about it reaches the server. The toggle itself is conditional. It renders only while at least one row fails the always-visible test, so it is present on Fanuc, Mazak, Syntec and Siemens and absent on Heidenhain — and absent on the brand-neutral table too, whose fifteen ids all pass. The Frames leaf carries the same toggle unconditionally and applies a narrower always-visible test of its own, G54 through G57; on the Siemens table the two tests keep the same four rows visible, so only the toggle's presence differs. Editing a Row Every value cell is the shared numeric field, so it commits on blur or on Enter and never per keystroke — its parsing, its bounds behaviour and the double commit that follows Enter are Numeric Input. No cell here passes a minimum or a maximum, and the id column is plain bold text that cannot be edited. The write is the whole row. A commit assigns the new number into the local row, then sends that row's x, y and z as they now stand to the row's id. A failure restores the one component the handler captured and raises the branch's standard toast; the request that failed carried all three. A cleared cell parses to null, and a cell holding NaN or an infinity parses to a non-finite number; the handler returns before the request in both cases, so neither empties a stored offset. The cell keeps showing what the field made of the text — blank for a cleared cell and for NaN, the literal Infinity or -Infinity for an infinity — until the panel is remounted. Where that row lands differs by provider, and this is the point at which the uniform face ends. Fanuc, Mazak and Syntec write three consecutive parameter addresses, all three unconditionally. Siemens replaces the frame entry for that id. Heidenhain replaces the preset row the id aliases onto. The Fanuc-family and Heidenhain writes silently drop an id they do not map: the Fanuc-family write resolves the address first and does nothing without one, and the Heidenhain write matches the id against its two recognised forms. The Siemens frame table and the brand-neutral table do the opposite — an id they have never held is stored as a new row, the frame table refusing only G500. Neither behaviour is reachable from this leaf, because the panel only ever sends an id the same provider enumerated. P0 and M0 Two flat buttons sit in the Actions column of every row and write the whole triad in one call. M0 sets the row to machine zero. P0 sets it to the machine coordinate at which the workpiece's program-zero anchor sits with every dynamic axis of the equipment assembly — not only the machining chain's — stepped to zero, falling back to the machining chain's table buckle when the workpiece declares no program-zero anchor. Both re-read the whole table on success rather than patching the local row, so a value the provider stored differently from what was sent is picked up at once. Neither is confirmed. P0 carries a failure of its own that no other write in the branch produces: with no chain resolving a tool buckle the position is null, and the endpoint answers unsuccessfully with “Could not get the machine position at program zero” before it ever reaches the offset provider. The Canvas Marker Clicking a row also chooses which coordinate the General Setup canvas draws its triad on. That is the one write in this branch addressed to another surface, and it behaves differently from the rest in four ways worth naming. Where it is stored. The id goes to the equipment-display surface, which assigns it on the shared user configuration and schedules a debounced save of that file. It is device state, not project state: it is not written into the project, it outlives the project that set it, and a failure of the file write itself is logged rather than reported. What reads it. The canvas marker resolves the first IIsoCoordinateConfig on the active runner — the same object this panel edits — so an offset edited here moves the marker on the next frame. A marked id the provider does not answer draws nothing at all, which is the state after a brand switch leaves behind an id the new provider has never heard of. The marker is also suppressed while its Scene flag is off, and while no machining chain resolves an anchor. How it fails. The handler follows the same optimistic shape as a cell commit — assign, await, restore and toast on failure — but it is the branch's one call through the plain-JSON helper rather than the envelope helper, so only a non-2xx status throws there. On mount the panel seeds its highlight from the same surface and swallows any failure, so an unhighlighted table is not evidence that nothing is marked. What triggers it. The click handler is bound on the whole row and nothing inside the row stops propagation, so editing a cell or pressing P0 or M0 marks that row as well as doing its own work. A click on the row already marked returns immediately, which is what keeps repeated cell edits on the marked row from re-writing the user configuration on every pass. The highlight is a tinted row background, and the row carries the native tooltip “Click to mark this coordinate on the General Setup canvas”. What a Brand Switch Carries The brand switch is the one operation in the branch that treats work coordinates specially. Its panel carries a checkbox, Carry work-coordinate XYZ (G54…) into the new brand's table, ticked by default, and the flag reaches the endpoint with the brand. With it set, the offsets are read from the outgoing provider before the preset is swapped in, and written into the incoming one afterwards — but only for the ids the incoming provider already enumerates, and only when the two providers are different instances. Everything else is dropped. So the carry is lossy in a shape that follows directly from the inventory above: Fanuc to Siemens keeps G54 through G57 and loses G58, G59 and all 48 extended entries; Siemens to Fanuc keeps the same four and loses the whole G505 series; a switch to Heidenhain keeps at most six. The instance guard matters on the pair that shares a table. Mazak and Fanuc proxy the same parameter table, so a switch between them resolves the same instance on both sides and the carry is skipped as redundant — the values are already there. What a switch keeps, resets and destroys elsewhere is Brand Switch. What the Rows Feed A work-coordinate word in a program is resolved into a translation composed onto the block's program-to-machine transform. Two details of that path do not match what this panel shows. The run-time lookup walks every provider; so does the panel. The resolver iterates all offset providers in the effective list and takes the first non-null answer, which is what lets a brand table cover its hardware-mapped ids while a second provider covers ids the brand table does not map — the shape the Fanuc, Mazak and Syntec presets ship in, with the extended G59.1–G59.9 on a brand-neutral table behind the brand table. The panel lists every provider's ids in the same order (the first provider that holds an id wins) and writes an edit to the provider that enumerates the id; the snapshot's kind field still names the first provider only, which is why the caption reads “Fanuc parameter table” above rows the second table holds. The 48 extended rows are reached by G54.1 Pn — and by G54 Pn. The ISO coordinate syntax reads G54–G59 and G59.1–G59.9 from the block's parsed flags, and the additional work coordinate systems from the G54.1 P capture the parsing bundle writes as a sub-object; both spellings Fanuc's manual gives that chapter (“G54.1 or G54”) land in that capture, with or without a space before the P word, so G54 P48 and G54P48 select row 48 exactly as G54.1 P48 does. A G54 with no P word in its scope stays the plain G54 flag. The row's id is the un-padded G54.1P48, the same key the Fanuc-family table maps to #7001+, so on Fanuc, Mazak and Syntec the extended rows this panel edits are the rows the program selects. A row that is selected but was never entered — the brand tables seed every extended row with zero, as a fresh-battery controller reads them — reports Coord-WorkOffset--AdditionalZero on the selecting block; the program then runs on the machine origin, which is almost never what a pallet or fixture offset meant. A zero G54–G59 stays silent: it is a common authoring convention. The Fanuc-family table is also the macro variable lookup, so on Fanuc and Mazak those rows read back from a macro program as #7001–#7999, alongside G54–G59's own #5221–#5328; the Syntec table implements no variable lookup, so on Syntec the rows are reached by the coordinate words only. The extended G59.1–G59.9 ids live on a second table behind the brand table. The Fanuc-family tables map G54–G59 and the 48 additional rows and nothing else, so the Fanuc, Mazak and Syntec presets mount a brand-neutral coordinate table holding only G59.1–G59.9 right behind their brand table. The two id sets are disjoint, the run-time lookup finds each id on the one provider that holds it, and this leaf shows the nine rows among the others and writes each edit to the provider that carries the id. Those rows are seeded with zero and, like G54–G59 and unlike the 48 additional rows, a zero one stays silent: leaving a row of the standard series at zero is a common authoring convention. A project that kept a G59.x value in its legacy coordinate table carries it into this second table when the legacy table migrates (each row lands on the provider that carries its id). A controller saved before the second table existed gains it on load; one that lost it resolves no offset for a G59.x at all and reports Coord-WorkOffset--NoTableEntry instead. Which row an untagged program starts on is the brand preset's static initializer, and the three answers differ. Preset Initial coordinate id Effect Fanuc, Mazak, Syntec G54 the G54 row is active from the first block Siemens G500 no frame is active; the offset is zero until a frame word appears Heidenhain none no coordinate section is seeded; the datum cycles set one On Heidenhain the program's own route into the same table is the datum cycle rather than a G word: a preset cycle reads the preset row its number names and writes a synthetic coordinate id that the table resolves back, which is how rows 7–20 are consumed at run time despite having no row on this leaf. A word or a cycle that resolves no offset composes a zero translation rather than failing. Layout General Setup Control Tree — the left dock of /general-setup Controller Node Row Program Data Group Row — equipment/controller/program-data Work Coordinates (G54…) Node Row — equipment/controller/program-data/work-coordinates Editor Row — the panel of whichever node is selected Work Coordinates (G54…) Panel No-Runner Body — \"No NC runner — load a project first.\"; the shared empty state, shown instead of everything below while the snapshot reports no runner Absent-Table Body — \"No work-coordinate table on the active runner.\"; shown instead of everything below while the panel's own read reports no provider Header Strip Storage Caption — the one-line note for the snapshot's coordinate kind, left-aligned and grey Show all Toggle — right-aligned, dense; rendered only while a row exists that the always-visible test rejects Coordinate Table — dense, flat, bordered; no sort, no pagination, no column menu Header Row — Id, X (mm), Y (mm), Z (mm), Actions. The three axis headers are literals in the template; Id and Actions are the shared translated labels Coordinate Row, one per visible id — the whole row is clickable and carries the tooltip “Click to mark this coordinate on the General Setup canvas”; the marked row is tinted Id Label — bold plain text, never editable Value Numeric Field, one per axis column — no minimum, no maximum, no unit suffix P0 Button — flat, dense, tooltip “Set to the machine position at program zero” M0 Button — flat, dense, tooltip “Set to machine zero” Toast — negative, three seconds, the panel's context followed by the server's own message The panel carries no heading, no save button, no unsaved marker and no dialog, and it reports no structural change, so no edit made on this leaf rebuilds the branch. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/SoftNcWorkCoordinatesPanel.vue — the panel: the storage caption's five-way switch, the always-visible test and the conditional Show all toggle, the whole-triad cell commit with its non-finite guard, the P0 / M0 actions and their re-read, and the row click that writes the canvas marker. wwwroot-src/src/components/controlTree/softNcItemTypes.ts — the branch builder: this leaf's node id and label key, and its position as the first ungated member of the program-data stem. wwwroot-src/src/components/controlTree/SoftNcEmptyState.vue — the shared no-runner line the panel opens with. wwwroot-src/src/components/widgets/NumericInput.vue — the value cell: commit on blur or Enter, the empty-text-to-null parse, and the infinity and NaN literals the panel's handler then rejects. wwwroot-src/src/api/softNcRunner.ts — the snapshot's coordinate-kind field and its parser, the work-coordinate reader and its row shape, the whole-triad setter, the two zeroing actions, and the brand switch's carry flag. wwwroot-src/src/api/equipmentSetup.ts — the canvas marker id: the getter the panel seeds its highlight from and the setter the row click writes, on the equipment-display surface rather than this branch's own. wwwroot-src/src/api/http.ts — the two helpers this panel mixes: the envelope helper every table call uses, and the plain-JSON helper the marker call uses. wwwroot-src/src/composables/useSoftNcRunner.ts — the shared snapshot the coordinate kind and the no-runner guard are read from. wwwroot-src/src/components/controlTree/SoftNcFramesPanel.vue — the other node on the Siemens frame table: the same rows through the frame-keyed reader, with an unconditional toggle and a narrower always-visible test. wwwroot-src/src/components/controlTree/SoftNcDatumTablePanel.vue — the other node on the Heidenhain datum table: the preset rows this leaf aliases, plus the rows and the shift table it does not reach. wwwroot-src/src/components/controlTree/SoftNcBrandPanel.vue — the carry checkbox and its default. wwwroot-src/src/i18n/en/softNc.ts — the node label, the two empty bodies, the five storage captions, the row and button tooltips, and the five error contexts. wwwroot-src/src/i18n/en/common.ts — the shared Id and Actions column headers and the Show all label. Mech/SoftNcRunnerController.cs — the REST surface: the coordinate-kind type switch in the snapshot builder, the reader that enumerates the provider's ids and zero-fills a null offset, the whole-triad writer, the two zeroing actions with the program-zero lookup's own failure message, and the brand switch's capture-swap-carry-sweep with its accepted-id filter and its instance guard. Mech/EquipmentSetupDisplayController.cs — the marker id's reader and writer, the user-config slot it lands in, and the debounced save that follows. Disp/EquipmentSetupDisplayee.cs — the marker's binding to the first offset provider on the active runner, and the guards that drop it with no chain or with its Scene flag off. Disp/EquipmentSetupDisplayeeConfig.cs — the stored marker id, its G54 default and its serialization. Environments/UserService.cs — the loose save behind the marker write, and the failure it logs rather than returns. HiAPI Engine HiMech/NcParsers/Dependencys/IIsoCoordinateConfig.cs — the offset-provider contract: the id-keyed get and set, and the id enumeration every row of this leaf comes from. HiMech/NcParsers/Dependencys/IsoCoordinateAddressMap.cs — the Fanuc-family address scheme shared by the Fanuc and Syntec tables: the two base addresses and the stride, the read that treats an entry with no address as absent, the write that lays down all three, the enumeration this leaf's rows follow, the per-address description the native form annotates with, and the seeding of every entry with zero. HiMech/NcParsers/Dependencys/Fanuc/FanucParameterTable.cs — the Fanuc and Mazak provider: its offset accessors over the address map, its default table, and the variable lookup that also exposes the same addresses to a macro program. HiMech/NcParsers/Dependencys/Syntec/SyntecParameterTable.cs — the Syntec provider: the same address scheme without the variable lookup. HiMech/NcParsers/Dependencys/Siemens/SiemensFrameTable.cs — the Siemens provider: the seeded G54–G57 and G505–G599 ids, the cancel-frame handling that keeps one code out of the row set, and the per-axis translation dictionary neither panel exposes. HiMech/NcParsers/Dependencys/Heidenhain/HeidenhainDatumTable.cs — the Heidenhain provider: the twenty preset and twenty shift rows, the G54–G59 alias onto preset rows 1–6, and the synthetic ids the datum cycles resolve through. HiMech/NcParsers/Dependencys/Generic/IsoCoordinateTable.cs — the brand-neutral table behind the generic arm, and the fifteen ids it seeds. HiMech/NcParsers/Dependencys/Generic/IsoCoordinateTableProxy.cs — its get-or-create proxy, the other shape a runner can carry it in. HiMech/NcParsers/Dependencys/Siemens/SiemensFrameTableProxy.cs, HiMech/NcParsers/Dependencys/Heidenhain/HeidenhainDatumTableProxy.cs — the seedless proxies those two brands carry: each installs a fresh table into a project holding none, which is why those two brands open on their constructors' defaults. HiMech/NcParsers/Dependencys/Fanuc/FanucParameterTableProxy.cs — the seeded proxy the Fanuc and Mazak presets share, and the reason those two resolve one instance. HiMech/NcParsers/SoftNcRunner.cs — the five brand presets and the offset provider each carries, the proxy resolution every read goes through, and the legacy import that replays an older coordinate table into whichever provider resolves. HiMech/NcParsers/LogicSyntaxs/CoordinateOffsetUtil.cs — the run-time resolver that walks every provider and takes the first non-null answer, and the translation it composes. HiMech/NcParsers/LogicSyntaxs/IsoCoordinateOffsetSyntax.cs — the G-word path: the flag vocabulary it consumes, the modal lookback that keeps a coordinate alive across blocks, and the zero fallback when nothing answers. HiMech/NcParsers/LogicSyntaxs/Heidenhain/HeidenhainCoordinateOffsetSyntax.cs — the datum-cycle path into the same table, and the synthetic ids it writes. HiMech/NcParsers/Keywords/Generic/IsoKeywords.cs — the recognised G-word series. HiMech/NcParsers/Keywords/Siemens/SiemensKeywords.cs — the extended frame series and the cancel frame. HiMech/NcParsers/Initializers/StaticInitializer.cs — the three brand defaults for the coordinate active at the first block. HiMech/Machining/MachiningEquipmentUtils/MachiningEquipmentUtil.cs — the program-zero machine position P0 writes: the reflection that zeroes every dynamic branch of the equipment assembly, and the anchor fallback when the workpiece declares none. See Also Program Data Plane — the plane this leaf opens, and the per-case tables beside it that a brand switch keeps or sweeps Frames — the other node on the Siemens frame table, where the same rows are edited as settable frames rather than as G54 offsets Datum Tables — the other node on the Heidenhain datum table, carrying the preset rows this leaf aliases plus the fourteen rows and the shift table it cannot reach"
  },
  "anatomy/general-setup/fixture.html": {
    "href": "anatomy/general-setup/fixture.html",
    "title": "Fixture | HiAPI-C# 2025",
    "summary": "Fixture The fixture is what holds the workpiece on the machine table: one geometry, and the two anchor transformers that place that geometry against the workpiece and against the table. It has two surfaces: the equipment/fixture branch of the General Setup page's Control Tree (/general-setup?tree=equipment/fixture), an equipment child of the General Setup group between Coolant and Workpiece. /fixture and anything below it redirects there. It edits the one fixture the project owns. Key Model: Fixture It is addressed by an IndexService key handed to the Object Management Menu Button and installed back onto the project through the controller's UpdateFixture. Assistant Model: LocalProjectService — owns the fixture as Fixture. There is no fixture-only canvas: the branch shares the General Setup canvas, whose displayee is the equipment-setup displayee (Disp/EquipmentSetupDisplayee.cs) — the merged fixture + workpiece scene with the anchor, buckle and controller-coordinate overlays. Its option set is the equipment-setup config (Disp/EquipmentSetupDisplayeeConfig.cs), carried on UserService.UserConfig as its EquipmentSetupDisplayeeConfig property. Layout Control Tree Branch The root panel is rendered inline by the dock's primary editor pane, so it has no title label of its own — the wrapping expansion header carries the selection breadcrumb. Every item below is a tree node whose editor is swapped into that same PRIMARY row. Fixture Root Panel — equipment/fixture, item type FixtureRoot Object Management Menu Button — file extension .Fixture, load type Hi.NcMech.Fixtures.Fixture, HiMech, rel file Fixture.xml, based at the project directory. Load / Save As / Copy / Paste / XML. Geometry Type Badge — the attached geometry's kind name, none when the slot is empty. Intro caption, and an empty-state caption while no fixture key is minted. equipment/fixture/geometry — “Geometry”, a Geometry slot backing Geom. The slot's own panel is the kind picker (Geometry Management Control, selector only); the picked kind's editor is the slot's child item. Kinds offered: Box3d, Cylindroid, StlFile, TransformationGeom, GeomCombination, plus None. The geometry must satisfy IStlSource, so the runtime-only voxel CubeTreeFile is not among them. equipment/fixture/anchor — “Anchor”, a Group stem whose info text states how the fixture is placed. Two Transformer slots hang from it, each a kind picker (Transformer Manage Panel) over the picked kind's child editor: equipment/fixture/geom-to-workpiece — “Geom To Workpiece”, GeomToWorkpieceTransformer, which places the workpiece buckle — where the workpiece attaches — relative to the fixture geometry (see Workpiece). equipment/fixture/geom-to-table — “Geom To Table”, GeomToTableTransformer, which pins the fixture geometry onto the machine table buckle. Kinds offered on both: StaticTranslation, StaticRotation, StaticFreeform, DynamicTranslation, DynamicRotation, GeneralTransform, NoTransform. Shared slave view: the General Setup equipment canvas in the page's MAIN column, shared with Machine Tool, Workpiece and Controller (see General Setup Page). Its Display Options dropdown carries this branch's share of the scene — the Fixture Solid / Edge / Hide radio group, and the Fixture Geom Anchor, Workpiece Buckle and Table Buckle flags in the Anchors group. Behavior ClearGeomCache() runs after any change at or below the branch: each node's afterChange chain ends in the controller's ClearGeometryCache, which calls it. The two anchor slots re-commit their swap-in before clearing the cache: an inner-value edit re-posts UpdateGeomToWorkpieceTransformer / UpdateGeomToTableTransformer, so the object the switchboard produced is always the one installed on the owning field when the redraw happens. Load / Paste / XML-Apply only swap the IndexService entry. The tree root then installs the result onto the project through UpdateFixture — the equipment setter re-attaches the buckles itself — re-runs Initialize to re-mint the branch's keys, and clears the geometry cache. The button's XML dialog re-emits its object-loaded event on Apply, so that install and refresh chain runs exactly once. Kind pickers are parent-aware. Picking a geometry kind calls CreateGeometry, which installs the new object on Geom server-side and maps the literal None to null; picking a transformer kind creates the object and then rebinds the owning field. The shared canvas snaps to the isometric view once, when its displayee is bound — the display controller's initialize does it server-side. Afterwards a geometry set only clears the cache, and the operator re-frames from the RenderingCanvas Tool Bar's view picker. Both canvases draw the live model, so an edit shows on the next frame with no further calls. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/useControlTreeHost.ts — builds the equipment/fixture root (item type FixtureRoot, keyed on the IndexService fixture key) with its geometry slot and the anchor Group holding geom-to-workpiece and geom-to-table; owns the clear-cache and transformer-rebind afterChange chains, the create hooks and the Object Management install handlers. wwwroot-src/src/components/controlTree/PrimarySlavePanel.vue — renders the root editor inline: the Object Management button, the geometry-type badge and the intro / empty-state captions. wwwroot-src/src/components/controlTree/itemTypes.ts — the ItemType registry that binds the branch's Geometry and Transformer slots and every concrete kind to their panels, and grows the sub-tree from the indexed object's type. wwwroot-src/src/components/controlTree/GeometrySlotPanel.vue — the Geometry node's kind picker. wwwroot-src/src/components/controlTree/TransformerSlotPanel.vue — the Geom To Workpiece and Geom To Table nodes' kind picker. wwwroot-src/src/components/controlTree/SoleEditorPanel.vue — hosts the concrete kind's own editor once a geometry or transformer kind is chosen. wwwroot-src/src/components/controlTree/ControlTreeDock.vue — the left dock: the Control Tree row over the PRIMARY editor row, with a draggable height divider. wwwroot-src/src/pages/GeneralSetupPage.vue — the three-column host page (dock / content column / canvas) that provides the equipment-scope control-tree host. wwwroot-src/src/components/mech/EquipmentSetupPanel.vue — the shared canvas column: the RenderingCanvasToolBar, the Display Options dropdown and the RenderingCanvas. wwwroot-src/src/components/widgets/ObjectManagementMenuButton.vue — the reused object-management dropdown, keyed entirely on its modelKey (see Object Management Menu Button). wwwroot-src/src/components/geom/GeometryEditor.vue — the generic geometry kind switchboard reached from the Geometry slot panel, including its None (unset) entry. wwwroot-src/src/components/topo/TransformerSelectPanel.vue — the generic transformer kind switchboard reached from the Transformer slot panels. wwwroot-src/src/api/fixture.ts — typed client for /api/Fixture/*: Initialize, UpdateFixture, the three Get…Type reads, UpdateGeometry, the two Update…Transformer rebinds, CreateGeometry and ClearGeometryCache. wwwroot-src/src/api/equipmentSetup.ts — typed client for the shared canvas: binds the equipment-setup displayee onto the connection's engine and drives its display options. wwwroot-src/src/router/routes.ts — declares general-setup and the fixture/:rest(.*)* redirect onto ?tree=equipment/fixture. Mech/FixtureController.cs — REST surface at /api/Fixture: Initialize, UpdateFixture, GetGeometryType, GetGeomToWorkpieceType, GetGeomToTableType, UpdateGeometry, UpdateGeomToWorkpieceTransformer, UpdateGeomToTableTransformer, CreateGeometry, IndexCurrentGeometry and ClearGeometryCache. Mech/EquipmentSetupDisplayController.cs — /api/mech/equipment-setup-display: binds and configures the displayee per rendering connection and serves its whole option set — the three rendering-mode endpoints (fixture, raw-geom, ideal-geom), show-machine, show-tool, show-dimension-bar, show-fixture-geom-anchor, show-workpiece-buckle, show-table-buckle, show-workpiece-geom-anchor, show-program-zero-anchor, show-meshed-geom, show-controller-coordinate and controller-coordinate-id. Disp/EquipmentSetupDisplayee.cs — the displayee the General Setup canvas renders: the merged fixture + workpiece scene with the anchor, buckle and controller-coordinate overlays. HiAPI Engine HiMech/NcMech/Fixtures/Fixture.cs — the key model: the geometry, the table and workpiece buckles, the geom anchor, the two anchor transformers and ClearGeomCache. See Also Mechanism Builder Page — reuses this page’s parent-aware transformer rebind pattern Freeform Holder Panel — the other surface built from the same generic Geometry and Transformer slots"
  },
  "anatomy/general-setup/hidden-controllers.html": {
    "href": "anatomy/general-setup/hidden-controllers.html",
    "title": "Hidden Controller Branches | HiAPI-C# 2025",
    "summary": "Hidden Controller Branches Two Control-Tree nodes on the General Setup page are absent from a fresh installation: CSV Controller and CL Controller, on /general-setup under the ids equipment/controller-csv and equipment/controller-cl. Each is the entire editing face of one resident non-brand runner suit — the CSV control-table pipeline and the NX-CL (CLSF) pipeline — and each is minted only when its device-local Preference checkbox is on or the current URL targets it. This page is the answer to “why is that node not in the tree”, because the equipment tree withholds a node in two different ways and only one of them can be talked out of it. Important Anatomy makes no claim that any id named here is stable across versions. The migration hop that keeps an older ?tree= value resolving is described in Tree Ids and Routes. Two Kinds of Invisibility Preference-gated Brand-gated Which nodes equipment/controller-csv, equipment/controller-cl every gated leaf under equipment/controller What decides a checkbox stored in the browser the active runner's dependency list Where the decision lives one device the project Reachable by a link anyway yes, and deliberately no What a link to it does mints the node and selects it nothing at all The distinction is not a matter of degree. A preference-gated node exists in the code that builds the tree and is simply not pushed; the same build reads the URL, so naming the node in a link is enough to bring it back for that visit. A brand-gated node has no such second door: the branch builder never creates it, and the selection code refuses an id the built tree does not carry, so there is nothing for a link to select. Which leaf that branch grows on which brand, and the snapshot flag behind each one, is Brand Matrix. Preference-Gated: The Two Runner-Suit Nodes The equipment tree host mints each of the two nodes when a project is open and either the node's checkbox is on or the route's tree id begins with that node's id. All three parts matter. With no project open neither node is built, whatever the checkboxes say — the same guard that keeps the Controller branch childless before a project is loaded. The consequence is not a dead end: loading a project bumps the layout's project epoch, which destroys and rebuilds the page, and the rebuilt host runs the build again and then adopts whatever ?tree= the URL still carries. A link opened against an empty application therefore lands on its node once a project is opened, without the link being touched. The checkboxes are device-local. Both are held in one browser-storage record of view preferences, off by default, written back a moment after each flip, and never sent to the server — so the setting belongs to a browser rather than to a user account or to a project. They are the CSV Controller and CL Controller entries of the app menu bar's Preference dropdown, described in Preference Menu. Only the route reveals — not the persisted last selection. The host also remembers the last node selected on each tree page, and that memory deliberately mints nothing: the landing selection is honoured only when the id it names is already in the built tree, and falls back to the equipment group root when it is not. Reveal-by-route has to happen while the tree is being built, because the code that adopts a ?tree= id afterwards refuses an id the tree lacks. Switching a box off while standing on its node The host watches both checkboxes and rebuilds the whole equipment tree when either flips. Before the rebuild it checks whether the current selection is one of the nodes that just lost its box, and when it is, it does two things in this order: Replaces the URL's tree query with equipment. Moves the selection to the equipment group root. Only then does the tree rebuild. The order is the point: the URL already mirrors the selection, and the URL is exactly what reveals an unchecked node, so a selection left standing there would leave its id in the query, and the next build's prefix test would re-mint the node that was just switched off. The reader lands on the General Setup group panel, whose clickable child list no longer carries the row. The selection is moved directly rather than through the host's switch request, which would matter only for a panel registering the before-switch gate; neither of these two does. Switching a box off while the selection is elsewhere takes no such detour — the rebuild simply drops the node from the tree and from the group panel's child list. What the two nodes are not Both are childless leaves. Neither declares a child builder, so nothing grows beneath them; neither registers a content view, so the General Setup content column keeps its own empty hint for both; and neither panel reports a structural change, so nothing either panel does rebuilds any part of the tree. There is no Object-Management menu on either: a CSV or CL pipeline is not loaded, pasted or saved as a file of its own the way a brand controller is. Brand-Gated: The Node That Was Never Minted Under equipment/controller the node set is grown from a snapshot of the active NC runner, and a leaf whose backing dependency that runner does not resolve is never created. Nothing reveals it. A link naming such an id — equipment/controller/program-data/frames on a project running a Fanuc runner, say — reaches the host, finds no such node in the built tree, and is dropped: the selection is left as it was, the URL keeps the id it was given, and no redirect and no message follow. On a first load that means the editor row shows its own hint, \"Select an item in the Control Tree to edit it here.\", under a tree in which the node the link names is simply not present. The two behaviours meet at the same line of code from opposite sides. The runner-suit nodes are read out of the URL while the tree is built, so by the time that check runs they exist; a brand-gated leaf is not, so the check is the end of the road for it. That is why a checkbox can be overruled by a link and a runner cannot. What the Preference Captions Mean Under each checkbox sits a caption reading either “This project plays CSV” / “This project plays CL” or “Not used by this project”. It is the informed-choice half of the design: the menu answers whether the loaded project plays that kind, so the decision to show a node is made with evidence rather than by trial. The caption is read when the Preference dropdown opens rather than on page load, and both runner snapshots are fetched together; with no project open both captions are blank, and a snapshot that fails to load leaves its own caption blank rather than asserting either answer. The evidence is a scan of the loaded project, per kind: A mission Program File command whose effective kind is that kind — its explicit kind, or, for the default Auto, the kind detected from the file extension: .cl, .cls and .clsf are CL, .csv is CSV, and every other extension is brand NC code (DetectByPath(API)). A mission script command whose text contains CsvFile( or ClFile(. It is a bare substring test rather than a list of verbs. The play verbs end in it — PlayCsvFile(API) and PlayClFile(API) — and on the CSV side so do the two sensor-mapping verbs, MapSingleByCsvFile(API) and MapSeriesByCsvFile(API), so a script that only maps recorded telemetry onto steps counts as CSV evidence though it plays no control table. The CL side carries no such neighbour: every member whose call text ends in ClFile( plays or runs a CLSF file. For CL only, a machining chain that is a ClMillingDevice, since a pure-CL project plays nothing else. Three properties of that scan are easy to guess wrong. It walks the whole mission, the entries of a nested list command included, and it walks through each command's enable wrapper without reading it — a Program File command that is switched off still counts as evidence. The script test cuts the other way too: a play routed through the generic NC entry point with a .csv path is deliberately not matched, because a bare .csv appears in step and shot output templates far more often than in play paths. And the answer feeds the caption and nothing else — usage evidence mints no node. The tree is built from the checkbox and the route, and from nothing the scan reports. How Both Panels Edit Neither node belongs to the Controller branch, so that branch's Editing Contract does not govern them. Both panels nonetheless follow most of its shape, and the places they do not are worth naming. Shared with the contract. Each panel fetches its own snapshot once on mount and owns no store. Each opens with two guards, in order: \"No project loaded.\" from the snapshot's own project flag, then a line naming the absent config — \"No CSV column config on the CSV runner.\" or \"No CLSF config on the CL runner.\" Every control commits on its own, with no save button and no dirty marker. A failed write raises one negative toast, three seconds, composed as the panel's localized context followed by the server's own English sentence, with a console line beside it, and leaves no inline error state behind once it expires. Both REST surfaces answer a missing config inside a success envelope rather than with an error status, and the shared write helper turns that envelope into a thrown error; the read helper inspects no envelope, and neither endpoint has a non-200 path, so a read fails only on transport. A failed read therefore leaves the empty snapshot in place and the panel renders its \"No project loaded.\" line — the same body an absent project produces, with the toast as the only signal that the two differ. Where they part from it. The CSV panel is not optimistic: its text fields are bound to a local draft, so the screen already shows the new text, and the request is awaited before the panel's server mirror is updated; a failure restores the field from that mirror. The CL panel is optimistic in the contract's own shape, assigning first and restoring on failure, and its two numeric fields are the shared numeric widget, committing on blur or on Enter and never per keystroke; the full widget contract is Numeric Input. Both panels guard on equality, and the guard is the panel's rather than the widget's. Every commit handler on both — the CSV tag fields, the two CL rates and the tool-house toggle — compares the incoming value against the fetched server mirror first and returns when the two match, so committing an untouched field, or blurring after an Enter that already succeeded, sends nothing. That is the departure from the Controller branch, whose numeric leaves carry no such comparison and lean on the shared widget alone, and the widget emits on every blur and every Enter. The one control across the two panels with no such comparison is the CL chip field. CSV Controller The node is the face of the project's resident CSV runner suit (CsvRunnerSuit), a whole runner suit constructed alongside the brand one and never absent from a loaded project. Its runner is a SoftNcRunner assembled as the CSV pipeline by the factory GeneralCsvRunner, and it replays a CSV control table. A project file that stores the column configuration flat, outside any suit, has that element migrated into the suit's pipeline as it loads, so such a file keeps its tags. The whole face is one flat configuration, CsvRunnerConfig — no brand presets, no per-case tables and no native parameter form, which is why the node is a leaf rather than a branch. The panel's caption says what it edits: \"Column tags of the CSV control table (matched against the header line). Played by a mission Program File of CSV kind or a script's PlayCsvFile(\"…\").\" The header line is the file's first row, split on commas; each title then has quote characters stripped from its two ends and is trimmed of whitespace, in that order, so a title whose opening quote sits behind a space keeps that quote and never matches its tag. Field label Default tag What reads it Machine coordinate prefix MC. the machine-coordinate columns, composed as the prefix plus X, Y, Z, A, B, C Cutter location prefix CL. nothing in the shipped pipeline Tool id column ToolId the tool-change section Spindle speed column (rpm) SpindleSpeed_rpm the spindle section Spindle direction column Spd.Dir. the spindle section, parsed as a direction name; a speed with no direction turns clockwise Feedrate column (mm/min) Feedrate_mmdmin the feedrate section Step duration column (s) StepDuration the recorded-timing section Actual time column ActualTime the recorded-timing section Coolant column Coolant the coolant section Line-begin C# script column LineBeginCsScript the script section, run before the row Line-end C# script column LineEndCsScript the script section, run after the row Four things that table does not show on its own: The cutter-location prefix is stored, serialized and editable, and no syntax in the shipped CSV pipeline reads it. Columns under it are not consumed as coordinates; they survive into the residual telemetry below. Naming a column consumes it. Each syntax removes the columns its tags name from the decoded row, and whatever is left over is carried onto the step as recorded data — sensor channels, file and line bookkeeping, anything else the file holds. So clearing a tag does more than stop the value being used: it moves that column into the residual set. The duration cell is read as a time span rather than as a number of seconds, despite the field's own (s). A cell that does not parse falls back to the difference between this row's actual time and the previous parseable one, and a resolved duration longer than one minute is clamped to one minute, on the reasoning that a longer gap is spliced recordings rather than machining time. An empty field is a real edit. The write applies every field the payload carries, and the panel sends exactly the field that changed, so blanking a box clears that tag on the model rather than leaving it alone. Each field commits on blur or on Enter — never while typing — and sends only itself. There is no validation on either side of the wire: no trimming, no bounds, no uniqueness. CL Controller The node is the face of the project's resident NX-CL suit (ClsfRunnerSuit), constructed the same way beside the brand suit and the CSV suit, its runner a SoftNcRunner assembled as the CLSF pipeline by the factory NxClRunner. Its caption reads \"Plays NX cutter-location files (CLSF) — a mission Program File of CL kind or a script's PlayClFile(\"…\").\" Everything on the panel is one ClsfRunnerConfig, and every field on it answers something a cutter-location file cannot say for itself. Rapid feedrate (assumed), suffixed mm/min, and Rotary rapid feedrate (assumed), suffixed deg/min, default to 20000 and 36000. A CLSF carries no machine axes, so a RAPID move has nothing to be timed against — but the two rates are not read on the same path, and the machining chain decides which. On a pure-CL chain the CLSF pipeline's own motion semantic reads the linear rate straight off this configuration and times every rapid from it; the rotary rate is never consulted. On a machine-tool chain, where each CLSF block is re-expressed in machine coordinates and routed to the motion semantics reused from the NC pipeline, the configuration doubles as the pipeline's rapid-feedrate provider and answers axis-uniformly — every linear axis gets the first rate, every rotary axis the second — and that is the only place the rotary rate is read. Both fields carry a minimum of 1: a smaller value is refused inside the widget itself, which shows Must be ≥ 1 under the box and emits nothing, so no request is made and no toast appears. The server's own positivity check sits behind that and is not reachable from this panel. A cleared or non-finite entry is dropped by the panel before the request, which leaves the box showing what was typed while the stored rate stands; selecting another node and returning restores the box. Prefer Tool House on LOAD/TOOL is a toggle, on by default, committing on the click. Its caption sits below it permanently rather than as a field hint: \"On: a LOAD/TOOL id already configured in the Tool House keeps that tool (CLSF TLDATA geometry ignored). Off: TLDATA overwrites the tool-house entry on every load.\" That is what the code does — a tool change requesting an id the tool house already holds is left alone while the toggle is on, and the file's own tool geometry rebuilds the entry when it is off. Either way an id the house does not hold is built from the file's tool data, and an id with neither is reported as a configuration error. Excluded record words is a chip field: a word typed and entered joins the list, and there is no dropdown, because the option list is deliberately empty. Its preset list is PAINT, TOOLNO, LOADTL, TOOL PATH, TOOLPATH and END-OF-PATH. A CLSF record that reaches the end of the pipeline unhandled is otherwise reported as a validation warning naming the record word; a word on this list is consumed silently instead, matched whole and without regard to case. Adding or removing one chip writes the whole list, the server trims each word and drops the blank ones before replacing the stored list, and the panel keeps what was typed — so a word entered with stray whitespace reads differently on screen from what was stored, until the panel is remounted. Layout App Menu Bar Preference ▾ Dropdown — fetches both runner snapshots as it opens, and only with a project open CSV Controller CheckBox Usage Caption — “This project plays CSV”, “Not used by this project”, or blank CL Controller CheckBox Usage Caption — the same three states, for CL General Setup Control Tree — the left dock of /general-setup General Setup Group Row — equipment Controller Node Row — the brand branch, built ahead of the two rows below CSV Controller Node Row — equipment/controller-csv; present only under the conditions above, and pushed before the CL row when both are CL Controller Node Row — equipment/controller-cl; the last row the group can carry. Each is a plain label with no icon, no checkbox and no children Editor Row — the panel of whichever node is selected General Setup Group Panel — where a switched-off node's selection lands: the group's intro caption over a bordered, separated list of its children, one clickable row each CSV Controller Panel No-Project Body — \"No project loaded.\" No-Config Body — \"No CSV column config on the CSV runner.\" Editor Body Intro Caption — the column-tags line, with PlayCsvFile(\"…\") set in code Tag Text Field, one per row, in this order: Machine coordinate prefix (hint e.g. “MC.” → MC.X / MC.Y / MC.Z), Cutter location prefix (hint e.g. “CL.” → CL.X / CL.Y / CL.Z), Tool id column, Spindle speed column (rpm), Spindle direction column, Feedrate column (mm/min), Step duration column (s) (hint Overrides feedrate-derived timing.), Actual time column (hint Wall-clock instant of the row.), Coolant column (hint Flood / Mist / Off or on/off.), Line-begin C# script column (hint Runs before the row.), Line-end C# script column (hint Runs after the row.) CL Controller Panel No-Project Body — \"No project loaded.\" No-Config Body — \"No CLSF config on the CL runner.\" Editor Body Intro Caption — the plays-CLSF line, with PlayClFile(\"…\") set in code Rapid feedrate (assumed) Numeric Field — suffixed mm/min, minimum 1 Rotary rapid feedrate (assumed) Numeric Field — suffixed deg/min, minimum 1 Prefer Tool House on LOAD/TOOL Toggle Policy Caption — the On: … Off: … explanation, always shown Excluded record words Chip Field — free-text entry with no dropdown list, hint Record words consumed silently as intentional skips (case-insensitive). Type + Enter to add. Toast — negative, three seconds, the panel's context followed by the server's own message Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/useControlTreeHost.ts — the build rule that mints the two nodes and where in the equipment group they sit, the checkbox watch that steps the selection off a node losing its box before the rebuild, and the route-adoption guard that refuses an id the built tree lacks. wwwroot-src/src/components/controlTree/runnerSuitItemTypes.ts — the two item types and the panels they bind to; its own docblock names the usage evidence and the persisted selection as reveal conditions, which the host's build rule does not. wwwroot-src/src/components/controlTree/CsvRunnerPanel.vue — the column-tag form: the two guards, the field list with its labels and hints, the blur-and-Enter commit with its equality guard against the fetched mirror, and the single-field payload. wwwroot-src/src/components/controlTree/ClRunnerPanel.vue — the CLSF form: the two rapid rates, the cleared and non-finite values it drops before the request, the equality guard on each rate and on the tool-house toggle, and the unguarded whole-list chip write. wwwroot-src/src/composables/useViewPrefs.ts — the device-local browser-storage record behind both checkboxes: their default, their persistence, and the record they share with the tree's expansion and last-selection memory. wwwroot-src/src/components/AppMenuBar.vue — the Preference dropdown's two checkboxes, and the caption refresh that fetches both snapshots as the menu opens. wwwroot-src/src/api/csvRunner.ts and wwwroot-src/src/api/clRunner.ts — the two snapshot shapes, their pre-fetch empty values, and the typed wrappers over each REST surface. wwwroot-src/src/api/http.ts — the plain-JSON read that inspects no envelope, beside the envelope write that throws a success: false message. wwwroot-src/src/components/widgets/NumericInput.vue — the field behind the two rapid rates: commit on blur or Enter, and the minimum that reports inline without emitting. wwwroot-src/src/components/controlTree/PrimarySlavePanel.vue — the editor row: the remount key that refetches when the selection moves, and the select-an-item hint a refused deep link leaves behind. wwwroot-src/src/components/controlTree/GroupInfoPanel.vue — the General Setup group's editor, whose clickable child list gains and loses these two rows with the tree. wwwroot-src/src/components/controlTree/itemTypes.ts — the registry the two item types are spread into, and the panel lookup the editor row resolves through. wwwroot-src/src/router/treeRoutes.ts — the id migration applied to a ?tree= value before the reveal test reads it, and the page roots a foreign id is redirected by. wwwroot-src/src/pages/GeneralSetupPage.vue — the route that creates the equipment-scoped tree host and calls its initialization. wwwroot-src/src/layouts/MainLayout.vue — the project epoch that rebuilds the page when a project loads, which is what lets a link opened against an empty application land afterwards. wwwroot-src/src/i18n/en/tree.ts — the two node labels, both panels' intros, empty lines, field labels, hints and error contexts. wwwroot-src/src/i18n/en/menu.ts — the two checkbox labels and the two usage-caption strings. wwwroot-src/src/i18n/en/common.ts — the shared “No project loaded.” line both panels open with. Mech/CsvRunnerController.cs — the CSV suit's REST surface: the snapshot, the write that applies only the fields the payload carries, and the success envelope a missing config is reported in. Mech/ClRunnerController.cs — the CL suit's REST surface: the same envelope, the positivity checks on the two rates, and the trim-and-replace of the excluded-word list. Mech/NcSuitUsage.cs — the usage scan behind the two captions: the mission walk that reads through a command's enable wrapper, the two script substrings, the extension detection for an Auto Program File, and the CL-only chain test. HiAPI Engine HiNc/MachiningProcs/MachiningProject.cs — the two resident suits as property-initialized members, their load paths with the fall back to a fresh pipeline, and the migration of the older flat CSV column element into the suit. HiNc/MachiningProcs/LocalProjectService.cs — the re-bind that wires both suits to the host alongside the brand suit, and the chain walk that clears a generic axis configuration before stamping the chain's axes onto it. HiNc/MachiningProcs/SessionShell.cs — the script verbs whose call text the caption's evidence scan matches: the two play verbs, and the two CSV sensor-mapping verbs that end in the same substring. HiNc/SessionCommands/NcFileCommand.cs — the Program File command whose kind the scan reads, and its Auto default. HiNc/SessionCommands/EnablingWrapper.cs — the enable wrapper the scan walks through without reading, which is why a switched-off command still counts as evidence. HiMech/MachiningProcs/NcKind.cs — the kind enum and the closed extension sets behind the Auto detection. HiMech/Numerical/CsvParsers/GeneralCsvRunner.cs — the factory that assembles the suit's runner as the CSV pipeline, and the place its column configuration sits in that pipeline. HiMech/Numerical/CsvParsers/CsvRunnerConfig.cs — the eleven tags, their serialization, and the constants they default to. HiMech/Mapping/MappingUtil.cs — those constants. HiMech/Numerical/CsvParsers/CsvSegmenter.cs — the header row the tags are matched against, and the quote-then-whitespace trim applied to each title. HiMech/Numerical/CsvParsers/RowToSyntaxs/RowToMachineCoordinateSyntax.cs — the six axis names the machine-coordinate prefix is composed with, and the consumption of those columns whether or not they resolved. HiMech/Numerical/CsvParsers/CsvSemantics/CsvTimingUtil.cs — the duration parse, the actual-time fallback and the one-minute clamp. HiMech/Numerical/CsvParsers/CsvSemantics/CsvActDataSemantic.cs — the residual columns carried onto the step, which is where a column no tag names ends up. HiMech/Numerical/ClsfParsers/NxClRunner.cs — the factory that assembles the CLSF pipeline, and the configuration's place in it. HiMech/Numerical/ClsfParsers/ClsfRunnerConfig.cs — the four values, their defaults, and the axis-uniform rapid-rate provider the machine-coordinate motion semantics read. HiMech/Numerical/ClsfParsers/ClMotionValveSemantic.cs — the router that sends a block carrying machine coordinates to the semantics reused from the NC pipeline and every other block to the pure-CL one, which is what decides whether the rotary rate is read at all. HiMech/Numerical/ClsfParsers/ClMotionSemantic.cs — the pure-CL motion semantic, timing a rapid from the linear rate taken directly off the configuration. HiMech/Numerical/ClsfParsers/ClsfRecordCleanupSyntax.cs — the excluded-word match, and the validation warning it replaces with a silent consume. HiMech/Numerical/ClsfParsers/ClsfToolBuildSemantic.cs — the tool-house policy: the entry that wins, the file's tool data that builds a missing one, and the error when neither answers. HiMech/Milling/ClMillingDevice.cs — the chain type that is CL usage evidence on its own. See Also General Setup Page — the page whose tree these two nodes are minted into, and the equipment items they sit after Preference Menu Dropdown — the dropdown holding the two checkboxes and their usage captions, and the other per-user settings beside them Brand Matrix — the other kind of missing node: which leaf the brand branch grows on which brand, and the snapshot flag behind each one"
  },
  "anatomy/general-setup/index.html": {
    "href": "anatomy/general-setup/index.html",
    "title": "General Setup Page | HiAPI-C# 2025",
    "summary": "General Setup Page General Setup is the equipment page at /general-setup. It is one of the two Control-Tree pages: the left dock names every piece of equipment in the project and edits whatever is selected, and the canvas on the right shows all of it at once. Selection rides the URL as ?tree=equipment/…, so any branch of it is a link. The tree's one root is a pure Group stem at equipment, selectable in its own right: it renders an orientation panel listing the equipment items beneath it. The page renders three columns in nested splitters — the Control-Tree dock, the content column, and the equipment canvas. The dock carries two stacked rows: the tree above, and below it the editor panel of whichever node is selected. The content column holds a second, wider view of the same selection, mounted only for the item types that register one — on this page the spindle branch and nothing else — while every other selection leaves it showing its empty hint. Column widths are device-local, and the dock aligns with the Execution page's so the two tree pages feel like one application. Ordered as the page builds its equipment children. Pages Machine Tool — The kinematic chain the whole scene hangs from, and the standalone route that loads and previews it Spindle Capability — The spindle envelope: thermal condition, gear shift, dry run, power and torque Background / Coolant — The two scene branches that are not machine parts: the backdrop and the coolant model Fixture — What holds the workpiece, its geometry and the two anchors that place it Workpiece — Raw and target geometry, the anchors that locate them, the mesh, and the material Controller — The SoftNcRunner-native controller branch: its two planes, the brand matrix behind which nodes appear at all, and the contract every leaf edits by Hidden Controller Branches — The two runner-suit nodes a fresh installation never builds, the device-local checkboxes that reveal them, and the second kind of invisibility a link cannot undo The superseded Legacy Controller screen at its own route is a separate surface, editing a different model from the branch above. See Also Execution Page — the other Control-Tree page, and the one this was split out of Tool House Page — the third equipment surface, a tab page rather than a tree page Main Panel — the shell whose Page menu reaches this route Control Tree — the engine behind this page's tree: how a branch is built, rebuilt and selected Controller Branch — the branch this page hosts whose node set changes with the controller brand Hidden Controller Branches — the two equipment nodes this page withholds until a preference or a link asks for them Legacy Controller — the superseded controller screen at its own route, and the three settings only it edits"
  },
  "anatomy/general-setup/machine-tool.html": {
    "href": "anatomy/general-setup/machine-tool.html",
    "title": "Machine Tool | HiAPI-C# 2025",
    "summary": "Machine Tool The machine tool is the project's kinematic chain — the linkage between the machine table and the tool spindle. It has three surfaces: the equipment/machine-tool branch of the General Setup page's Control Tree (/general-setup?tree=equipment/machine-tool), the first equipment child of the General Setup group and a leaf: chain structure belongs to the Mechanism Builder Page, so the root carries no child slots; the /machine-tool route, a standalone surface pairing a chain-only canvas with a load button and a GUI / XML view of what is loaded. Its fields are read-only, but the route is not: its Load installs the picked chain file onto the project. It carries no Page-menu entry and is reached by URL. Both edit the one chain the project owns. Key Model: IMachiningChain The chain is addressed by an IndexService key handed to the Object Management Menu Button and installed back onto the project through the controller's Update. Assistant Model: LocalProjectService — owns the chain as the MachiningChain / MachiningChainFile pair. MachiningProject Layout Control Tree Branch The root panel is rendered inline by the dock's primary editor pane, so it has no title label of its own — the wrapping expansion header carries the selection breadcrumb. Machine Tool Root Panel Object Management Menu Button New Items: one entry, New ClMillingDevice (“CL-driven blank device”). Its parameterless form is the complete CL-driven device; any other chain type arrives by Load, Paste or XML. Load / Save As / Copy / Paste / XML, over the project directory and the admin directory. File extensions are .MachineTool and .mt, so the Load / Save As filter reads *.MachineTool / *.mt / *.xml; the load type is IMachiningChain. Type Badge — the chain's runtime type name, none when no chain is attached. Read-only caption lines, shown once a chain is attached: Name: — Name Note: — Note, when non-empty File: — the chain's project-relative file, when it has one Intro caption, and an empty-state caption while no project is open. Shared slave view: the General Setup equipment canvas, whose Solid group's Machine flag draws this chain (see General Setup Page). That flag starts cleared, so the shared canvas shows a correctly attached chain only after it is ticked; the /machine-tool route's own canvas has no such flag and always draws it. /machine-tool Route Load and show only: no Save As, no ReLoad, no name editing. Header Row Title Label “Machine Tool” [relFile] caption — the loaded chain's project-relative path, when it has one. Folder-icon Load Button — opens the server-side file explorer dialog, restricted to the ProjectDirectory and ResourceDir roots and filtered to Machine Tool (.MachineTool|.mt). Disabled until a project is open. Read-only Name Field, shown once a chain is loaded. GUI / XML View Toggle, disabled until a chain is loaded. Body — two columns Left: Identity Card or XML Source GUI mode — a read-only Name input, a read-only auto-grow Note textarea, and a Type chip. XML mode — the chain serialised to XML, badged read-only, with a refresh button. The text is fetched lazily on the first switch to XML and re-fetched after a load while XML mode is open. Right: Viewer Panel RenderingCanvas Tool Bar and a connection badge. RenderingCanvas, cache id MachineToolCanvas — this route's own canvas. Behavior Load / Paste / XML-Apply only swap the IndexService entry. The tree root then installs the result onto MachiningChain — the setter re-attaches the fixture and workpiece buckles and wires the runtime hooks itself — re-mints the key and rebuilds the branch. The button's XML dialog re-emits its object-loaded event on Apply, so that install and refresh chain runs exactly once. A chain the file describes wrongly is refused, and which of the two steps refuses it depends on the file. A machine tool file asking for its collision pairs to be generated is walked from the ground anchor to each end while it is being read, so a chain carrying no anchor named exactly t or exactly w never reaches the IndexService at all: Object Management's Load answers Load failed: This kinematic chain has no worktable-end anchor named 'w'. A file that lists its collision pairs instead is read without that walk and does reach the index; the install that follows builds the kinematics solver, which requires the same two anchors, so the same sentence arrives one step later as Install machine tool: … and the project keeps the chain it had. The shipped machine tool files all ask for generated pairs, so the first form is the one usually met. The worktable end is checked before the tool end, so a chain missing both names only 'w' until that one is fixed. The /machine-tool route runs both steps inside its single call, so either refusal reaches it as Load machine tool: …, and — like the no-project refusal behind the disabled folder button — leaves the loaded chain untouched. The IndexService key is minted even on a project with no chain attached, so Load and Paste stay usable from an empty root. The /machine-tool route's own Load takes the shorter path: one call materialises the picked file server-side and assigns the chain to MachiningChain in the same request, with no IndexService swap in between. It re-points MachiningChainFile too — project-relative when the picked file sits under the project directory, and the path relative to the chosen root otherwise. It is refused while no project is open, which is why the folder button is disabled there. New ClMillingDevice builds and installs the blank chain in one server call and clears the project's chain-file reference, so a later project save embeds the fresh chain inline instead of overwriting the previous chain's file. When the replacement came from a server-file Load, the install also re-points MachiningChainFile: project-relative when the file sits under the project directory, resource-root-relative when it sits under the resource root, absolute otherwise. An absolute path there would make every later project save rewrite the shared resource file in place instead of copying it into the project. Paste and XML applies leave the file reference unchanged. Both canvases draw the live model, so a replacement shows on the next frame with no further calls. The /machine-tool canvas snaps to the isometric view when it is bound and again after each load; the shared equipment canvas snaps once, when its displayee is bound. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/useControlTreeHost.ts — builds the equipment/machine-tool node (item type MachineToolRoot, keyed on the IndexService chain key) and owns the install / create / rebind handlers. wwwroot-src/src/components/controlTree/PrimarySlavePanel.vue — renders that branch inline: the Object Management button, its New ClMillingDevice entry, the type badge and the read-only Name / Note / File captions. wwwroot-src/src/components/widgets/ObjectManagementMenuButton.vue — the reused object-management dropdown, keyed entirely on its modelKey (see Object Management Menu Button). wwwroot-src/src/components/mech/EquipmentSetupPanel.vue — the shared equipment canvas the tree root's chain is drawn on. wwwroot-src/src/pages/MachineToolPage.vue — the /machine-tool route. wwwroot-src/src/components/widgets/FileExplorerDialog.vue — the server-side file picker that route opens, seeded to the resource root's MachineTool folder when nothing is loaded and to the current file's directory otherwise; it emits \"{rootName}:{relativePath}\" selection keys. wwwroot-src/src/api/machineTool.ts — typed client for /api/mech/machine-tool/*: snapshot, initialize, update, create, load, XML, plus the display initialize and reset-view calls. Shared by the route page and the tree root. wwwroot-src/src/router/routes.ts — declares the machine-tool route. wwwroot-src/src/components/AppMenuBar.vue — the Page menu, which lists General Setup but not /machine-tool. Mech/MachineToolController.cs — REST surface at /api/mech/machine-tool: the snapshot DTO, initialize / update / create / load and the XML read. Only ClMillingDevice is offered for blank creation. Mech/MachineToolDisplayController.cs — /api/mech/machine-tool/display: binds the project's chain onto a rendering connection's DispEngine through a delegating displayee, and serves the isometric reset-view the route page calls after a load. See Also Mechanism Builder Page — the user-scoped editor for the same anchor topology"
  },
  "anatomy/general-setup/spindle-capability.html": {
    "href": "anatomy/general-setup/spindle-capability.html",
    "title": "Spindle Capability | HiAPI-C# 2025",
    "summary": "Spindle Capability The Spindle Capability editor is the equipment/spindle branch of the General Setup page's Control Tree (/general-setup?tree=equipment/spindle), the equipment child after Machine Tool. Two older paths redirect onto it: /spindle-capability/:tab?, whose tab segment maps straight onto one of the branch's five children, and /equipment/spindle. The menu bar carries no entry of its own for it — the Page menu reaches General Setup, and the tree reaches the branch. It edits SpindleCapability on the project's authored equipment face, SetupEquipment, reached as SetupEquipment. It exposes the metadata (name, note), the thermal scalars (energy efficiency, working-temperature ceiling), the gear-shift spindle speed, the two dry-run coefficients, and the power / torque contour lists. Key Model: SpindleCapability Assistant Model: SetupEquipment — owns the capability as SpindleCapability and its optional side-file reference SpindleCapabilityFile. MachiningProject — carries that face across the .hincproj save. Layout The branch is one root plus five children, six selectable nodes in all. Each node's editor occupies the dock's PRIMARY row, and all six — the root included — register the same CONTENT-column view, the two contour charts, so the charts stay mounted while the operator walks the branch. Control Tree Branch Spindle Capability Root Panel — equipment/spindle, item type SpindleCapabilityRoot Object Management Menu Button — Load / Save As / Copy / Paste / XML over file extension .SpindleCapability, load type Hi.Milling.SpindleCapability, HiMech, rel file SpindleCapability.xml, based at the project directory. This is the whole file surface of the editor. Caption — the capability's name, or a “no capability” note. Empty state, while nothing is attached: an hourglass, a “not attached to project” line and a hint pointing at the ⋮ menu's Load entry. Name TextField — Name. Note TextField — Note. equipment/spindle/thermal — “Thermal / Energy”, item type SpindleScalars Energy Efficiency NumberField — EnergyEfficiency, clamped to 0 – 1. Working Temperature Upper Boundary NumberField (°C) — WorkingTemperatureUpperBoundary_C. equipment/spindle/gear-shift — “Gear Shift”, item type SpindleScalars Has-Gear-Shift CheckBox — flips GearShiftSpindleSpeed_rpm between null (no mechanism) and 0 (mechanism present; the operator dials in the speed). Gear Shift Spindle Speed NumberField (rpm) — always rendered, disabled until the checkbox is on. equipment/spindle/dry-run — “Dry-Run Coefficients”, item type SpindleScalars Friction Power Coefficient NumberField (mW/rpm) — DryRunFrictionPowerCoefficient_mWdrpm. Windage Power Coefficient NumberField (pW/rpm³) — DryRunWindagePowerCoefficient_pWdrpm3. equipment/spindle/power — “Power Contours”, item type SpindleContour Count line and an Add button. Contour Selector — a select over the contour list, each entry labelled by its workable duration (n min, or Continuous for the infinite one). Edit-duration Button — opens the modal below. Delete Button — confirms, then removes the selected contour. Disabled at one remaining contour. Points Table — the selected contour's points, one row per point: a spindle-speed cell (rpm, min: 0), a value cell, an insert-next button that clones the row, and a double-click remove that is disabled at one remaining point. A cell edit replaces the whole point list server-side. Empty state, when the axis has no contour yet. Edit-duration Modal Continuous (∞) CheckBox — disabled when another contour already holds the continuous key. Workable Duration NumberField (min), shown while Continuous is off, min: 0. Save rejects a non-positive duration and is a no-op when the key is unchanged. equipment/spindle/torque — “Torque Contours”, item type SpindleContour, the same shape over the torque list. Shared content view, registered by the root and by all five children: the two contour charts in the General Setup page's CONTENT column. Power chart and Torque chart, each with a chip legend — one chip per contour, showing its duration and, on hover, its point count. Clicking a chip selects the contour the PRIMARY-row editor edits. A vertical marker line at the gear-shift spindle speed, while one is set. Its own not-attached empty state, mirroring the root panel's. Behavior Rpm ↔ cycles/s conversion lives server-side. SpindleCapability stores spindle speed in cycles/s (Hz); the controller converts to rpm in its DTOs and back on write. The frontend only ever sees rpm. Nullable gear shift. The Has-Gear-Shift checkbox writes 0 when checked and null when cleared, which is how the model distinguishes “mechanism present, speed not yet dialled in” from “no gear-shift mechanism”. One state, thin views throughout. Every panel on the branch — root, the three scalar sections, the two contour sections and the charts — reads and writes one module-singleton composable. A point edit therefore redraws the chart in the same tick, and a legend click moves the editor. The composable installs a single project-change watch that reloads on open and clears on close. No cache chain. These scalars feed the cutting-force and thermal physics, not the setup canvas, so the branch's afterChange does nothing — unlike the geometry branches, nothing here clears a geometry cache. Add Contour. The prompt is pre-filled with 60; a blank entry means continuous (∞). A duration already present is refused, a second continuous contour included. The new contour is seeded from the currently selected contour, falling back to the first in the list, and to a built-in default curve when the axis is empty — so the operator rarely draws from scratch. Project-scoped, and forwarded to the run. The capability lives on the authored equipment face and is persisted with the .hincproj save; setting SpindleCapabilityFile externalizes it to a side-file instead. The runtime equipment face holds the same object by reference, so a scalar or point edit is visible to a run immediately; a replacement (Load, Paste, XML Apply) re-stamps that reference through the project service's ForwardSetupEnvironmentToExecution. Load / Paste / XML-Apply only swap the IndexService entry. The root panel then installs the result onto the equipment through the controller's update, and reloads the snapshot and the key. The controller's initialize indexes a blank placeholder when nothing is attached yet, which is what keeps the ⋮ menu usable — and Load reachable — on a project with no capability. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/useControlTreeHost.ts — builds the equipment/spindle root (item type SpindleCapabilityRoot) and its five children: thermal, gear-shift and dry-run as SpindleScalars, power and torque as SpindleContour. wwwroot-src/src/components/controlTree/itemTypes.ts — registers those three item types and gives all of them the same CONTENT-column view. wwwroot-src/src/components/controlTree/SpindleCapabilityPanel.vue — the branch root panel: the Object Management button, the name caption, the not-attached empty state, and the Name / Note fields. wwwroot-src/src/components/controlTree/SpindleScalarsPanel.vue — one scalar section per role path: thermal, gear-shift (checkbox plus the rpm field, disabled while the value is null) and dry-run. wwwroot-src/src/components/controlTree/SpindleContourPanel.vue — the power / torque child: the count line, Add, the contour selector, the edit-duration modal and the delete button, hosting the point editor. wwwroot-src/src/components/spindle/SpindleContourEditor.vue — the selected contour's numeric points table; its own header is hidden when the tree panel drives it. wwwroot-src/src/components/spindle/SpindleContoursPanel.vue — the CONTENT-column view every spindle item registers: both charts. wwwroot-src/src/components/spindle/SpindleContoursChart.vue — one plotted chart with the clickable chip legend that selects the contour the editor edits, plus the gear-shift marker line. wwwroot-src/src/components/controlTree/ContentSlavePanel.vue — the General Setup page's CONTENT column, which mounts whichever content panel the selection's item type registers; it deliberately leaves that component unkeyed so the charts survive a move between the branch's six nodes. wwwroot-src/src/composables/useSpindleCapability.ts — the module-singleton state and every mutation on the branch: the scalar handlers, add / remove / rename contour, the point updates and the object-management install hooks. wwwroot-src/src/components/widgets/ObjectManagementMenuButton.vue — the reused ⋮ menu carrying Load / Save As / Copy / Paste / XML for the .SpindleCapability file surface. wwwroot-src/src/api/spindleCapability.ts — typed client for /api/mech/spindle-capability/*. wwwroot-src/src/router/routes.ts — the spindle-capability/:tab? redirect (the tab mapped onto the branch child id) and the equipment/spindle redirect, both landing on general-setup?tree=…. wwwroot-src/src/router/treeRoutes.ts — defines the tab segments that redirect accepts: thermal, gear-shift, dry-run, power, torque. Mech/SpindleCapabilityController.cs — REST surface at /api/mech/spindle-capability over the authored equipment face's capability: GET / — flat snapshot: metadata plus the contour keys of each axis. GET /power-contours, GET /torque-contours — per-axis contour lists with their points. PUT /name | /note | /energy-efficiency | /working-temperature-upper-boundary-c | /gear-shift-spindle-speed-rpm | /dry-run-friction-power-coefficient-mwdrpm | /dry-run-windage-power-coefficient-pwdrpm3 — one scalar each. POST /power-contours | /torque-contours — add one contour. DELETE /power-contours/{key} | /torque-contours/{key} — remove one contour ({key} accepts numeric strings and \"inf\" / \"infinity\"). PUT /power-contours/{key}/points | /torque-contours/{key}/points — replace one contour's points; this is what backs per-point editing. PUT /power-contours/{key}/key | /torque-contours/{key}/key — rename a contour's workable-duration key, refusing a key that already exists; this is what backs the edit-duration modal. GET /xml — serialise to XML text. POST /load, POST /load-file, POST /reload — install from XML text, from a file under a named root, or from the file already stamped on the equipment. PUT /capability-file — set the side-file reference without reloading. POST /initialize, POST /update — index the capability for the Object Management button, and install the swapped-in object back onto the equipment. HiAPI Engine HiMech/Milling/SpindleCapability.cs — the model: EnergyEfficiency, WorkingTemperatureUpperBoundary_K with its _C accessor, the nullable GearShiftSpindleSpeed_cycleds with its _rpm convenience property, the two dry-run coefficients and the power / torque contour dictionaries keyed by workable duration. HiMech/Machining/MachiningEquipmentUtils/SetupEquipment.cs — the authored equipment face that owns the capability and its file reference and serializes them, inline or as a side-file reference. See Also Mechanism Builder Page — same file-level IO pattern (Load / Reload / Save As) but user-scoped rather than project-scoped. Background / Coolant — sibling branch of the same Control Tree, editing the same authored equipment face. Spindle Capability — what the model represents physically and how the per-step ratios come out of it."
  },
  "anatomy/general-setup/workpiece.html": {
    "href": "anatomy/general-setup/workpiece.html",
    "title": "Workpiece | HiAPI-C# 2025",
    "summary": "Workpiece The Workpiece editor is the equipment/workpiece branch of the General Setup page's Control Tree (/general-setup?tree=equipment/workpiece); the old /workpiece route redirects there. The key model is Workpiece, taken from the Main Panel's Workpiece. The cached solids it is drawn from belong to WorkpieceService. The branch has no display config of its own: it shares the General Setup canvas, gated by the equipment-setup config (Disp/EquipmentSetupDisplayeeConfig.cs), which carries the fixture and workpiece flags together — the fixture and workpiece geometry anchors keep separate flags, while the fixture↔workpiece buckle pair, being one attached identity at one location, is a single flag. Layout Control Tree Branch Workpiece Root — a summary panel, rendered inline by the dock's primary editor pane. It carries no Object Management button: the workpiece has no standalone .Workpiece file surface here, and its geometry, anchors, mesh and material are all edited through the child items below. Raw Geometry Type Badge and Target Geometry Type Badge (none when the slot is empty) Intro caption, and an empty-state caption while the project has no workpiece equipment/workpiece/raw-geometry — “Raw Geometry”, a Geometry slot backing InitGeom. The slot's own panel is the kind picker (Geometry Management Control, selector only); the picked kind's editor is the slot's child item. Kinds offered: Box3d, Cylindroid, StlFile, TransformationGeom, GeomCombination, CubeTreeFile, plus None. ExtendedCylinder is an IMakeXmlSource and was offered here until its start section — wired by a host, never serialized — was found to reload a saved project degenerate; see Extended Cylinder Panel for what an older project holding one still shows. The source choice folds into that one picker — picking the voxel CubeTreeFile, which the picker shows as MeshedGeomFile, is the meshed source (see Meshed Geometry Panel). equipment/workpiece/target-geometry — “Target Geometry”, the same slot shape backing IdealGeom. Kinds offered: Box3d, Cylindroid, StlFile, TransformationGeom, plus None. The target must satisfy IGetStl, so CubeTreeFile is not among them. equipment/workpiece/anchor — “Anchor”, a Group stem whose info text states how the workpiece is placed. Two Transformer slots hang from it, each a kind picker (Transformer Manage Panel) over the picked kind's child editor: .../anchor/geom-to-fixture — “Geom To Fixture”, which positions the workpiece geometry on the fixture's workpiece buckle (see Fixture). .../anchor/geom-to-program-zero — “Geom To Program Zero”, which places the program zero, the NC origin, relative to the workpiece geometry. equipment/workpiece/runtime — labelled Mesh in the tree. Initial Resolution Select (InitResolution, in mm), a fifteen-step powers-of-two ladder: 0.0009765625 0.001953125 0.00390625 0.0078125 0.015625 0.03125 0.0625 0.125 0.25 0.5 1 2 4 8 16 Hint caption: a smaller resolution means a finer voxel grid and a slower runtime simulation. The engine's own ladder bottoms out at 0.001953125, so the first entry builds the same mesh as the second. Values typed in from elsewhere are rounded to the next finer rung rather than used as given — see Mesh Resolution. The panel self-gates on the project having a workpiece. equipment/workpiece/material — “Material”, a Group stem whose info text names the two pre-prepared resources loaded by reference. Present whenever the project has a workpiece; nothing on this branch gates it on a physics flag. Its two children share one panel, which reads its role from the node's own path: .../material/workpiece-material — .WorkpieceMaterial files, seeded to the resource root's WorkpieceMaterial folder. .../material/cutting-parameter — .mp files, seeded to the resource root's CuttingParameter folder. Each child is one Resource-only File Path Input — the project-directory Browse entry is suppressed, leaving the Resource-root pick — plus a readonly Name field (Name) and a readonly Note field (Note). Page Frame The General Setup page lays the tree dock, the content column and the equipment canvas out in nested splitters with device-local widths; inside the dock, a height divider between the Control Tree row and the primary editor row trades their heights. See General Setup Page. Canvas Column — one RenderingCanvas bound to the equipment-setup displayee (Disp/EquipmentSetupDisplayee.cs): the merged fixture + workpiece setup scene, with optional machine and tool solids. RenderingCanvas Tool Bar Display Options Menu — six groups; the workpiece's own entries are in bold: Solid — Machine, Tool, Meshed Geometry Fixture Rendering Mode — Solid / Edge / Hide Raw Shape Rendering Mode — Solid / Edge / Hide Target Shape Rendering Mode — Solid / Edge / Hide Anchors — Fixture Geometry Anchor, Workpiece Buckle (the one flag for the fixture↔workpiece pair), Table Buckle, Workpiece Geometry Anchor, Program-Zero Anchor, Controller Coordinate Display Aids — Dimension Bar Default Resource The default resources of Workpiece Material and Cutting Parameter exist in Resource folder under application folder (Not project folder). Both clients seed their file pickers at the matching Resource sub folder: “Resource/WorkpieceMaterial” “Resource/CuttingParameter” Behavior A geometry slot's edit re-commits the swap-in before clearing the cache. The canvas draws the runtime face's solids, and that face follows an authored edit only by rebuild, so a bare cache clear would re-solidify a stale face. The re-commit is skipped when the slot is cleared to None: None leaves the old object indexed, and re-committing would resurrect it. Call WorkpieceService.ClearRawGeomCache() on Raw Shape set or changed. Call WorkpieceService.ClearIdealGeomCache() on Target Shape set or changed. The branch reaches that service by posting the controller's cache-clear endpoints. Anchor edits re-commit their transformer and deliberately do not clear the geometry cache, so a placement change forces no CubeTreeFile re-mesh. The Mesh item's Initial Resolution feeds the runtime voxel simulation, not the setup canvas, so no cache chain runs after a change. The equipment canvas snaps to the isometric view when its displayee is bound to a rendering connection; a shape edit on the branch re-commits and clears the cache so the next frame re-solidifies, and leaves the view alone. Keep Portability of the Material properties. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/useControlTreeHost.ts — builds the whole equipment/workpiece branch: the root, the two geometry slots, the anchor group with its two transformer slots, the Mesh item and the material group with its two resource items — including each slot's re-commit-then-clear chain and the two allowed-kind whitelists. wwwroot-src/src/components/controlTree/PrimarySlavePanel.vue — renders the root inline: the Raw and Target type badges plus the intro. wwwroot-src/src/components/controlTree/itemTypes.ts — the ItemType registry mapping the branch's children to their panels. wwwroot-src/src/components/controlTree/GeometrySlotPanel.vue — the kind picker behind the raw and target geometry slots. wwwroot-src/src/components/controlTree/TransformerSlotPanel.vue — the kind picker behind the two anchor slots. wwwroot-src/src/components/controlTree/WorkpieceRuntimePanel.vue — the Mesh item's editor: the Initial Resolution ladder and its hint. wwwroot-src/src/components/controlTree/WorkpieceResourcePanel.vue — the one panel both Material children share, choosing its extension and resource subfolder from the node's role path. wwwroot-src/src/components/widgets/FilePathInput.vue — the file field those children use; its project Browse entry is suppressed under resourceOnly, leaving the Resource-root pick. wwwroot-src/src/components/mech/EquipmentSetupPanel.vue — the canvas column and its Display Options menu. wwwroot-src/src/pages/GeneralSetupPage.vue — the /general-setup page hosting the tree dock, the content column and the canvas in nested splitters. wwwroot-src/src/api/workpiece.ts — typed client for /api/Workpiece/*: initialize, status, the geometry re-commit and cache-clear calls, the two anchor transformer updates, init-resolution, the two resource loads and the diff settings. wwwroot-src/src/api/equipmentSetup.ts — typed client for the shared canvas: the three rendering-mode targets and the ten display flags, several of which are the workpiece's own overlays. Mech/WorkpieceController.cs — the model REST surface at /api/Workpiece: geometry install and cache clears, the anchor transformer updates, init-resolution, workpiece-material/load, cutting-parameter/load, and the geometry-diff settings pair (visual radius and detection radius) whose menu rides the Execution Extended Tool Bar rather than this branch. Mech/EquipmentSetupDisplayController.cs — /api/mech/equipment-setup-display: binds the equipment-setup displayee to a rendering connection, framing it isometrically at bind time, and serves the rendering-mode and flag endpoints. Disp/EquipmentSetupDisplayee.cs — the merged fixture + workpiece setup scene the canvas draws. Disp/EquipmentSetupDisplayeeConfig.cs — its config: the fixture and workpiece display flags in one place."
  },
  "anatomy/geom/box3d-control.html": {
    "href": "anatomy/geom/box3d-control.html",
    "title": "Box3d Control | HiAPI-C# 2025",
    "summary": "Box3d Control The Box3d editor edits an axis-aligned Box3d through four vector rows — Min, Max, Dimension and Center — of which an Edit Mode selector decides which two are writable. It is reached wherever a Geometry slot admits the Box3d kind: a Control-Tree kind node under a Geometry slot, or the geometry switchboard embedded inline. Layout Edit Mode — a selector over three modes. Its internal values are MinMax, MinDimension and CenterDimension, labelled “Min / Max”, “Min + Dimension” and “Center + Dimension”. Min, Max, Dimension, Center — four vector rows, one X / Y / Z input each. The editor captions Dimension “Dimension (Max − Min)” and Center \"Center ((Max + Min) / 2)\"; the Min and Max captions come from the shared label set rather than the geometry one. The mode rules each row read-only or editable rather than showing a different set of rows: Min is read-only in Center + Dimension, Max in anything but Min / Max, Dimension in Min / Max, and Center in anything but Center + Dimension. Key Model Only Min and Max are settable on the type; Dim and Center are derived and get-only. That is why the other two modes are arithmetic over the same two stored corners rather than a different storage shape — and that arithmetic happens in the browser, which then posts the resulting Min and Max. Behavior A row commits on blur or Enter, not per keystroke. The vector widget emits only from its blur handlers, suppresses the emit when the parsed value is unchanged, and reverts an unparseable entry to its previous value. This editor has no read-only variant. A host that needs one draws its own rows instead — the STL file editor's read-only bounding-box rows are not this editor. Four endpoints ship without a caller. The controller exposes UpdateByMinDimension, UpdateByCenterDimension, IndexDimension and IndexCenter; the shipped SPA calls none of them, because the editor resolves every mode to a plain Update. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/geom/Box3dEditor.vue — the editor: the Edit Mode selector, the four vector rows and their per-mode read-only rules, and the client-side arithmetic behind the two derived modes. Its only prop is the IndexService key. wwwroot-src/src/components/widgets/Vec3Input.vue — the X / Y / Z row widget, in standard or single-field text mode; its readonly prop is what the edit mode drives. wwwroot-src/src/components/geom/geometryEditors.ts — maps the Box3d kind to this editor, the single map both the switchboard and the Control Tree resolve through. wwwroot-src/src/components/geom/GeometryEditor.vue — the kind picker that creates a Box3d and, outside selector-only mode, embeds this editor beneath itself. wwwroot-src/src/components/controlTree/itemTypes.ts — registers Box3d against the sole-editor panel and lists it among the kinds a container may hold. wwwroot-src/src/components/controlTree/SoleEditorPanel.vue — the kind node's panel, resolving Box3d through the kind map and binding the editor to the node's key. wwwroot-src/src/components/controlTree/GeometrySlotPanel.vue — the Geometry slot's picker, from which a Box3d is chosen. wwwroot-src/src/api/geometry.ts — getBox3d, indexBox3dMin, indexBox3dMax and the create entry. There is deliberately no update wrapper here; the editor posts the update itself. wwwroot-src/src/i18n/en/geom.ts — the box.* and bounds.* strings, and wwwroot-src/src/i18n/en/common.ts — the shared Min and Max row captions. Geom/Box3dController.cs — REST endpoints at /api/Box3d/*: New, NewWithValue, Get, Update, IndexMin, IndexMax, IndexDimension, IndexCenter, UpdateByMinDimension and UpdateByCenterDimension. Common/IndexService.cs — the keyed object store every box key resolves against. See Also Geometry Management Panel — the switchboard that offers this kind and hosts this editor"
  },
  "anatomy/geom/cylindroid-control.html": {
    "href": "anatomy/geom/cylindroid-control.html",
    "title": "Cylindroid Control | HiAPI-C# 2025",
    "summary": "Cylindroid Control The Cylindroid editor edits a Cylindroid — a solid of revolution defined by a list of (Z, R) pairs — as a table of rows, with a minimum of two. It is reached from any Geometry slot that admits the Cylindroid kind, and again from the Tool House cylindroid holder, whose Geometry node embeds the same editor directly. Layout Z-R pairs — a header row carrying the section label and an Add button. Add appends a row ten millimetres above the last one, at the same radius. The table — one row per pair, columns #, Z (mm) and R (mm). Each Z and R cell is an inline text field parsed as a number; there is no spinner. A per-row remove button sits at the end of each row, disabled once only two pairs remain. The caption — a one-line statement of the type: a solid of revolution defined by (Z, R) pairs, minimum two. Behavior A cell commits on blur or Enter. An empty or non-finite entry is dropped rather than written, and a negative radius is clamped to zero — on the client and again on the server. The floor is two pairs, and both ends enforce it. The remove button is disabled at two and the controller refuses the call below two. Creating one seeds three pairs. The create endpoint starts a new cylindroid at (0, 20), (30, 20) and (60, 10) rather than empty. Four endpoints ship without a caller. The controller exposes GetPairCount, GetPairAt, UpdatePairAt and SortByZ; the shipped SPA uses none of them, committing the whole list instead. Tessellation Resolution Is Not a Property of the Shape There is no longitude count, and no per-instance resolution, on a cylindroid. The STL longitude number is derived internally at generation time from a resolution the caller supplies; the type carries only a static default. Where resolution is exposed, it belongs to the holder rather than to the shape: the Tool House cylindroid holder carries a Resolution tree node beside its Geometry one, offering a linear resolution in millimetres and an angle resolution in degrees, described in the app as the tessellation resolution used for display and collision meshing. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/geom/CylindroidEditor.vue — the editor: the header row and Add button, the Z / R table with its per-cell commit, and the per-row remove and its two-pair floor. Edits by IndexService key and emits changed so the owner can resync. wwwroot-src/src/components/geom/geometryEditors.ts — maps the Cylindroid kind to this editor. wwwroot-src/src/components/geom/GeometryEditor.vue — the kind picker that creates a Cylindroid and embeds this editor beneath itself. wwwroot-src/src/components/controlTree/itemTypes.ts — registers Cylindroid against the sole-editor panel and lists it among the kinds a container may hold. wwwroot-src/src/components/controlTree/SoleEditorPanel.vue — the kind node's panel. wwwroot-src/src/components/controlTree/toolhouse/HolderSectionPanel.vue — the second host: it embeds this editor on the holder's cylindroid key for the Geometry node, and renders the linear and angle resolution fields for the sibling Resolution node. wwwroot-src/src/components/controlTree/toolHouseItemTypes.ts — grows those two holder children, and only for a cylindroid holder. wwwroot-src/src/api/geometry.ts — getCylindroid, updateCylindroidPairs, addCylindroidPair, removeCylindroidPairAt and the create entry. wwwroot-src/src/api/cylindroidHolder.ts — the holder side: the cylindroid key it exposes, the geometry update, and the resolution setter. wwwroot-src/src/i18n/en/geom.ts — the cylindroid.* strings, and wwwroot-src/src/i18n/en/toolhouse.ts — the Resolution node's own labels and hint. Geom/CylindroidController.cs — REST endpoints at /api/Cylindroid/*: New, Get, GetPairCount, GetPairAt, UpdatePairAt, UpdateAllPairs, AddPair, RemovePairAt and SortByZ. Mech/CylindroidHolderController.cs — the holder surface at /api/CylindroidHolder/* behind the Tool House host. Common/IndexService.cs — the keyed object store every cylindroid key resolves against. See Also Geometry Management Panel — the switchboard that offers this kind and hosts this editor Cylindroid Holder Panel — the second host, and the surface that owns the tessellation resolution"
  },
  "anatomy/geom/extended-cylinder-panel.html": {
    "href": "anatomy/geom/extended-cylinder-panel.html",
    "title": "Extended Cylinder Panel | HiAPI-C# 2025",
    "summary": "Extended Cylinder Panel The Extended Cylinder editor edits one number on an ExtendedCylinder: its full length, measured from Z=0 and including the span below the start section. Its only home on it is the Tool House cutter's Upper Beam, where the start section is the flute top. Layout An explanatory block stating what the type is and, in bold, how the length is measured. Full Length — a single numeric field in millimetres, with a hint under it. Behavior The hint states a lower bound only when that bound is positive. The bound is the Z of the start section, served with the value as minFullLength; above zero the hint reads “must exceed the start-section Z”, and at zero it degrades to a plain “full length from Z=0”. The test is the number, not the wiring — a geometry with no start-section source and one whose source sits at Z=0 read identically here, because the controller answers 0 for both. There is no upper bound anywhere — not in the editor and not in the controller. A live bound belongs to the cutter alone. The bare create endpoint installs a constant start pair at Z=0, and the container-aware create switches install no source at all; both answer a bound of zero. Only the cutter upper beam wires a real one — setting the beam links it to the flute top — so only there does a bound appear. The guard is two layers, and they differ by one. The numeric field rejects a value below the minimum — its minimum is inclusive — so a value exactly equal to the bound passes the field and is caught one layer up by the editor, which raises an error to its host as a banner rather than an inline field message. The controller then rejects non-finite, non-positive, and at-or-below-bound values with a 400. The field commits on blur or Enter, and the range guard runs on both the field and the backend. Creating one through the cutter is not the same as creating one bare. The Upper Beam creates through the cutter's own endpoint so the backend seeds a valid full length and can return geometry-issue warnings — which the Upper Beam panel renders as persistent banners. The bare create endpoint seeds a length of 100 and a single start pair. Reach This kind is restricted to the cutter's upper beam, and the mechanism is absence rather than a flag: no Geometry slot offers it at all. it is absent from the container kinds, so it can be neither a transformation geometry's inner geometry nor a combination child, and it was taken out of the workpiece's raw geometry once a saved project was found to reload one degenerate. The single surface that offers it is the cutter's Upper Beam, which mounts the switchboard itself over its own six-kind list rather than being a Geometry slot. Note A project saved earlier can still carry one on a workpiece, and the two halves of the tree disagree about it. The kind is serialized; only the start-section hookup is not. Such a project reloads with the raw geometry in place, and the Geometry slot's child builder tests the type against the whole kind map rather than against the slot's whitelist, so the ExtendedCylinder kind node and this editor still appear beneath it. The slot's own picker tests the whitelist, finds the type outside it and blanks — leaving an empty type dropdown above a child node that edits an Extended Cylinder. The bound reads zero there, because nothing is wiring a start section. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/geom/ExtendedCylinderEditor.vue — the description block and the Full Length field, its hint, and the at-or-below-bound check that raises an error to the host. wwwroot-src/src/components/widgets/NumericInput.vue — the shared numeric field: an inclusive minimum rejected on blur, and the hint slot under it. wwwroot-src/src/components/toolhouse/UpperBeamDiv.vue — the component's real home: the cutter's Upper Beam, which creates through the container-aware cutter endpoint and renders the returned geometry-issue warnings. wwwroot-src/src/components/controlTree/toolhouse/CutterSectionPanel.vue — mounts that panel for the cutter's Upper Beam node, and deliberately skips its own fetch there. wwwroot-src/src/components/controlTree/toolHouseItemTypes.ts — builds the Upper Beam child of the Cutter node. wwwroot-src/src/components/geom/geometryEditors.ts — maps the ExtendedCylinder kind to this editor. wwwroot-src/src/components/geom/GeometryEditor.vue — the kind picker. wwwroot-src/src/components/controlTree/itemTypes.ts — registers ExtendedCylinder against the sole-editor panel, is where its absence from the container kinds is declared, and holds the Geometry slot's child builder — the half that tests the whole kind map rather than the whitelist. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — the workpiece raw-geometry whitelist, and the comment recording why the kind is no longer in it. wwwroot-src/src/api/geometry.ts — getExtendedCylinder, updateExtendedCylinderFullLength and the create entry. wwwroot-src/src/api/toolHouse.ts — the upper-beam get, create and resync wrappers, and the warnings contract. wwwroot-src/src/i18n/en/geom.ts — the extCylinder.* strings: the label, the description and measure rule, both hints, and the below-minimum error. Geom/ExtendedCylinderController.cs — REST endpoints at /api/ExtendedCylinder/*: New, Get, UpdateFullLength and GetFullLength. Get carries minFullLength alongside the value. Mech/CutterController.cs — the upper-beam routes the Tool House host actually goes through, and the geometry-issue warnings it surfaces. Mech/WorkpieceController.cs — the raw-geometry create switch, which still carries an ExtendedCylinder arm that no picker can now reach. See Also Geometry Management Panel — the switchboard that offers this kind and hosts this editor Milling Cutter Panel — the cutter whose Upper Beam is this editor's real home, and the one surface that supplies a start section"
  },
  "anatomy/geom/geom-combination-control.html": {
    "href": "anatomy/geom/geom-combination-control.html",
    "title": "Geometry Combination Control | HiAPI-C# 2025",
    "summary": "Geometry Combination Control A GeomCombination is several geometries treated as one, and it has two faces: an inline editor that renders every child's own editor at once, and a Control-Tree panel that manages the list only and puts each child on its own node. There is no selection model on either — every child carries its own remove button. Layout The inline editor Add bar — a child-kind picker beside an Add button, and a Clear all button. One card per child, each with a #n index badge, the child's type name, its own remove button, and — in the card body — that child's full editor, rendered recursively. All children are editable at once. The Control-Tree panel Deliberately shallow: a list of read-only rows with Add, a per-row remove and Clear all, and a standing hint that an Item child node is where a child is actually edited. No editor is embedded here; each child is its own Item node — .../item-{index} — under this one. Adding a Child Pick the kind first, then Add; the request carries the kind. Five kinds may be children — Box3d, Cylindroid, StlFile, TransformationGeom and a nested GeomCombination, so combinations nest arbitrarily deep. CubeTreeFile and ExtendedCylinder are accepted by neither switch. Behavior A type switch rewires the slot, not just the alias. Changing a child's kind goes through SetItemAt, which replaces the entry in StlSources itself. The aggregate STL is cached, and a child's own controller does not invalidate it. Editing a child through its own endpoints leaves the combination returning the mesh it had already built, so both faces call CleanCache before bubbling the change, and compose that call into the ancestor chain. This is the behavioural fact the rest of the page depends on. Removing a child does not renumber the ones after it. Item keys are minted as {key}-item-{index} and the remove endpoint leaves later indices pointing at the old aliases, which is why every structural change rebuilds the branch and re-mints them. Clear all is posted directly, with no confirmation. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/geom/GeomCombinationEditor.vue — the inline face: the Add bar, the per-child cards, and the recursive editor in each. Type switches route through SetItemAt, a cache clean precedes every changed bubble, and item aliases are released on refresh and unmount. wwwroot-src/src/components/controlTree/GeomCombinationTreePanel.vue — the Control-Tree face: list management only, emitting a structure change so the host re-mints the item aliases. wwwroot-src/src/components/controlTree/itemTypes.ts — registers the kind against that panel with a child builder that mints one Item node per element, and declares the five container kinds a child may be. wwwroot-src/src/components/geom/geometryEditors.ts — maps the GeomCombination kind to the inline editor. wwwroot-src/src/components/geom/GeometryEditor.vue — the recursive kind picker each child card embeds. wwwroot-src/src/components/controlTree/GeometrySlotPanel.vue and wwwroot-src/src/components/controlTree/SoleEditorPanel.vue — an Item node's picker and, once a kind is chosen, that kind's editor. wwwroot-src/src/components/geom/TransformationGeomEditor.vue — the nesting host: a combination is an allowed inner geometry. wwwroot-src/src/components/controlTree/useControlTreeHost.ts, wwwroot-src/src/pages/MechBuilderPage.vue and wwwroot-src/src/components/toolhouse/UpperBeamDiv.vue — the slots that admit the kind: the fixture geometry, the workpiece raw geometry, a mechanism anchor's geometry and the cutter upper beam. The workpiece's target geometry deliberately does not. wwwroot-src/src/api/geometry.ts — getGeomCombination, addGeomCombinationItem, setGeomCombinationItemAt, removeGeomCombinationItemAt, clearGeomCombination, cleanGeomCombinationCache and indexGeomCombinationItemAt, with the child-kind and combination types and the create entry. wwwroot-src/src/api/index-service.ts — the index release the editor uses to drop item aliases. wwwroot-src/src/i18n/en/geom.ts — the combination.* strings, and wwwroot-src/src/i18n/en/tree.ts — the tree panel's own strings and the Item node label. Geom/GeomCombinationController.cs — REST endpoints at /api/GeomCombination/*: New, Get, GetCount, AddItem, SetItemAt, RemoveItemAt, Clear, CleanCache, IndexItemAt and GetItemTypeAt. AddItem and SetItemAt share one five-arm kind switch and both clean the cache. Geom/TransformationGeomController.cs, Mech/FixtureController.cs, Mech/WorkpieceController.cs, Mech/MechBuilder/GeneralMechanismController.cs and Mech/CutterController.cs — the container-aware create switches behind each host's onCreate. See Also Geometry Management Panel — the switchboard that offers this kind, and the panel each child card embeds"
  },
  "anatomy/geom/geom-manage-control.html": {
    "href": "anatomy/geom/geom-manage-control.html",
    "title": "Geometry Management Panel | HiAPI-C# 2025",
    "summary": "Geometry Management Panel The geometry switchboard is one control: a kind picker over the kinds its host allows, and — unless the host asked for the picker alone — the picked kind's editor beneath it. It binds a key into the shared object store, not an object, and every Control-Tree Geometry slot is this same control in selector-only mode. Layout Web: a geometry-type dropdown; a separator, drawn only while a kind is active; then that kind's editor. Picking a kind commits immediately — there is no Apply button. In selector-only mode everything below the dropdown is dropped, which is the form each Geometry slot node shows. What It Binds The web panel has no target-geometry property. It takes a modelKey naming the object it edits and mutates what sits behind that key; a host that also owns the field holding the geometry passes an onCreate hook, so switching the kind rebinds the host's field rather than just the key. Each host's field type decides which kinds it may offer; whether the kind survives a save decides which of those it does. A fixture's geometry and a transformation geometry's inner geometry are IGetStl; a workpiece's initial geometry is an IMakeXmlSource, which is why the cube-tree file — which is not an IGetStl — reaches that picker and no other. Type compatibility alone is not sufficient, and ExtendedCylinder is the case that shows it. It is an IMakeXmlSource, so the workpiece's raw slot could hold one and once did — but its start section is supplied by a host at run time and is not serialized, so a saved project reloaded it with a zero-radius start and the shape degenerated. The kind is now offered by the one host that wires that source, the cutter's upper beam. Reach The picker's own default is six of the seven kinds: Box3d, Cylindroid, StlFile, TransformationGeom, GeomCombination and CubeTreeFile. ExtendedCylinder is in the kind map but out of that default: a host that can wire its start section names it explicitly. Nothing is hidden by a flag. The default is a guard rail, not a shipped list. Every host passes its own whitelist — the five Control-Tree Geometry slots from the node context, the four inline hosts as a constant — so no shipped surface renders the default at all, and the whitelist is what really decides reach. Host Kinds offered Fixture geometry, mechanism anchor, a transformation geometry's inner geometry, a combination child the five container kinds — Box3d, Cylindroid, StlFile, TransformationGeom, GeomCombination Workpiece raw geometry six — the five container kinds plus CubeTreeFile Workpiece target geometry four Cutter upper beam six — Cylindroid, ExtendedCylinder, TransformationGeom, StlFile, Box3d, GeomCombination A null geometry is a legal state of the model, but the web picker offers its None (unset) entry only when the host asks for it: the three General Setup slots and a transformation geometry's inner geometry do, while the mechanism anchor, the cutter upper beam and combination children do not, so those pickers cannot clear the slot. Clearing goes through the host's create hook with the literal kind None, which the container-aware endpoints map to null. There Is No Way to Wrap an Existing Geometry Wrapping a geometry that is already in a slot into a TransformationGeom — and extracting it back out — is not offered anywhere in the application, and the difference from what the picker looks like it does is not cosmetic. Picking TransformationGeom creates a new, empty one and discards the geometry that was there. The same holds for a combination: there is no operation that takes a geometry and puts a container around it in place. In the Control Tree Geometry is a slot item type. Its child builder probes the slot's key for the type behind it and, when that type is a known kind, grows exactly one child node of that kind bound to the same key — so the slot node carries the picker and its single child carries the editor. Five kinds resolve to the shared sole-editor panel; TransformationGeom and GeomCombination instead map to panels of their own, because they grow further slot children rather than hosting one editor. The two file-backed kinds compose the referenced file into their node label. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/geom/GeometryEditor.vue — the switchboard: the kind picker over the allowed kinds, the opt-in unset entry, the immediate commit through the create hook, and the active kind's editor. wwwroot-src/src/components/geom/geometryEditors.ts — the single kind → editor map both this picker and the Control Tree's sole-editor panel resolve through. wwwroot-src/src/components/controlTree/GeometrySlotPanel.vue — the slot node's panel: this switchboard in selector-only mode, fed its allowed kinds, its unset flag and its create hook from the node. wwwroot-src/src/components/controlTree/SoleEditorPanel.vue — the kind child's panel. wwwroot-src/src/components/controlTree/itemTypes.ts — registers Geometry as a slot type with its child builder, registers each kind against its panel, and holds both the container-kind list and the file-backed node labels. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — the three General Setup Geometry slots and their per-host kind whitelists. wwwroot-src/src/pages/MechBuilderPage.vue and wwwroot-src/src/components/toolhouse/UpperBeamDiv.vue — the two inline, non-tree hosts. wwwroot-src/src/api/index-service.ts — the type probe the picker calls to discover which kind is currently behind the key. wwwroot-src/src/api/geometry.ts — the kind union, the create dispatcher and its per-kind endpoint map, and every per-kind call. wwwroot-src/src/api/fixture.ts, wwwroot-src/src/api/workpiece.ts, wwwroot-src/src/api/toolHouse.ts and wwwroot-src/src/api/generalMechanism.ts — the container-aware create wrappers each host's hook posts through. wwwroot-src/src/i18n/en/common.ts and wwwroot-src/src/i18n/en/geom.ts — the picker's label and its unset and empty-state strings. Geometry type names are deliberately not translated. The seven per-kind controllers under Geom/ — Geom/Box3dController.cs, Geom/CylindroidController.cs, Geom/ExtendedCylinderController.cs, Geom/StlFileController.cs, Geom/CubeTreeFileController.cs, Geom/TransformationGeomController.cs and Geom/GeomCombinationController.cs — each at /api/{Kind}/*. There is no single geometry controller and no geometry hub. Common/IndexController.cs — the type probe at /api/Index/GetType. Common/IndexService.cs — the keyed object store all of the above read and write. There is no per-panel session object. Mech/FixtureController.cs, Mech/WorkpieceController.cs, Mech/CutterController.cs and Mech/MechBuilder/GeneralMechanismController.cs — the container-aware create endpoints that set the host's own field, and the ones that accept None and store null. See Also Mechanism Builder Page — embeds this control under its anchor editor Box3d Control — the kind editors this switchboard resolves Cylindroid Control — the same, for a solid of revolution Extended Cylinder Panel — the same, and the kind exactly one host offers STL File Control — the same, for an STL reference Meshed Geometry Panel — the same, for a voxel cube tree Transformation Geometry Control — one of the container kinds this panel offers, and why picking it replaces rather than wraps Geometry Combination Control — the other container kind, whose every child embeds this panel again"
  },
  "anatomy/geom/index.html": {
    "href": "anatomy/geom/index.html",
    "title": "Geometry Panels | HiAPI-C# 2025",
    "summary": "Geometry Panels The Geometry Panels are the editors for Geometry Objects, together with the switchboard that picks which ITransformer places them. Two switchboards run the folder: the Geometry Management Panel chooses a geometry kind and hosts that kind's editor, and the Transformer Select Panel does the same for a transformer. On the shipped SPA a Control Tree is where both switchboards are usually met. A Geometry slot or a Transformer slot carries the kind picker, and the picked kind becomes the slot's single child node, whose panel is that kind's editor. The same editors are also embedded inline, without a tree — by Transformation Geometry Control for its inner geometry and inner transformer, by Geometry Combination Control for each child, by the Mechanism Builder page, and by the Tool House cutter's upper beam. A page belongs in this folder when it documents one geometry kind's editor, or a switchboard that picks a kind and hosts that editor. The transformer switchboard lives beside the geometry kinds rather than under a route because it sits in the same Control-Tree slot pattern and is embedded by the same editors. Ordered the way the folder builds up: the primitive solids first, then the file-backed geometries, then the operators that wrap and combine them, and last the two switchboards that host all of them. Geometry Kinds Page What it edits Box3d Control A 3D box defined by min/max coordinates Cylindroid Control A cylindroid with radius values along the Z axis Extended Cylinder Panel An ExtendedCylinder and its full length STL File Control An IStlSource loaded from an STL file Meshed Geometry Panel A CubeTreeFile, the pre-computed voxel cube tree; the kind picker shows it as MeshedGeomFile Transformation Geometry Control An inner geometry plus the transformer that places it Geometry Combination Control Several geometries combined into one Every kind above is an ordinary entry in the same geometry kind map, and the switchboard resolves each one the same way. What separates them in practice is reach, not class: each host names the kinds its own model accepts, so CubeTreeFile reaches only the workpiece's raw-geometry picker, and ExtendedCylinder only the cutter's upper beam. Switchboards Page What it hosts Geometry Management Panel The geometry kind picker and the picked kind's editor Transformer Select Panel The transformer kind picker and the picked kind's editor, over all seven transformer kinds Source Code Path See HiNC App Anatomy for git repository links. The editors and the two switchboards: wwwroot-src/src/components/geom/ — the geometry editors, plus wwwroot-src/src/components/geom/GeometryEditor.vue, the geometry switchboard itself. wwwroot-src/src/components/topo/ — the transformer editors, plus wwwroot-src/src/components/topo/TransformerSelectPanel.vue. wwwroot-src/src/components/geom/geometryEditors.ts and wwwroot-src/src/components/topo/transformerEditors.ts — the two kind → editor maps every host resolves an editor through. The Control-Tree glue that makes them reachable: wwwroot-src/src/components/controlTree/GeometrySlotPanel.vue and wwwroot-src/src/components/controlTree/TransformerSlotPanel.vue — the two slot panels, each its switchboard in selector-only mode. wwwroot-src/src/components/controlTree/SoleEditorPanel.vue — the kind node's panel, resolving the node's kind through both maps. wwwroot-src/src/components/controlTree/itemTypes.ts — registers Geometry and Transformer as slot types; the five leaf geometry kinds and all seven transformer kinds against SoleEditorPanel; and TransformationGeom and GeomCombination against their own tree panels, which grow further slot children instead of one editor. The REST controllers, one per kind: Geom/Box3dController.cs, Geom/CylindroidController.cs, Geom/ExtendedCylinderController.cs, Geom/StlFileController.cs, Geom/CubeTreeFileController.cs, Geom/TransformationGeomController.cs, Geom/GeomCombinationController.cs. Mech/Topo/StaticTranslationController.cs, Mech/Topo/StaticRotationController.cs, Mech/Topo/StaticFreeformController.cs, Mech/Topo/DynamicTranslationController.cs, Mech/Topo/DynamicRotationController.cs, Mech/Topo/GeneralTransformController.cs, Mech/Topo/NoTransformController.cs."
  },
  "anatomy/geom/meshed-geom-panel.html": {
    "href": "anatomy/geom/meshed-geom-panel.html",
    "title": "Meshed Geometry Panel | HiAPI-C# 2025",
    "summary": "Meshed Geometry Panel The meshed-geometry editor points a geometry at a pre-computed voxel cube tree in a .wct file. Its model is CubeTreeFile, a reference to that file: neither the editor nor the controller loads the voxel data, which stays deferred until something actually needs the mesh. Important The kind is CubeTreeFile; the label is MeshedGeomFile. The rename is display-only and lives in exactly two registries — the kind picker's option label and the Control-Tree node label — while the value sent to the backend stays the type name. The domain type carries the matching display name of its own. Any page describing a mesh source has to keep the two apart. Layout A caption naming what the field takes, .wct. The file selector — the shared file-path widget, filtered to .wct, with an empty-state hint when nothing is chosen. A standing description: the geometry is a pre-computed voxel cube tree, and loading it is deferred until it is needed. Reach One slot offers this kind: the workpiece's Raw Geometry. The fixture's geometry and the workpiece's target geometry both exclude it, and it is not among the container kinds, so it can be neither a transformation geometry's inner geometry nor a combination child. The Control-Tree node carries the chosen file in its label, as MeshedGeomFile [<path>]. There is no separate geometry-source toggle: picking the MeshedGeomFile kind is choosing the meshed source. The classification survives on the server, which still reports a raw geometry of this type as a meshed one. Key Model CubeTreeFile is the file reference; CubeTree is the voxel tree itself. The reader resolves the stored relative path and opens it with no extension test of its own — .wct is what the app writes and what every user-facing string names, not something the loader enforces. The consumer that reads the data is the equipment-setup scene: it recognises a workpiece whose initial geometry is a cube-tree file and builds the meshed geometry for the canvas, behind the canvas's own Meshed Geometry display toggle. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/geom/CubeTreeFileEditor.vue — the editor: the caption, the .wct file selector and the deferred-loading description. wwwroot-src/src/components/widgets/FilePathInput.vue and wwwroot-src/src/components/widgets/FileExplorerDialog.vue — the picker and the in-app browser it opens. wwwroot-src/src/components/geom/geometryEditors.ts — maps the CubeTreeFile kind to this editor. wwwroot-src/src/components/geom/GeometryEditor.vue — the kind picker, and the display-only rename applied to its option label. wwwroot-src/src/components/controlTree/itemTypes.ts — registers the kind against the sole-editor panel, holds the other half of the rename, builds the node label that carries the file, and is where the kind's absence from the container kinds is declared. wwwroot-src/src/components/controlTree/SoleEditorPanel.vue and wwwroot-src/src/components/controlTree/GeometrySlotPanel.vue — the kind node's panel and the parent slot's picker. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — the workpiece raw-geometry slot, the only slot whose allowed kinds admit it, and the node-label refresh when the file changes. wwwroot-src/src/api/geometry.ts — getCubeTreeFile, setCubeTreeFileSourceFile and the create entry. wwwroot-src/src/i18n/en/geom.ts — the meshedFile.* strings, and wwwroot-src/src/i18n/en/tree.ts — the Raw Geometry slot label. Geom/CubeTreeFileController.cs — REST endpoints at /api/CubeTreeFile/*: New, Get and SetSourceFile, and nothing else. None of them loads the voxel data. Mech/WorkpieceController.cs — the raw-geometry create path, and the classification that still reports this type as a meshed geometry. Common/IndexService.cs — the keyed object store every cube-tree-file key resolves against. Disp/EquipmentSetupDisplayee.cs and Mech/EquipmentSetupDisplayController.cs — the scene that builds the meshed geometry for the canvas, and the display toggle that shows it. See Also Geometry Management Panel — the switchboard that offers this kind and hosts this editor STL File Control — the other file-backed kind, and the one this slot offers beside it"
  },
  "anatomy/geom/stlfile-control.html": {
    "href": "anatomy/geom/stlfile-control.html",
    "title": "STL File Control | HiAPI-C# 2025",
    "summary": "STL File Control The STL file editor points a geometry at an .stl file rather than describing a shape: the model holds a file reference, and the editor is a picker over it plus a read-only summary of what was loaded. The file lives on the server, not on the machine running the browser, and that difference shapes everything else on the page. Layout File reference — a read-only field showing the path currently referenced, with an empty-state hint when there is none. The picker — a Select dropdown whose menu holds Browse…, Browse Resource… and, only while a path is set, Clear. Either Browse entry opens the in-app File Explorer dialog filtered to .stl. There is no reload action. STL info — behind an info icon, opening a dialog that shows the triangle count and the bounding box as read-only vector rows, and states an empty case when nothing is loaded. Behavior The picker browses the server's named roots, not a file system. Three roots are exposed — Project, Resource and Admin — and nothing outside them is reachable. A pick outside the current project is silently re-homed. The update endpoint stores Geom/<filename> rather than the picked location, so saving the project copies the geometry into the project folder. The consequence is visible: after such a pick the read-only field shows the re-homed path, not the one that was chosen. The info dialog refetches on each open, because the bounding box is computed server-side by walking the triangles rather than kept resident. Only Min and Max come back from the server; Dimension and Center are derived in the browser from them. The picker previews. Double-clicking an .stl row in the File Explorer dialog swaps its slave panel to a 3D preview of that file before the pick is confirmed. The dialog opens with that panel hidden, which is why the double-click is the gesture that reaches a preview there; a single click does so only once the toolbar's pencil has revealed the panel. The preview belongs to the File Explorer rather than to this editor — see STL Preview Pane. One endpoint ships without a caller. The controller exposes Reload; nothing in the SPA calls it. Reach StlFile is the least restricted geometry kind. It is allowed in every Control-Tree geometry slot — the fixture's geometry and both of the workpiece's — is one of the container kinds, so it can be a transformation geometry's inner geometry or a combination child, and it is offered by the two inline hosts as well: a mechanism anchor's geometry and the cutter's upper beam. The Control-Tree node carries the referenced file in its own label. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/geom/StlFileEditor.vue — the editor: the caption, the file-path input, and the info dialog with its triangle-count badge and four read-only vector rows. wwwroot-src/src/components/widgets/FilePathInput.vue — the picker widget: the Select dropdown with its Browse, Browse Resource and Clear entries beside a read-only field. wwwroot-src/src/components/widgets/FileExplorerDialog.vue and wwwroot-src/src/components/FileExplorer.vue — the in-app browser the Browse entries open, and the row gestures that swap in the STL preview. wwwroot-src/src/components/StlPreviewPane.vue and wwwroot-src/src/api/stlPreview.ts — that preview and the surface behind it. wwwroot-src/src/components/widgets/Vec3Input.vue — the read-only vector rows in the info dialog. wwwroot-src/src/components/geom/geometryEditors.ts — maps the StlFile kind to this editor. wwwroot-src/src/components/geom/GeometryEditor.vue — the kind picker; it leaves this kind's label verbatim. wwwroot-src/src/components/controlTree/itemTypes.ts — registers StlFile against the sole-editor panel, lists it among the container kinds, and builds the node label that carries the referenced file. wwwroot-src/src/components/controlTree/SoleEditorPanel.vue and wwwroot-src/src/components/controlTree/GeometrySlotPanel.vue — the kind node's panel and the parent slot's picker. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — the three tree slots that admit the kind, and the node-label refresh when the source file changes. wwwroot-src/src/components/geom/TransformationGeomEditor.vue, wwwroot-src/src/components/geom/GeomCombinationEditor.vue, wwwroot-src/src/components/toolhouse/UpperBeamDiv.vue and wwwroot-src/src/pages/MechBuilderPage.vue — the inline hosts that also admit it. wwwroot-src/src/api/geometry.ts — getStlFile, getStlFileInfo, setStlFileSource and the create entry. wwwroot-src/src/i18n/en/geom.ts — the stl.* strings and the bounds.* captions shared with the Box3d editor. Geom/StlFileController.cs — REST endpoints at /api/StlFile/*: New, NewWithPath, Get, GetInfo, UpdateSourceFile, UpdateSource, Clear, GetFileInfo and Reload. UpdateSource is where the re-homing happens; GetInfo answers loaded: false when nothing is cached. Common/NamedRootResolver.cs — the three named roots the picker can reach, and the only three. Common/IndexService.cs — the keyed object store every STL file key resolves against. Mech/WorkpieceController.cs — the workpiece slots' create paths. Disp/StlPreviewController.cs and Disp/StlPreviewService.cs — the picker's preview, loaded onto the caller's own rendering connection and superseded as the selection moves. See Also Geometry Management Panel — the switchboard that offers this kind and hosts this editor Meshed Geometry Panel — the other file-backed kind, and the one the workpiece's raw geometry offers beside this one STL Preview Pane — the preview the picker opens on an .stl row before the pick is confirmed"
  },
  "anatomy/geom/transformation-geom-control.html": {
    "href": "anatomy/geom/transformation-geom-control.html",
    "title": "Transformation Geometry Control | HiAPI-C# 2025",
    "summary": "Transformation Geometry Control A TransformationGeom is an inner geometry plus the transformer that places it, and the editor is those two things side by side. It has two faces: an embedded two-card editor, and a Control-Tree panel that shows only the status of each half and puts the editing on child nodes. Important Choosing a kind here replaces, it does not wrap. Picking an inner geometry calls the container-aware create endpoint, which constructs a fresh instance and discards whatever was there. There is no operation anywhere that wraps an existing geometry into a transformation geometry, or extracts it back out — see Geometry Management Panel. Layout The embedded editor Two bordered cards, each badged with the live type behind it, over a short explanation of what a transformer applied to a geometry means: Inner Geometry (.../inner-geom) — the full Geometry Management Panel, its dropdown labelled Inner geometry type, over five kinds: Box3d, Cylindroid, StlFile, a nested TransformationGeom and GeomCombination — which is what makes recursion and nesting legal — plus a None (unset) entry. Inner Transformer — the Transformer Select Panel, mounted with no kind restriction at all, so its own default of all seven transformer kinds applies. The Control-Tree panel Status badges for the two halves and the same explanation, and nothing editable: the tree grows an Inner Geometry slot and an Inner Transformer slot as children, and each of those grows its own kind child. The registry deliberately overrides the kind → editor map here, so the two-card editor never appears inside a tree. Behavior The identity transformer is the floor. The inner-transformer picker offers no null entry, and the server installs a NoTransform whenever the field is null, so the slot is never unset. Creation is container-aware on both halves. Both go through this type's own create endpoints rather than the generic per-kind ones, so the owning field is rebound and not merely the store entry. The control does not preview. There is no viewport on it. It reports edits upward — one event when a half is mutated, another when a half is replaced — and the hosting page's shared 3D canvas re-renders from there. A null inner geometry has a deterministic key anyway. When the inner geometry is unset the server returns no key, so the editor falls back to a derived alias; without it the picker could never create the first geometry. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/geom/TransformationGeomEditor.vue — the embedded editor: the two cards and their type badges, the two container-aware create hooks, and the fallback alias for a null inner geometry. wwwroot-src/src/components/controlTree/TransformationGeomTreePanel.vue — the Control-Tree face: status only. wwwroot-src/src/components/controlTree/itemTypes.ts — registers the kind against that panel with a child builder that grows the Inner Geometry and Inner Transformer slots, and is where the override of the kind → editor map lives. wwwroot-src/src/components/controlTree/GeometrySlotPanel.vue, wwwroot-src/src/components/controlTree/TransformerSlotPanel.vue and wwwroot-src/src/components/controlTree/SoleEditorPanel.vue — the two child slots' pickers and each kind grandchild's editor. wwwroot-src/src/components/geom/geometryEditors.ts and wwwroot-src/src/components/geom/GeometryEditor.vue — the kind map that reaches this editor, and the switchboard it re-enters for its own inner geometry. wwwroot-src/src/components/topo/TransformerSelectPanel.vue and wwwroot-src/src/components/topo/transformerEditors.ts — the inner-transformer picker and the seven kinds it offers, with the labels it renders them under. wwwroot-src/src/components/geom/GeomCombinationEditor.vue, wwwroot-src/src/pages/MechBuilderPage.vue and wwwroot-src/src/components/toolhouse/UpperBeamDiv.vue — the three embedders of the non-tree form. wwwroot-src/src/api/geometry.ts — the transformation-geometry DTO, the two index calls and the two create calls. wwwroot-src/src/api/transformer.ts — the transformer kind union and the per-kind endpoints the inner transformer's editors bind through. wwwroot-src/src/i18n/en/geom.ts and wwwroot-src/src/i18n/en/tree.ts — the card labels, the explanation, and the two child-node labels. Geom/TransformationGeomController.cs — REST endpoints at /api/TransformationGeom/*: New, Get, IndexGeom, IndexTransformer, CreateGeom, CreateTransformer, UpdateTransformer, GetGeomType and GetTransformerType. IndexGeom answers empty for a null geometry, and IndexTransformer is where the identity default is installed. Geom/Box3dController.cs, Geom/CylindroidController.cs, Geom/StlFileController.cs and Geom/GeomCombinationController.cs — the four other inner-geometry kinds' own surfaces. The seven per-kind transformer controllers under Mech/Topo/ — reached by the inner transformer's editors for their own reads and writes, not for creation, which this type's own endpoint owns. Common/IndexController.cs and Common/IndexService.cs — the type probe both pickers use, and the store the two aliases are registered into. See Also Transformers Geometry Management Panel — the switchboard this editor embeds for its inner geometry, and the only place a wrap or extract exists Transformer Select Panel — the inner-transformer picker and its seven kinds"
  },
  "anatomy/geom/transformer-panel.html": {
    "href": "anatomy/geom/transformer-panel.html",
    "title": "Transformer Select Panel | HiAPI-C# 2025",
    "summary": "Transformer Select Panel The Transformer Select Panel is the switchboard that picks which ITransformer occupies a transformer-valued slot and edits the one that is there. For the model behind the picker — what each transformer does to a frame — see Handle Transform Matrix by ITransformer. Surface The panel's principal home is a Transformer slot of the General Setup page's Control Tree (/general-setup). Four slots on that tree are Transformer slots: equipment/fixture/geom-to-workpiece — “Geom To Workpiece” equipment/fixture/geom-to-table — “Geom To Table” equipment/workpiece/anchor/geom-to-fixture — “Geom To Fixture” equipment/workpiece/anchor/geom-to-program-zero — “Geom To Program Zero” A fifth shape appears wherever a TransformationGeom is grown as a tree node: its .../inner-transformer child is a Transformer slot too. Two surfaces embed the panel outside any tree — the Mechanism Builder Page (/util/mech-builder), for the selected branch's transformer, and the inner-transformer card of Transformation Geometry Control. Layout Transformer Select Panel Transformer Type Dropdown — one dense, outlined q-select listing the kinds this host allows. Its label is the host's label prop, falling back to Transformer type; the inner-transformer card labels it Inner transformer. Picking a kind commits immediately; there is no Apply button. Separator — drawn only when a kind is active. Active Kind's Editor — the component the kind maps to in TRANSFORMER_EDITORS, bound to the IndexService key the picker resolved for the live transformer. The panel takes a selectorOnly prop that drops everything below the dropdown, which gives it two forms: Form Where it is used What renders Embedded (default) Mechanism Builder page; the inner-transformer card of TransformationGeomEditor.vue dropdown, separator, and the active kind's editor in one column Selector only every Control-Tree Transformer slot, through TransformerSlotPanel.vue the dropdown alone In a Control Tree the picker and the editor sit on two different nodes. buildTransformerChildren() grows at most one child under the slot, typed with the current kind, and that child's panel is SoleEditorPanel.vue, which resolves the kind through the same TRANSFORMER_EDITORS map and binds it to the slot's own key. The builder first probes the slot's key with getIndexType and returns no child at all when that probe fails or names a type outside the seven kinds, so a slot holding nothing is a picker with nothing beneath it. Selecting the slot shows the picker; selecting the child shows the kind's editor. Transformer Type Dropdown The dropdown gets and sets the ITransformer behind the bound key. On mount, and again whenever that key changes, it probes the object's type with getIndexType; picking a different kind creates the replacement through POST /api/{Kind}/New unless the host supplied an onCreate hook, in which case that hook runs instead so the owning domain object is rebound alongside the IndexService entry. Which kinds it offers is the allowedKinds prop, defaulting to all seven. A Control-Tree slot feeds it from the node's ctx.allowedKinds; none of the four General Setup slots narrows it, so all seven appear there. When the probed kind falls outside allowedKinds, both the active and the selected kind reset to empty: the dropdown blanks, and the embedded form prints No transformer attached. in place of an editor. The out-of-list transformer is not rendered. Transformer Kinds The web client offers seven kinds, one editor each. Kind Editor What the editor holds StaticTranslation StaticTranslationEditor.vue one Vec3 input, the constant offset StaticRotation StaticRotationEditor.vue axis Vec3 input (with Normalize), angle in degrees, pivot Vec3 input StaticFreeform StaticFreeformEditor.vue a 4×4 matrix grid with Identity and Invert (stored column-major, displayed row-major) DynamicTranslation DynamicTranslationEditor.vue axis Vec3 input (with Normalize) and a step in mm DynamicRotation DynamicRotationEditor.vue axis Vec3 input (with Normalize), angle in degrees, pivot Vec3 input GeneralTransform GeneralTransformEditor.vue a scale field over two embedded sub-transformer cards NoTransform NoTransformEditor.vue an identity-transform notice; no controls The picker offers no null entry: identity is expressed by choosing NoTransform. Note The GeneralTransform editor is a composition, not a flat form: a scale field, then the StaticRotation and StaticTranslation editors embedded in their own bordered cards, titled Rotation sub-transformer and Translation sub-transformer. It keys the two sub-editors off POST /api/GeneralTransform/IndexRotation and /IndexTranslation, edits the scale itself, and owns no vector widget — every Vec3d field on it comes from the nested editors. The effective transform is T × R × scale × I. Key Model ITransformer — the interface the slot holds and the dropdown swaps. StaticTranslation, StaticRotation, StaticFreeform, DynamicTranslation, DynamicRotation, GeneralTransform and NoTransform — the seven implementations the web picker lists. Vec3d — the axis, pivot and translation fields the static and dynamic editors bind. Source Code Path See HiNC App Anatomy for git repository links. The switchboard and its editors: wwwroot-src/src/components/topo/TransformerSelectPanel.vue — the picker, the create call and the optional inline editor; props modelKey / label / allowedKinds / onCreate / selectorOnly, events changed / typeChanged / error. wwwroot-src/src/components/topo/transformerEditors.ts — TRANSFORMER_EDITORS, the single kind → editor map, plus isTransformerKind() and humanizeTransformerKind(). wwwroot-src/src/components/topo/StaticTranslationEditor.vue wwwroot-src/src/components/topo/StaticRotationEditor.vue wwwroot-src/src/components/topo/StaticFreeformEditor.vue wwwroot-src/src/components/topo/DynamicTranslationEditor.vue wwwroot-src/src/components/topo/DynamicRotationEditor.vue wwwroot-src/src/components/topo/GeneralTransformEditor.vue wwwroot-src/src/components/topo/NoTransformEditor.vue The Control-Tree glue and the two direct embedders: wwwroot-src/src/components/controlTree/TransformerSlotPanel.vue — the slot's panel: this switchboard in selector-only mode, fed allowedKinds and onCreate from the node context. wwwroot-src/src/components/controlTree/SoleEditorPanel.vue — the kind node's panel. wwwroot-src/src/components/controlTree/itemTypes.ts — registers Transformer as a slot type with buildTransformerChildren, and each of the seven kinds against SoleEditorPanel. wwwroot-src/src/pages/MechBuilderPage.vue — embeds the panel for the selected branch. wwwroot-src/src/components/geom/TransformationGeomEditor.vue — embeds it for the inner transformer. The transport and the strings: wwwroot-src/src/api/transformer.ts — the TransformerKind union, the per-kind /api/{Kind}/New create endpoints, and the typed wrappers for every update and Index* call. wwwroot-src/src/i18n/en/topo.ts — every string on these panels, including topo.select.noTransformer. Transformer type names are identity and stay verbatim. The REST controllers, one per kind: Mech/Topo/StaticTranslationController.cs Mech/Topo/StaticRotationController.cs Mech/Topo/StaticFreeformController.cs Mech/Topo/DynamicTranslationController.cs Mech/Topo/DynamicRotationController.cs Mech/Topo/GeneralTransformController.cs — also serves IndexRotation and IndexTranslation. Mech/Topo/NoTransformController.cs — New and Get; there is nothing on a NoTransform to update. See Also Mechanism Builder Page — edits a mechanism’s per-branch transformer through this switchboard Transformation Geometry Control — embeds this picker as its inner transformer, with no kind restriction at all"
  },
  "anatomy/index.html": {
    "href": "anatomy/index.html",
    "title": "HiNC App Anatomy | HiAPI-C# 2025",
    "summary": "HiNC App Anatomy Anatomy is the view ↔ model ↔ source reference for the shipped HiNC applications: one page per component, each naming the widget tree the user sees, the HiAPI types behind it, and the files that implement it. It documents how the shipped apps are put together — it is not a build tutorial, and for that see Getting Started. The section is grouped by the surface that owns a page: a folder per live route that hosts a Control-Tree branch or several pages, a single page where a route needs only one, and — where the shipped surface owns nothing, as with a reusable control or a cross-screen rule — the source directory the components actually live in. Important Anatomy makes no claim that Control-Tree ids are stable across versions, and no page may state one. treeRoutes.ts guarantees something narrower: an old id keeps resolving, because each regroup adds a migration hop. The ids themselves have moved repeatedly. Finding the Page From the App What you are looking at Where its anatomy is The window frame, its menu bar and its message bars App Shell /execution, and ?tree=execution/… on it Execution Page — its Mission branch is under Mission /general-setup, and ?tree=equipment/… on it General Setup Page — its Controller branch is under Controller /machine-tool Machine Tool — the route is a read-only preview of the same branch /tool-house/:toolId?/:tab?/:subtab?, and ?tree=toolhouse/… Tool House Page /controller/:tab? Legacy Controller /util/file-explorer, /util/mech-builder Utility Pages /login, /preference/log Platform — the two routes that document the platform rather than a machining step A geometry editor embedded in any of the above Geometry Panels A control that appears on more than one screen Widgets A rule that holds across screens rather than on one Conventions Machinery under every screen — the Control-Tree engine, the ?tree= id surface, the locale bundles, the host process Platform A directory in one of the source trees, rather than a screen By Source Directory Sections Conventions — The rules and shared contracts every page assumes: messaging, file paths, numeric values, the hub patterns, the canvas transport Platform — The machinery every route sits on and no user can point at: the Control-Tree engine, the id and route surface, session state, the locale bundles, the login gate, the log viewer and the host process App Shell — The frame every route renders inside: the Main Panel, its two message bars, and the Preference menu Widgets — The reusable controls pages embed rather than own, most-embedded first Geometry Panels — The primitive solids, the operators that combine and mesh them, and the switchboards that host both Execution Page — The run cockpit: its tool bars, the step column, the charts, and the Mission branch it hosts General Setup Page — The equipment Control Tree: the machine, the spindle envelope, the scene, the fixture, the workpiece and the controller branch Tool House Page — The tool library and the per-tool editor tabs, cutter and holder Legacy Controller — The superseded HardNcEnv controller surface and its REST implementation Utility Pages — The two /util/ routes: the File Explorer and the Mechanism Builder By Source Directory — The same knowledge keyed on the source tree instead of the screen: one directory index per half of the flagship The Two Codebases A page's Source Code Path section lists the files that implement it in the flagship web service. The desktop client's counterparts are not listed at all: it takes no new feature work, and a hand-maintained map of its files went stale faster than anyone read it. The two codebases are not peers. HiNC-2025-webservice is the flagship — a Quasar SPA (Vue 3 + TypeScript + Pinia) served by ASP.NET Core, and the only target for new feature work. Repository: HiNC-2025-webservice.git HiNC-2025-win-desktop is the outgoing WPF client, kept here only so a reader familiar with the desktop UI can find the equivalent web-service component. Do not start new work against it. Repository: HiNC-2025-win-desktop.git Tip The host process, its configuration and the address it listens on are documented in Program and Hosting. Writing a Page Here Name the surface it documents in prose — the route, and where the component lives in a Control Tree, its ?tree= id. Make no claim that the id is stable. Layout — the widget tree as the user meets it, nested as the UI nests. Key Model — the backing HiAPI types, as <xref:> so the API reference is one click away. Source Code Path — the implementing files in the web service. Backtick every path, with its extension: tools/check-source-paths.ps1 resolves a full path against the source tree and a bare file name by its base name, and refuses an entry carrying no backticks at all. Do not add desktop-client files. ## See Also — mandatory, and audited for reciprocity. An entry is not landed until the target links back. Anatomy is authoritative on component and source facts: when Manual and Anatomy disagree, Anatomy is corrected first and Manual follows. See Also Anatomy by Source Directory — the inverse index: enter by the directory a change landed in rather than by the screen it shows up on Manual — the same shipped screens as an operating procedure rather than a component breakdown"
  },
  "anatomy/legacy-controller.html": {
    "href": "anatomy/legacy-controller.html",
    "title": "Legacy Controller Page | HiAPI-C# 2025",
    "summary": "Legacy Controller Page The Legacy Controller page is the superseded controller face: the screen that edits HardNcEnv, kept reachable while it still carries settings nothing else in the application edits. It ships at the route /controller/:tab?, is reached from the app menu bar's Page → Legacy-Controller entry, and owns no Control-Tree id of its own. Controller settings for a project are edited on the General Setup page at /general-setup under the Control-Tree id equipment/controller — Controller Branch — and the two surfaces edit different models, so an edit on one is invisible to the other. Important The equipment/controller id named above belongs to the Controller Branch rather than to this page, and Anatomy makes no claim that it is stable across versions. The migration hop that keeps an older value resolving is described in Tree Ids and Routes. The Model It Edits, and the One It Does Not The project carries both models side by side and serializes both. HardNcEnv is loaded from the project's own NcEnv element unconditionally; NcRunnerSuit — the runner plus the project's per-case dependency list — is read from its own nested element. The legacy element is a fallback source for the suit rather than a shared store: a project file that carries no runner element derives one from the legacy element at load time, and from then on the two drift apart, because every later edit lands on one of them alone. The legacy model is still read at play time. The legacy NC runner is constructed over a delegate onto the project's NcEnv, so installing a replacement through this page's ⋮ menu propagates without rewiring, and a project-level switch selects which of the two pipelines plays. That switch defaults to the SoftNc pipeline and no screen in the web application changes it; it is a scripting property, EnableSoftNcRunner(API). The legacy NC optimisation route is the other live reader: it is taken whenever the switch is off or the session holds no played SoftNc layers, and it is handed MachiningProject.NcEnv directly. What Only This Screen Edits Three settings on this screen have no editor anywhere else in the web application — neither on the branch, nor on any other page. Align P0, and its undo history The Coordinate Table tab — that is the tab button's label; ISO Coordinate Table is the heading over the panel it opens — carries a third row action beside P0 and M0: Align P0, titled \"Move workpiece+fixture so ProgramZero coincides with this ISO entry (mutates Fixture.GeomToTableTransformer)\". It does not write the coordinate — it writes the fixture's geometry-to-table transformer, moving the workpiece and fixture so that program zero lands on the offset the row holds. The write goes to the authored setup equipment and reports the edit, so the runtime face follows at the next rebuild. The branch's Work Coordinates leaf carries P0 and M0 and no alignment. The endpoint keeps no undo slot. It answers with the assigned translation plus the transformer as it stood before and after the write, both serialized as XML, and the tab holds the history itself: Undo Align and Redo Align buttons over two component-local stacks, the undo stack capped at 32 entries and the oldest dropped past it. A third button sits beside them, Show on Display, which belongs to the viewer rather than to the history: it is a bound toggle over the IsoCoordinate rendering flag, carrying a visibility / visibility_off icon and writing through the same flag endpoint the Scene dropdown writes. The two datum tabs carry the same button over HeidenhainCoordinate. Each step posts a stashed snapshot back to a stateless revert endpoint, which parses it and assigns the result as the fixture's transformer. Both stacks are cleared whenever the tab's has-a-project prop changes, and the snapshot the component believes is current is only what it last saw — a transformer changed from another surface is overwritten wholesale by the next undo or redo rather than merged. The engine exposes the same operation as a script call, AlignWorkpieceProgramZeroToIso(API); the history is the screen's own. Enable Shortest Rotary Path The Config tab's single toggle writes EnableShortestRotary, which constructs true. Its banner reads \"Shortest Rotary Path: optimises rotary axis motion to use the shortest angular distance between positions.\" On the legacy pipeline the flag gates one step: each rotary axis of a block is cycled into the ±180° window around the previous block's value. The toggle is narrower than it reads, because that same cycle is applied unconditionally on Heidenhain — the brand branch runs it before the flag is consulted, so clearing the box changes nothing there. The runner's dependency layer declares no counterpart: no brand parameter table, no generic config and no branch leaf carries a shortest-rotary switch. The nearest thing the runner pipeline has is the Heidenhain M126 / M127 pair, which is read from the program text rather than from any setting. Heidenhain master-axis character The Brand tab grows a second card while the brand is Heidenhain, holding one select over A, B, C labelled Master-axis character. It writes HeidenhainMasterAxisChar, a character face over the integer axis direction the PLANE … SEQ solution family is resolved against. Reads are normalised: anything that is not B or C after trimming and upper-casing becomes A. On the runner pipeline the master rotary is derived rather than configured — it is the first declared rotary axis — so the branch has nothing to expose and no leaf for it. What It Shares With the Branch Naming what is not exclusive matters as much. The CNC brand, the stroke limits, the rapid feed, the tool-change time, the tool offset table with its tool-house dependence, the work coordinates with their P0 and M0 actions, and the Heidenhain datum preset and datum shift tables all have editors on the branch — see Brand Matrix for which of those leaves each brand grows. The Max Speed (rpm) column has a counterpart too: on the runner pipeline the rotary speed ceiling is read from the rapid-feedrate config, and the legacy import funnels this field into it at rpm × 360 deg/min, so the branch's Rapid Feedrates leaf edits the runner-side number. One control on this screen writes a value the branch also writes. Set ideal offset dependent on tool house is a project-level configuration flag rather than a member of either NC model, and both the Offset Table tab and the branch's Tool Offsets leaf read and write that one flag. The two tables stay separate: this tab's Refresh from Tool House recomputes MillingToolOffsetTable from MachiningToolHouse, while the branch's refresh recomputes the runner's own tool-offset table. Two Faces of a Work Coordinate The work-coordinate marker is one displayee class serving two providers. This page's viewer draws it from IsoCoordinateTable — a IsoCoordinateTable instance owned by the legacy model, which constructs with G54 … G59 and G59.1 … G59.9 all at zero. The General Setup canvas builds the same displayee over the active runner's effective IIsoCoordinateConfig instead, which on most brands is the brand parameter table. Same marker, same code, two stores. Selecting a row on the ISO Coordinate Table tab writes the marker's id onto the shared Execution displayee, so it decides which offset the marker draws at. It decides that whether or not the marker is drawn: all three coordinate flags are off in the shipped rendering-flag set — as are the machine tool and the cutter, leaving the workpiece, the fixture, the dimension bar and the cutter-location strip as the four that arrive on — so on an untouched project the selection column moves something invisible until Show on Display is pressed. The datum tabs also carry a single-selection column, but nothing is sent when it changes — there the selection is a highlight and nothing more. The Tabs The left pane is a tab strip over seven panels, addressable as the route's optional segment: coordinate-table, datum-preset, datum-shift, offset-table, machine, brand, config. A bare /controller canonicalises to coordinate-table. Two tab buttons are conditional — Datum Preset and Datum Shift render only while the brand reads Heidenhain — but their panels are always present in the template, so both segments stay valid URL targets under any brand. Switching the brand away from Heidenhain while one of those two is active moves the selection back to Coordinate Table. Tab Edits Coordinate Table IsoCoordinateTable, plus the P0 / M0 / Align P0 row actions Datum Preset HeidenhainDatumPresetTable, keyed Q339 Datum Shift HeidenhainDatumShiftTable, keyed D Offset Table MillingToolOffsetTable with row-level add, delete and key rename Machine RapidFeedrate_mmdmin, ToolingTime, StrokeLimitXyz_mm, StrokeLimitAbc_rad, MaxRotarySpeedABC_radds Brand CncBrand, and the master-axis character on Heidenhain Config EnableShortestRotary The brand select offers all five declared brands — Fanuc, Heidenhain, Mazak, Siemens and Syntec — labelled with the brand names verbatim rather than through the locale bundle, and warns above the select that \"Brand-specific settings may be lost when the brand changes.\" The Machine tab's axis rows are fixed, not chain-driven. It renders exactly X, Y, Z under Linear Axis Stroke (mm) and exactly A, B, C under Rotary Axis Stroke (deg) & Max Speed (rpm), because both row sets are literal in the template. Every write there sends the whole vector — all six linear bounds, all six rotary bounds converted to radians, or all three speeds converted to rad/s — rather than the one cell that changed. The branch's per-axis leaves take the opposite shape: one row per machine-chain axis, one axis per write, described in Per-Axis Tables. Both stroke limits construct as an infinite box, and the service serializes named floating-point literals, so those bounds reach the browser as the tokens Infinity and -Infinity rather than as numbers. The shared numeric field prints what it is handed and parses both words back, so an unconfigured Machine tab opens showing those words rather than a blank and takes them typed in; the rotary rows carry them through unconverted, because the degree conversion guards on a finite value. A stroke write does not survive its own re-read. The read and the write agree on the wire order: the read emits the six bounds interleaved per axis, [minX, maxX, minY, maxY, minZ, maxZ], and the tab posts the same six back. The write then hands that vector to the box constructor, which reads its arguments grouped — the whole minimum corner first, the whole maximum corner second. The vector is de-interleaved on the way in, so only the first and the last number land where they were sent and the four between them move to other rows; from the infinite default above, that is enough to leave the middle axis reading a Max below its Min after any single edit. The rotary stroke endpoints share the constructor and the behaviour; the three Max Speed values travel as a plain triple and are unaffected. The regrouped box is not inert — with the stroke check on and no runner-side stroke config resolving, the legacy play path validates every step against StrokeLimitXyz_mm and StrokeLimitAbc_rad as stored. The branch's per-axis leaves, writing one axis at a time, carry none of it. How an Edit Commits The tabs reuse the same numeric field the rest of the application uses, so the timing is that widget's: commit on blur or on Enter, never per keystroke, with the bounds and parse behaviour set out in Numeric Input. Clearing a cell parses to null and every legacy handler returns on null, so an emptied cell is not an edit — the one exception is the Offset Table's tool-number cell, which forbids an empty value and shows a parse error in place instead. Selects, toggles and row buttons commit on the click. The optimistic write is the same capture-assign-await-restore shape the branch's panels use, and Editing Contract is where that shape, its row-scoped payloads and its rollback semantics are set out once. Four differences are this screen's own: Three fields commit without a rollback. The Machine tab's Rapid Feedrate and Tooling Time handlers assign the new value and await the write without capturing the old one, so a refused write raises the toast and leaves the field showing the number the server rejected. The Brand tab's Master-axis character select is the third and the least recoverable: its handler captures nothing and restores nothing, and its two-way binding has already put the pick into the tab's own state before the handler runs, so a refused write leaves the rejected character on screen looking accepted. Every other value handler — the stroke and speed vectors, the coordinate and datum cells, the offset row and its key rename, the brand select itself, the shortest-rotary toggle (two-way bound as well, but reconstructing its old value from the new one) — restores the old value on failure. Row actions are outside the shape entirely: P0, M0, the datum reset, an add and a delete all write first and touch the local rows only once the request resolves. The REST surface answers with status codes, not a success envelope. A missing table, an unknown index or an unexpected paste type is answered as not found, bad request or conflict. Most of those answers are bare English sentences; four carry a code — no project loaded, no NcEnv found, no NcEnv configuration and no fixture — which the client re-renders from the locale bundle under any language but English. The branch's surface instead answers a missing dependency inside a 200 envelope; nothing here does. A refused load is silent on six of the seven tabs. Every write wrapper in this page's API module goes through the plain-JSON helper, which throws on any non-2xx and returns the parsed body otherwise, so a refused write always reaches a toast. Eight read wrappers deliberately bypass it and answer a benign default on any non-2xx: an empty list for the coordinate table, both datum tables and the offset table, unknown for the brand, A for the master-axis character, and off for the tool-house dependence and shortest-rotary flags. A refused load therefore renders as an empty or default tab, indistinguishable from one whose table really is empty, with no toast and no console line. Only the Machine tab's five reads throw, so it is the one tab on which a refused load shows. The tool-house dependence toggle writes before it flips. Turning it on awaits the flag write, then flips the local toggle, then refreshes the offsets from the tool house and re-reads the table. A failure in the refresh therefore leaves the flag committed on both sides rather than reverted. Every tab composes its failure toast the same way: negative, 3.5 seconds, the tab's own localized context followed by the thrown error's own text, with a console line naming the component. That text is built by the shared helper as HTTP <status>: <server message>, so the status code reaches the user in the toast — where the branch's envelope failures surface the server's sentence alone. Each tab fetches once on mount and again when its has-a-project prop turns true; the tab panels are kept alive, so moving between tabs does not refetch. That prop is the indexed key rather than the project store's own flag: Initialize answers not found where the project carries no NcEnv, so a project can be open while every tab still reads as having none. Nothing pushes changes at a mounted tab, and no tab re-reads after a cell edit — the Offset Table's two tool-house actions are the one exception, because the server recomputes the table under them. The four tables that render as data tables — the coordinate table, the two datum tables and the offset table — are the only places in the application that use that component. None of them declares a sortable column, and all four run unpaginated with every row shown. Object Management and the Install Chain The left pane's head line carries the shared object-management ⋮ menu, the title Controller, and a badge reading ready while a key is indexed and no project otherwise. The menu's entries are Load, Save As, Copy, Paste and XML Mode; Load Resource is absent because the page passes no resource directory. Load and Save As browse the server file system through the shared file-explorer dialog filtered to *.NcEnv / *.xml, rooted at the project directory once a project is open; Save As proposes the name NcEnv.xml; Paste is checked against the expected type Hi.Numerical.HardNcEnv, HiUniNc. Load, Paste and an XML apply swap only the indexed object, so the page then installs it: it posts the indexed key to the install endpoint before re-running Initialize, because Initialize re-indexes from the project and would otherwise resurrect the object that was replaced. A failed install stops the chain with a toast. A successful one re-reads the brand, which is what re-gates the two Heidenhain tabs, refreshes the rendering flags, and raises an informational toast naming the installed type. The XML dialog's Apply raises the load event as well as its own, and the page listens only to the load event, so the chain runs once rather than twice. Initialize mints a fresh index key on every call, and the page registers each one for cleanup and drops the key it replaced, so repeated installs do not accumulate entries. The Viewer The right pane is a rendering canvas with its own toolbar: the shared view toolbar, a Scene ▾ dropdown, and a badge reading rendering or disconnected. The canvas binds the shared Execution displayee rather than a viewer of its own, so what is toggled here is what the Execution page shows. The Scene dropdown groups its checkboxes as Solid — Machine, Tool, Workpiece, Fixture — Coordinate — Program Zero, ISO Coordinate, Heidenhain Coordinate — and Display Aids — Dimension Bar, Color Scale Bar. The Heidenhain Coordinate row is listed only while the brand reads Heidenhain. Three tabs carry a Show on Display button of their own that flips the same shared flags: the coordinate tab flips ISO Coordinate, and the two datum tabs both flip Heidenhain Coordinate. The Heidenhain marker is gated twice over, and the second gate is never satisfied. The displayee is added to the scene only while its flag is set and the model's brand is Heidenhain; it then returns without drawing until an active datum number or datum-shift argument has been assigned to it, and no code path in the web service assigns either. So the marker stays absent whatever the flag reads. Where it does draw, it resolves its offset through the legacy datum tables — the ones this page's two datum tabs edit — and not through the runner's. Layout Legacy Controller Page — /controller/:tab?, a two-pane splitter, left pane 55 % and draggable between 25 % and 75 % Management Pane Head Line Object Management Menu Button (⋮) — Load, Save As, Copy, Paste, XML Mode Controller Title Status Badge — ready / no project Tab Strip — Coordinate Table, Datum Preset, Datum Shift, Offset Table, Machine, Brand, Config; the two datum buttons rendered only under Heidenhain Tab Panels — kept alive; one shown at a time ISO Coordinate Table Panel Toolbar — Undo Align, Redo Align, Show on Display Table — columns Index, X, Y, Z, Actions, with a single-selection column Row Actions — P0, M0, Align P0 Datum Preset Table Panel — Show on Display; columns Q339, X, Y, Z, Actions, the action being a reset-to-zero button Datum Shift Table Panel — the same shape, keyed D Tool Offset Table Panel Toolbar — Set ideal offset dependent on tool house toggle, and Refresh from Tool House while it is on Table — columns Tool #, Ideal Radius, Radial Wear, Ideal Height, Axial Wear, and a delete button; the tool number is editable and the delete button present only while the dependence is off Add Button — below the table, shown only while the dependence is off Machine Configuration Panel General Card — Rapid Feedrate (mm/min) and Tooling Time (sec) numeric fields Linear Axis Stroke (mm) Card — Axis / Min / Max over fixed rows X, Y, Z Rotary Axis Stroke (deg) & Max Speed (rpm) Card — Axis / Min (deg) / Max (deg) / Max Speed (rpm) over fixed rows A, B, C CNC Brand Panel Selection Card — the brand select over the five brands, above the brand-change warning banner Heidenhain Settings Card — Master-axis character select over A / B / C; shown only under Heidenhain Configuration Panel Options Card — Enable Shortest Rotary Path toggle above its explanatory banner Viewer Pane Viewer Toolbar RenderingCanvas Tool Bar Scene ▾ Dropdown — Solid, Coordinate and Display Aids groups Connection Badge — rendering / disconnected Rendering Canvas — bound to the shared Execution displayee Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/pages/ControllerPage.vue — the page shell: the splitter, the seven tab panels and the Heidenhain gate over two of the buttons, the install-then-initialize chain, the rendering-flag snapshot the per-tab toggles read, and the tab reset on leaving Heidenhain. wwwroot-src/src/components/controller/CoordinateTableTab.vue — the coordinate table: the per-cell whole-row write, the row selection that names the marker, the P0 / M0 actions, and Align P0 with its two client-side history stacks and their cap. wwwroot-src/src/components/controller/DatumPresetTab.vue and wwwroot-src/src/components/controller/DatumShiftTab.vue — the two Heidenhain tables: the Q339 and D key columns, the reset-to-zero action, and the selection that is a highlight only. wwwroot-src/src/components/controller/OffsetTableTab.vue — the offset editor: row add, delete and key rename with its duplicate guard, and the two-step tool-house dependence toggle. wwwroot-src/src/components/controller/MachineTab.vue — the fixed X/Y/Z and A/B/C row sets, the whole-vector writes, the degree and rpm conversions with their infinity guards, and the two handlers that commit without capturing a rollback value. wwwroot-src/src/components/controller/BrandTab.vue — the five-brand select with its captured rollback, the change warning, and the Heidenhain master-axis card: its read normalisation, its two-way binding and its write with no rollback. wwwroot-src/src/components/controller/ConfigTab.vue — the shortest-rotary toggle, its banner and its reconstructed rollback. wwwroot-src/src/components/controller/ControllerExtendedToolBar.vue — the Scene dropdown: the three flag groups and the brand test that hides the Heidenhain row. wwwroot-src/src/api/controller.ts — the typed wrappers over every endpoint above, the brand constants and their literal labels, the align / revert payloads, the documented stroke-vector order, and the eight read wrappers that answer a default instead of raising. wwwroot-src/src/api/http.ts — the plain-JSON helper every write goes through, its coded-error keys, and the success-envelope helper this module does not use. wwwroot-src/src/api/renderingFlags.ts — the flag indices the Scene dropdown and the per-tab toggles write. wwwroot-src/src/components/widgets/NumericInput.vue — the numeric cell: commit on blur or Enter, the empty-to-null parse the handlers reject, the generic text path that prints the infinity tokens, and the parse branch that takes them back. wwwroot-src/src/components/widgets/ObjectManagementMenuButton.vue — the ⋮ menu, its server file browser and extension filter, the paste type check, and the load event an XML apply also raises. wwwroot-src/src/components/RenderingCanvas.vue and wwwroot-src/src/components/RenderingCanvasToolBar.vue — the viewer pane's canvas and its shared view toolbar. wwwroot-src/src/composables/useRouteTabs.ts — the tab-to-URL sync, the seven valid segments and the default the bare route canonicalises to. wwwroot-src/src/composables/useCleanupHub.ts — the registration that drops each superseded index key. wwwroot-src/src/router/routes.ts — the /controller/:tab? route beside /general-setup. wwwroot-src/src/components/AppMenuBar.vue — the Page dropdown carrying the Legacy-Controller entry. wwwroot-src/src/stores/project.ts — the project flag the page watches in order to re-run Initialize; the indexed key that call returns is what the seven tabs and the status badge read. wwwroot-src/src/layouts/MainLayout.vue — the keep-alive that holds the page across navigation and rebuilds it on a project epoch change. wwwroot-src/src/i18n/en/controller.ts — every title, tab label, column header, banner and error context quoted above. wwwroot-src/src/i18n/en/menu.ts — the Page and Legacy-Controller menu strings. wwwroot-src/src/i18n/en/common.ts — the shared column, action and status strings the tabs reuse. Controller/ControllerController.cs — the page's whole REST surface: the index-and-install pair, the per-property readers and writers, the interleaved stroke reads beside the grouped stroke writes, the four coded error payloads, the row-level offset CRUD, the align endpoint that snapshots the transformer either side of the write, the stateless revert, and the display binding that attaches the shared Execution displayee. Common/ApiError.cs — the four coded payloads named above. Program.cs — the named-floating-point-literal serializer the infinite bounds travel under. Widget/ObjectManagementController.cs — the server half of the ⋮ menu, including the paste that rejects an object the expected-type string does not admit. Disp/ExecutionDisplayee.cs — the displayee this page's canvas binds: the two coordinate flags, the extra brand test on the Heidenhain one, and the legacy tables both markers are built over. Disp/IsoCoordinateEntryDisplayee.cs — the one marker class serving both faces, over whichever coordinate provider it is handed. Disp/HeidenhainCoordinateEntryDisplayee.cs — the Heidenhain marker: the brand guard, the datum number and shift argument it draws nothing without, and the legacy tables it resolves through. Common/ProjectDisplayeeService.cs — where that single shared displayee is created. HiAPI Engine HiUniNc/Numerical/HardNcEnv.cs — the model this page edits: the coordinate, datum and offset tables, the stroke boxes that construct infinite, the rapid rate and tooling time, the shortest-rotary flag with its Heidenhain exclusion, and the master-axis character over its integer direction. HiGeom/Geom/Box3d.cs — the box the two stroke limits are, its infinite construction, and the six-argument constructor whose grouped argument order the interleaved stroke writes are handed to. HiUniNc/Numerical/HardNcLine.cs — the legacy consumers of two of those settings: the shortest-rotary path application and the SEQ solve that reads the master-axis direction. HiUniNc/Numerical/MillingToolOffsetTable.cs — the offset table and the tool-house recompute the Refresh button calls. HiMech/NcParsers/Dependencys/Generic/IsoCoordinateTable.cs — the coordinate table type and the fifteen G-code keys it constructs with, shared by name with the runner's brand-agnostic table. HiMech/Machining/MachiningEquipmentUtils/MachiningEquipmentUtil.cs — the alignment itself: the translation written into the fixture's geometry-to-table transformer. HiMech/NcParsers/SoftNcRunner.cs — the legacy import: which legacy fields are funnelled into which runner dependency, including the rotary speed conversion into the rapid-feedrate config. HiMech/NcParsers/LogicSyntaxs/PolarInterpolationUtil.cs — the rotary speed ceiling the runner pipeline reads, and why it is the rapid-rate bucket rather than a setting of its own. HiMech/NcParsers/LogicSyntaxs/Heidenhain/HeidenhainPlaneTiltSyntax.cs — the derived master rotary on the runner pipeline: the first declared rotary axis, with no configured alternative. HiNc/MachiningProcs/MachiningProject.cs — where both models hang off the project, and the load path that derives a runner from the legacy element only when no runner element is present. HiNc/MachiningProcs/LocalProjectService.cs — the legacy runner built over a delegate onto the project's model, the switch that selects which pipeline is active, and the per-step stroke check that falls back to the legacy boxes when no runner-side stroke config resolves. HiNc/Numerical/FilePlayers/HardNcRunner.cs — the legacy runner itself. HiNc/MachiningProcs/SessionShell.cs — the scripting face of the pipeline switch and of the alignment, and the optimisation route that passes the legacy model directly. See Also Controller Branch — the SoftNcRunner-native controller branch that supersedes this screen, and where controller settings for a project are edited General Setup Page — the page that hosts the branch above, and the rest of the equipment tree beside it Legacy Controller (manual) — the end-user task: the settings this screen still owns alone, and which face to edit for everything else"
  },
  "anatomy/platform/control-tree.html": {
    "href": "anatomy/platform/control-tree.html",
    "title": "Control Tree | HiAPI-C# 2025",
    "summary": "Control Tree The Control Tree is the engine shared by the two tree-shaped pages of the web client: the Execution page at /execution and the General Setup page at /general-setup. Each page creates exactly one host — useControlTreeHost('execution') or useControlTreeHost('equipment') — provides it to its panes under one injection key, and the host owns everything after that: the node graph, the branch builders, the selection and the ?tree= query that carries it, the editor panel a selection resolves to, and the mission enable ticks. The Tool House page at /tool-house reuses the same node shape and the same item-type registry but renders a branch as nested tabs and creates no host. Important Node ids are role paths, not identities that survive a version change. Anatomy makes no claim that a ?tree= id is stable across releases; see Tree Ids and Routes for the migration hop that keeps an older link resolving. The Node Every branch of every tree is built from one structure, ControlNode, declared in itemTypes.ts: id — the node's role path, slash-separated, whose first segment is the owning page's scope (execution/…, equipment/…, toolhouse/…). This is the addressing surface: the ?tree= query, the persisted expansion list and the persisted last selection all hold ids. label, labelKey, labelParams — the display text; see Display Labels. itemType — the registry key that decides the node's editor and its child builder. key — the bound object. In the geometry and equipment branches it is an IndexService key, re-minted on every re-index; in the Mission branch it is the Mission API command path (0, 1, the dotted 0.2 of a nested list entry); in the Tool House branch it is the tool id as a string. Waves whose panels read a module-level state singleton rather than an indexed object leave it empty — the SoftNc controller leaves, the spindle sections, the Background and Coolant leaves and the Program branch all do. ctx — the parent-provided SlotCtx: the afterChange commit chain, a slot's onCreate create-and-rebind hook, and a slot picker's allowedKinds / allowNone constraints. children — grown by the builders, not declared by the tree column. selectable, info / infoKey, and the mission / program bookkeeping records the Mission and Program waves stamp on their own nodes. The split between id and key is the load-bearing one. A key is re-minted every time the host re-indexes the model, so nothing durable may hang off it; an id names a role in the model and therefore survives a rebuild, which is why expansion state, the URL and the landing selection are all keyed on ids. Two id families are positional rather than role-based: Mission entries are ${parentId}/${index} and Program files are ${parentId}/${index}, so moving or deleting a mission command renumbers its siblings and a link to one names a position in the list rather than that command. The Item-Type Registry ITEM_TYPES maps an itemType string onto a TreeItemDef carrying up to three members: panel — the editor mounted in the dock's editor row for a node of this type. contentPanel — a large view for the General Setup page's content column. buildChildren — an async builder that returns this node's children. Two flavours of type share the map. Slot types (Geometry, Transformer) have a kind picker as their panel and grow at most one child, the concrete kind, at the kind-independent id ${slot.id}/type — so switching a slot's kind keeps both the selection and the expansion. A slot holding nothing grows no child at all, which for the four geometry slots whose picker offers None is an ordinary state rather than a failure. Kind types (Box3d, StaticTranslation, …) register SoleEditorPanel, which looks the concrete editor up in the geometry and transformer editor maps and binds it to the node's key. The two composite geometry kinds do not embed nested editors: TransformationGeom grows an inner-geometry and an inner-transformer slot, and GeomCombination grows one slot per item, so the tree owns the structure and every panel stays shallow. The map is one flat namespace assembled in itemTypes.ts: the Group stem type, the geometry, transformer, workpiece-leaf, thermal-condition and spindle entries, and the Execution root's own type are written inline, and five per-wave registries are spread in beside them. The three roots the panel host renders itself — Machine Tool, Fixture and Workpiece — have no entry here at all. Wave File What it contributes Mission missionItemTypes.ts MissionRoot, MissionCommand, MissionSection; section children at ${command.id}/${sectionId}; the per-kind bespoke editors, with a generic field editor as the fallback Program programItemTypes.ts ProgramRoot, ProgramFile, ProgramConversionFile; writeback conversions at ${root.id}/dst-${index} Tool House toolHouseItemTypes.ts the tool collection and the per-tool editor branches under toolhouse/tool-<id>/… SoftNc controller softNcItemTypes.ts the controller root and its leaves on two planes — …/machine/<seg> and …/program-data/<seg> — a core every runner grows plus the brand-driven ones Runner suits runnerSuitItemTypes.ts CsvRunnerRoot and ClRunnerRoot, flat single-panel leaves with no builder The Program branch is fetched whole: its root builder takes one file-tree response plus one conversions response and stashes each file's raw subtree on the node, so the file nodes' builder only maps what is already in hand. The SoftNc branch is the opposite — its builder reads the runner snapshot once, and with no runner installed grows nothing at all. Where one resolves, the two plane stems appear over a fixed core that stands for every brand: six machine leaves, and Work Coordinates and Tool Offsets on the program-data plane. The leaves beside that core are the brand-driven ones — each appears only where the snapshot reports its backing table, so a brand switch changes which nodes exist. One flag does double duty: the Siemens $TC_DP flag adds its own two leaves and renames the core Tool Offsets leaf to its ISO G43 H reading, so the two offset ledgers do not read as one. The two runner-suit nodes are conditional, and the host — not the registry — decides. With a project open, a CSV or CL controller node is built when its Preference checkbox is on, or when the current ?tree= value starts with that node's id. The checkbox is device-local and off by default; the route is the only other reveal, deliberately not the persisted last selection, so a node switched off while it is selected does not resurrect itself. Stepping off comes first: when the selection sits on a node the user has just unchecked, the host re-points the URL at the page root before rebuilding. Building a Branch buildSubtree(node, services, depth) is the whole builder. It looks the node's type up, returns without touching children when the type declares no buildChildren or when depth has reached MAX_DEPTH (12, a guard against a self-referencing model), and otherwise awaits the builder, recurses into each returned child, and assigns the result. Building is eager: a branch is materialised in full at build time rather than lazily on expansion. Builders receive one service, registerKey, which registers a freshly minted IndexService key with the page's cleanup hub — see Webapi with Hub-Cleanup Assistance. rebuildBranch(node) is buildSubtree plus one thing: it adds the node's id to the expansion list so the fresh children are visible, and reports a failure as a toast named after the node's display label. The structure-changed event A panel that has changed the shape of the model emits structure-changed (or type-changed, wired to the same handler). The optional payload is a StructureChangeRequest: scopeId — the branch to rebuild. Without it the scope is the selected node itself, which is correct only while the change stays inside the emitting panel's own branch. selectId — the selection to adopt afterwards. It is assigned directly, bypassing the dirty-switch gate, because the emitting panel is being replaced on purpose. A null clears the selection. A mission command's move, duplicate and delete re-scope to the parent list, because those operations rewrite the parent's children, and they name the post-operation selection: the clone's slot after a duplicate, the neighbouring index after a delete, the parent list when the delete emptied it. Moving an entry out of a nested list re-scopes to the grandparent. The controller brand switch and the runner's Object-Management install re-scope to the controller root. The Tool House type selectors and a flute add re-scope to their own node; everything that rewrites the tool collection — a new tool, a duplicate, a delete, an id rename, an Object-Management install — re-scopes to the tool-house root, and a flute delete re-scopes to its fluting parent. Whole-tree rebuilds, and the refreshes that are not rebuilds rebuildTree() replaces the root array outright, and runs after an Object-Management swap of the machine tool or the fixture, after a blank machining chain is created, and after either runner-suit preference flips. On the execution host, an execution-status transition re-runs buildSubtree on the Program root directly rather than through rebuildBranch, so a run does not force that branch open on every transition. Two refreshes deliberately mutate existing nodes instead of rebuilding: A mission command's title is re-read from the entry list and written onto the node's label. A file-backed geometry leaf's label is re-read when its source file changes. The mission one exists because a rebuild of the Mission branch re-mints the per-build stamp that forms part of the editor's remount key, and remounting an open editor mid-edit would cost the user their cursor and any staged autosave. The geometry one is the same principle without the stamp: a title change and a source-file change alter no structure, so the label is all that has to move, and replacing the node under an open file editor would buy nothing. The commit chain The tree has no component bubbling, so the full post-edit commit chain lives on each node as ctx.afterChange, composed level by level as the branch is built. A GeomCombination item's chain cleans that combination's aggregated cache before running its parent's chain; the fixture's chain ends in a geometry-cache clear; the two workpiece geometry slots re-commit the swap-in before clearing their own cache, and skip that re-commit when the slot has been set to none; the fixture's two anchor transformers re-commit and then clear the geometry cache, while the workpiece's two re-commit and clear nothing, since a placement change invalidates no cached solid. Tool-house nodes all share one refresh. Every other family carries a no-op: the Mission, Program, spindle, SoftNc and thermal-condition nodes and the workpiece's Mesh and Material leaves have panels that write straight to the model, and the pages' canvases draw that model; the group stems and the Machine Tool and Workpiece roots have no field editor to commit for at all. Selection and the Dirty-Switch Gate Every selection change funnels through requestSelect(id). It returns immediately when the id is already selected; otherwise it awaits the mounted panel's optional tryConsumeBeforeSwitch() and abandons the switch when that returns false. Three entrances use it: a click in the tree, a change to the URL's ?tree= value, and a select-node event from the mounted panel — the wire the panel host puts on every registry panel, so a group stem's child list, a mission list's entry row and the Program branch's conversion jumps all arrive through that one. A fourth path — the selectId of a structure change — assigns the selection directly and skips the gate. There is no “nothing selected” state. Re-clicking the selected row makes the tree yield null, and that is ignored; an empty ?tree= lands on the persisted last selection for that page when the built tree still contains it, and on the page's root otherwise. The editor row is therefore always alive, and reclaiming its height is the row's own collapse toggle rather than a deselection. The gate itself is registered by the panel host: the mounted registry panel is handed to the host through a template ref, and the host asks that instance for tryConsumeBeforeSwitch. Panels that write one field per request need no gate and register none. One panel exposes it — MissionCommandSlavePanel: on a list entry it flushes the debounced title save while the command path is still live, then allows the switch; on any other entry it forwards its inner editor's gate. Today only the script editor has one: with unsaved text it asks save, discard or cancel, returning false on cancel and on a flush that ends in an error. The same gate is run before duplicating a command, so the clone is made from what has just been typed rather than from the last saved state. Display Labels nodeDisplayLabel(n) returns the translation of labelKey — with labelParams interpolated — when one is set, and the verbatim label otherwise. labelKey is therefore the form every role label the client translates itself takes, while label is the storage for text it cannot: server-composed mission titles, file-backed geometry paths and engine type names. The translator function is read inside the call rather than captured, so a language change re-renders the whole tree's role labels. Two labels are composed rather than looked up. A mission command's label is the title the server composes for it — the command's kind name in the request language, with the command's own text in brackets when there is one, as in Script [Warm-Up]. That title always arrives filled in, so the node's labelKey is always dropped and the tree's own kind-name fallback is a safety net that never fires in practice. Because titles are composed server-side per request, a language change also re-pulls the command entries and rewrites those labels in place. A file-backed geometry leaf carries its source file in brackets, so sibling instances read apart: StlFile [Geom/x.stl]. The voxel kind is renamed for display, appearing as MeshedGeomFile [...] rather than by its type name. Group stems take the same treatment for their intro text: infoKey wins over info, and a stem with neither falls back to a sentence naming the group. The Panel Host PrimarySlavePanel decides what the editor row shows, in this order: The three inline root types — MachineToolRoot, FixtureRoot, WorkpieceRoot — are rendered by the panel itself as a summary, and are never resolved from the registry. The two with a stand-alone file surface, Machine Tool and Fixture, carry an Object-Management button above it; the workpiece has none, since it is authored entirely through its child tree items. Otherwise the registry's panel for the selection's item type, mounted with the node as its only prop, with changed, type-changed, structure-changed, select-node and error wired to the host. A spinner while the first build is still running, and the select-an-item hint after that when the selection's type registers no panel. What decides a remount is the mounted component's key, ${id}|${key}|${stamp} — the node id, the node key, and the mission stamp where the node has one. So the editor remounts when the selection moves, when the bound object's key is re-minted, and when the Mission branch was rebuilt beneath it. That third term is exactly why the mission label refresh above mutates the node instead of rebuilding. On the Execution page the editor row grows a header: the transport bar is pinned above the scroll area whenever the Execution root or any of its descendants is selected, so the run controls never scroll away; that one instance also owns the transport's function-key shortcuts, which are attached for as long as it is mounted. A pure Group stem is not a node without an editor. Group registers GroupInfoPanel, whose body is the stem's intro line followed by a clickable list of its children; a row click emits select-node and the host moves the selection there. The General Setup root, the two Anchor stems, the workpiece Material stem and the controller's two plane stems are all of this kind. The General Setup page adds a second slave, ContentSlavePanel, which resolves contentPanel from the same registry. Three item types declare one — the spindle root and its scalar and contour section types — and all three name the same contours view, so the charts stay mounted while the selection moves across the spindle branch: the component takes no props and is mounted unkeyed on purpose. Every other selection shows the column's empty hint. NodeTabCascade is the third consumer of the registry. It renders a branch as nested tabs rather than tree rows: the node's own panel on top, a single child inlined below it, several children as a dense tab strip in which only the active child mounts. The active tab is remembered per role path at module scope, with the per-tool segment wildcarded, so switching tools keeps every level's tab. Its panels report through an injected cascade host that carries the emitting node, because — unlike the tree's one-panel-at-a-time model — several panels are mounted at once. The Tick Column The tree runs a strict tick strategy, and a node hides its checkbox unless it is a mission command or a mission section that carries its own enable flag. Writing the ticked set walks every command node at any depth: a command whose state changed is PUT to the Mission API and, on success, has the new state copied onto its section children; a section whose state changed is dispatched to its kind's writer. A failed write raises a toast and leaves the model untouched, so the getter re-derives the old value and the box snaps back. A row dims when it is itself disabled — a disabled command, or a section whose own flag is off — or when an ancestor command is disabled, which is how a disabled command greys its whole subtree while each descendant keeps its own state. The switch decides only whether the command runs: a disabled command stays fully editable. Layout Left Dock — both tree pages, one nav-bar button toggling the whole column Control Tree Expansion Row — collapses in place, keeping its header; stays mounted while collapsed, so the tree keeps its scroll position Tree — one root row per page: Execution or General Setup Node Row — the label is a real link to this node's ?tree= URL on the page, so the browser's context menu offers open-in-new-tab and copy-link; a plain left click keeps the in-app selection instead of navigating, while a modified or middle click opens a tab and leaves the current selection where it is. No icons are rendered. Node CheckBox — mission command rows, and mission section rows carrying an enable flag Execution Status Badge — on the Execution root row only Spinner and “Loading project…” — shown instead of the tree until the first build lands Row Divider — a 5 px bar between the rows, shown only while both are open; dragging it upwards grows the editor row, which keeps a stored pixel height while the tree above absorbs the change, down to a 120 px editor floor and a 100 px tree floor Editor Expansion Row — its header carries the selection breadcrumb, the node path joined with slashes, and falls back to Editor; stays mounted while collapsed Execution Transport Bar — Execution page, while an Execution-scope node is selected The selected node's editor panel, or “Select an item in the Control Tree to edit it here.” Content Column — General Setup page only, one nav-bar button The selected node's large content view, or “The selected item has no expanded content.” Both dock rows and both column widths are device-local browser preferences, shared by the two pages through one preferences module; each page keeps its own visibility record, and both pages share one expansion list because their id spaces do not overlap. Lifecycle The host is created while its page's script runs and provided before the dock mounts; the page's onMounted then awaits initialize(). That call connects the cleanup hub and builds the tree — on the equipment host, after re-indexing the machine tool, the workpiece and the fixture in that order — and finishes by adopting whatever the URL's ?tree= names. A loading flag is held for the whole call, which is what the tree and editor rows render their spinners from; later rebuilds mutate an already-populated tree and never re-enter it. A missing project, or a project without a fixture or workpiece, answers 404, and those are treated as empty states rather than errors, so no toast appears. Without an open project the Mission, Program and controller branches are still declared, as childless stems: their builders run only once a project is loaded. Because the layout keys its keep-alive wrapper on a project epoch, every page is destroyed and rebuilt when the project changes, and a host is therefore created once per project per page. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/useControlTreeHost.ts — the host: the two scopes' root builders, the selection gate, the ?tree= sync, the mission ticks, the rebuild entry points, the re-index and Object-Management handlers, and the reactive surface the panes consume. wwwroot-src/src/components/controlTree/itemTypes.ts — the ControlNode and TreeItemDef shapes, the SlotCtx hooks, the structure-change payload, nodeDisplayLabel / nodeDisplayInfo, the geometry and transformer builders, the ITEM_TYPES map and buildSubtree. wwwroot-src/src/components/controlTree/ControlTreePanel.vue — the tree column: the node anchors, the click handling that keeps a plain click in-app, and the execution-status badge. wwwroot-src/src/components/controlTree/ControlTreeDock.vue — the two-row dock and the height divider that sets the editor row's stored pixel height. wwwroot-src/src/components/controlTree/PrimarySlavePanel.vue — the panel host: the three inline root types, the registry lookup, the remount key, the gate registration and the transport header. wwwroot-src/src/components/controlTree/ContentSlavePanel.vue — the General Setup content column and its unkeyed content panel. wwwroot-src/src/components/controlTree/GroupInfoPanel.vue — a group stem's intro and its navigating child list. wwwroot-src/src/components/controlTree/SoleEditorPanel.vue — a kind node's editor, resolved from the geometry and transformer editor maps. wwwroot-src/src/components/controlTree/NodeTabCascade.vue — the same branches rendered as nested tabs, with the remembered per-role tab and the cascade host injection. wwwroot-src/src/components/controlTree/missionItemTypes.ts — the Mission wave: node bookkeeping, the section table and its enable-flag readers and writers, the per-kind editors and display names. wwwroot-src/src/components/controlTree/programItemTypes.ts — the Program wave: the file tree from one response, and the writeback conversion nodes. wwwroot-src/src/components/controlTree/softNcItemTypes.ts — the controller wave: the two planes, the core leaves every runner grows, and the snapshot flags that decide which brand leaves join them. wwwroot-src/src/components/controlTree/toolHouseItemTypes.ts — the Tool House wave and its tool-<id> role paths. wwwroot-src/src/components/controlTree/runnerSuitItemTypes.ts — the two runner-suit leaves. wwwroot-src/src/components/controlTree/MissionCommandSlavePanel.vue — the command control bar, and the only panel that exposes a dirty-switch gate. wwwroot-src/src/components/mission/ScriptCommandPanel.vue — the autosaving editor whose gate is forwarded, with its save / discard / cancel prompt. wwwroot-src/src/components/panels/PanelExpansion.vue — the expansion row both dock rows are built from. wwwroot-src/src/composables/useViewPrefs.ts — the device-local expansion list, last selections, dock sizes and the two runner-suit checkboxes. wwwroot-src/src/composables/useCleanupHub.ts — the key registration the builders call. wwwroot-src/src/router/treeRoutes.ts — the id migration hop and the page a given id belongs to. wwwroot-src/src/pages/ExecutionPage.vue — creates and provides the execution host. wwwroot-src/src/pages/GeneralSetupPage.vue — creates and provides the equipment host, and adds the content column. wwwroot-src/src/pages/ToolHousePage.vue — the registry consumer that renders tabs instead of a tree. wwwroot-src/src/layouts/MainLayout.vue — the project epoch that decides when a host is rebuilt. wwwroot-src/src/i18n/en/tree.ts — the dock labels, the group intros and the node role labels. See Also Tree Ids and Routes — how a node id becomes a URL, which page owns a given id, and how an older id keeps resolving Session State — the project epoch and the stores a host is rebuilt around Execution Page — the first live host: the run cockpit's Mission and Program branches General Setup Page — the second live host: the equipment branches and the content column Controller Branch — the one branch whose node set is not fixed: it is regrown from a snapshot, so which children exist depends on the controller in the project"
  },
  "anatomy/platform/i18n.html": {
    "href": "anatomy/platform/i18n.html",
    "title": "Internationalization | HiAPI-C# 2025",
    "summary": "Internationalization The web client ships three locales — en, zh-Hant and zh-Hans — over one message shape, and it owns no route: the mechanism is a vue-i18n instance created in the i18n module, a boot file that picks the locale before the application mounts, a single switch function every locale change goes through, and two Node scripts that gate the production build. English is not one locale among three; it is the schema the other two are written against and the text every unlocalized path falls back to. The user-facing gesture that triggers a switch is documented under Language Selection SubMenu, and the vocabulary the translations are held to under Translation Remarks. The Three Bundles Each locale is a folder under the i18n directory holding one file per namespace plus an index file that re-exports them as a single object. The three folders carry identical file lists — the same twenty-three namespaces, from apiErrors and auth through tree and widgets — because a namespace's keys are added to all three locales in the same change. Keys are named namespace.area.element in lowerCamelCase and are split by the UI region they serve rather than by the source file that reads them. English is the schema, mechanically and not by convention. wwwroot-src/src/i18n/schema.ts exports MessageSchema = typeof en, and each Chinese locale's index file annotates its own message object with that type, so a key missing from a Chinese namespace is a type error at the annotation rather than a silent English fallback at runtime. schema.d.ts augments vue-i18n's DefineLocaleMessage with the same shape, which registers it as the global message schema for call sites. Type checking is not part of the production build, however: wwwroot-src/package.json runs vue-tsc under a separate lint script, and build runs the two i18n scripts described below instead. The instance is created with legacy: false, an initial locale of en and fallbackLocale: 'en'. The resolution chain is therefore current locale → English → the key string itself, so a key missing from a Chinese bundle renders English with no runtime signal, and a key missing everywhere renders as its own dotted name. Quasar's own component texts are a parallel bundle with different code names, mapped in the same module: en to Quasar's en-US pack, zh-Hant to zh-TW, zh-Hans to zh-CN. All three packs are static imports rather than a dynamic import built from the locale code, because a template-literal import on a bare package specifier is not statically analysable by the bundler. Applying a Locale applyLocale(code) in the i18n module is the only place a locale change happens. It first maps its argument through normalizeLocale, falling back to en, and then does six things in one call: sets the vue-i18n instance's locale ref; calls Quasar's Lang.set() with the mapped language pack; writes document.documentElement.lang, which is what selects the CJK glyph variant; rebuilds the exported collator, an Intl.Collator for the new locale with base sensitivity and numeric ordering; writes the locale into localStorage under hinc.lang, inside a try/catch because storage can be unavailable; calls the re-title hook the router registered, so a browser tab parked on a page without navigating still gets its title in the new language. normalizeLocale maps any language tag — the server's, the browser's, or a stored one — onto a supported locale or null. An exact match wins; otherwise a tag beginning en becomes en, and a tag beginning zh becomes zh-Hant when it carries the hant script subtag or a TW, HK or MO region, and zh-Hans otherwise. Anything else yields null. applyLocale and the boot file's browser-language fallback each turn that null into en; the boot file's read of the stored value instead treats it as a cache miss and asks the server, so an unsupported stored code takes the cold-start path rather than pinning English. Only two modules call applyLocale: the boot file, and the app-state store's language action. The store updates its own languageCode optimistically, POSTs the new value, adopts the current and available the server echoes back, and only then applies the locale — so the UI text flips after the server has accepted the value, and a failed POST rolls the store reference back without any visible language change. Boot wwwroot-src/quasar.config.ts lists three boot files in the order auth, i18n, routine-toast. The i18n file is placed after auth because auth patches the global fetch for the 401 login gate, and the language request the i18n file makes must go through that patch on builds where login is enabled. The boot file installs the plugin and then reads the hinc.lang value: Cache hit. The cached locale is applied immediately, so the first painted frame is already translated, and a reconcile against the server is fired without being awaited. The server value is the source of truth, so a disagreement — the language was changed from another browser — repaints shortly after mount. Cache miss. The file returns a promise racing the language request against a four-second timeout, and mount waits on it. A dead backend rejects quickly; a hung one is capped by the timeout rather than blanking the application. Either failure falls back to the normalized browser language, and then to English. Every locale step is individually guarded, because a boot file that throws does not degrade to English — the client entry logs the error and never mounts. The one unguarded step is installing the plugin itself, without which nothing in the application can render a translated string at all. The worst case the guards preserve is an application that mounts in English. The shipped wwwroot-src/index.html is static and carries lang=\"en\", so the very first painted frame always reports English on the root element; applyLocale corrects it in the same tick as mount. What Re-Renders A locale change is a write to one reactive ref, so everything that reads a translation inside a render or a computed re-evaluates on its own. Five things follow it in practice: Component text. Every t() call in a template or computed. Quasar's built-in texts, through the language pack the same call sets. The tab title. Route records carry an i18n key in meta.title; the router resolves it against the active locale and composes the title from it. It re-resolves both after a navigation and from the hook applyLocale calls. Control-Tree node labels, described below. Engine session messages, which are re-resolved because the localizing helper reads the locale ref, so rows built inside a computed rebuild on a switch. File Explorer sorting is the one thing that does not follow on its own. The shared collator is a live let binding rather than a reactive one: applyLocale rebuilds it for the new locale, but no render tracks it and FileExplorer.vue watches no locale, so a listing already on screen keeps its pre-switch order until the next folder load or sort-spec change re-runs the comparison. Because the binding is live, a caller must invoke collator.compare(...) in place; capturing the instance or extracting its compare would pin the pre-switch locale for good. explorerSort.ts is its only consumer, and no bare localeCompare — whose undefined locale argument means the browser locale — is called anywhere in the client. Numbers deliberately do not follow the locale. Intl.NumberFormat is used nowhere in the client, and the only toLocale* calls are two triangle counts and two timestamps, each passed the app locale explicitly rather than defaulting to the browser's. NC and machine-tool quantities go through no locale-aware number formatting at all, so a coordinate never picks up a comma decimal separator from a locale that uses one. Control-Tree Node Labels A Control-Tree node carries both a label and an optional labelKey, and nodeDisplayLabel(n) in itemTypes.ts returns the translation of labelKey — with the node's labelParams interpolated — whenever one is set, and the verbatim label otherwise. nodeDisplayInfo applies the same rule to a group stem's intro text through infoKey over info. The translator function is read inside the call rather than captured at build time, so the computed that maps nodes onto the rendered tree tracks the locale ref and the whole tree's role labels change on a switch. The two fields overlap on purpose. label is required on the node type and labelKey is optional, so a fixed role label is written both ways: the key that actually renders, and the verbatim English sitting beside it as the fallback nodeDisplayLabel returns when no key is set. label is also the only storage for text that can never be a key at all — server-composed mission titles, file-backed geometry paths, and engine type names. It is the first of those two jobs, not the second, that makes the verbatim English on node labels the largest single class in the census allowlist: fixed role labels the census can see but the screen never shows, classified rather than removed because the node type requires the field. Mission command nodes are the one family that never takes the key path. A node's label is the title the server composes for the command — the kind name in the request language, with the command's own text in brackets when there is one — and Missions/MissionController.cs fills that title in for every entry: from the command's own composition where it implements the engine's title contract — whose rule keeps the kind name at the front and never drops it — and from the kind's display name, resolved in the request culture, where it does not. Because a title is therefore always present, the node's labelKey is always dropped and the client's kind-name fallback never fires. Since the composition happens on the server per request, the tree host watches the locale and re-reads the command entries, rewriting those labels in place; it deliberately does not rebuild the branch, which would remount an open command editor mid-edit. The kind keys are still built as tree.mission.kind.${commandType}, and they do render — AddCommandDialog.vue prefers one over the server's label for every kind that has one — while the key lint resolves the template shape by wildcard rather than reporting an orphan. The Server Half The language preference is server-held. GET /api/preference/language answers { success, current, available }, where current is the persisted UserConfig.LanguageCode — default en — and available is the server's own supported list, en, zh-Hans, zh-Hant. POST rejects an unlisted code with 400 and otherwise writes the value and saves the user configuration, which round-trips through the XML user config file. The localStorage key holds only a paint-time hint and loses every disagreement with this value. Some response text is composed on the server and never passes through a bundle. PresentCatalogService resolves the effective language per request in this order: an explicit ?lang= query, then the request's Accept-Language header, then the persisted preference, then English. Because the header sits above the saved preference, a browser set to a different language than the application would win by default — so the client sends ?lang= explicitly, from a currentLang() helper returning the app locale, on the endpoints whose text is localized server-side: the selected-step info, the execution strip chart, its step-property picker and its colour guide, the mission command entries, catalog and field descriptors, and the step-present key list. The mission controller resolves the same chain into a per-request UI culture and injects it into the command text source, so the culture rides on the request rather than on the thread. Two further server-originated string classes are localized on the client instead: Coded API errors. Ten error codes are mapped onto apiErrors.* keys; a failed response carrying one of them renders the bundle value with the server's interpolation arguments. English is passed straight through to the server's own message on purpose, because that message is the English rendering and keeps per-site nuance the generic bundle value flattens. Engine notifications. Session messages arrive with a structured id and English text. The client swaps in an engineMessages.<id> bundle entry, but only when the wire text agrees with the English bundle entry for that id: a templated message must match the canonical English template exactly before its arguments are re-interpolated, and an untemplated one is swapped only when the bundle entry has no interpolation holes. Any mismatch — an id emitted with different templates at different sites, or an engine built against a different bundle — falls back to the wire English rather than rendering wrong text. The English engineMessages values are therefore load-bearing code, not a description of the Chinese ones. The step-present labels have a third home again: they ship beside the executable as catalog.{lang}.json files that overlay translations on top of the live English attribute data. English never comes from those files, and a missing file, a missing key or a parse failure simply means English. The Glossary and the Build Gate Two Node scripts stand between the bundles and a shipped release. wwwroot-src/package.json defines lint:i18n as census.mjs followed by lint-glossary.mjs, and build as lint:i18n followed by quasar build — so either script failing stops the production build. The development server runs neither. lint-glossary.mjs bundles each locale's index through esbuild, flattens the three message trees into key/value maps, and applies four checks, every one of them a hard failure: Key isomorphism. The three flattened key sets must be identical, compared in both directions, so an extra key in a Chinese bundle fails as loudly as a missing one. Bidirectional key integrity. Every bundle-shaped string literal under the source tree — excluding the bundles themselves — must resolve to an English key, and every English key must be referenced from somewhere. A literal naming a namespace prefix counts as a reference to everything beneath it; a template literal with an interpolation hole is expanded into a wildcard, which is how tree.mission.kind.${kind} is matched; and @:linked.key references inside bundle values count as well. A double-quoted literal in a Vue template is treated as a key only when its attribute is one of the four the check knows to be key-valued, so an expression attribute whose local variable happens to share a namespace name is not mistaken for one. The orphan half is what makes the check bidirectional, and its allow-list is currently empty. Shape preservation. Never-translate tokens present in an English value must survive verbatim in both Chinese values — product and brand names, file formats and unit symbols by literal match, and NC codes, controller parameter names and function-key shortcuts by pattern. Placeholder sets must match in both directions, so a Chinese value can neither lose a placeholder nor invent one. Per-locale vocabulary. An adjudicated forbidden-term table per locale, each entry naming its replacement and its reason, plus a check for a Chinese value identical to its English source that contains no CJK at all. Both carry narrow exemptions: named keys where a term is used in a different sense, and a small identity set for values that legitimately are the identifier. The tables the third and fourth checks read are written at the top of the script itself. glossary.yaml, the large harvested term list that sits beside the bundles, is generated data that the application never imports and the lint never reads: it is where a reading is settled before it is written into a bundle, not an input to the gate. census.mjs guards the opposite direction — text that never became a key. It scans the same tree for user-visible English string literals reached through display-named template attributes, display-named object properties, notification and dialog shorthands, and prose text nodes; subtracts a classified allowlist of concrete text-and-file pairs; and compares what is left, per file, against a baseline. The gate fails only when a file's residual count rises, so cleanup can land incrementally — but the baseline is currently empty, which allows zero residual strings in any file and makes the effective rule that a newly hard-coded display string fails the build unless it is added to the allowlist with a reason. Allowlist entries whose file field is a glob or a brace list are classification notes rather than matchers; only concrete paths participate. Strings Outside the Bundles Three classes of user-visible English render in every locale — two because an interpolation hole hides them from the census, which discards any literal containing one, and one because the allowlist deliberately keeps it: The shared numeric field's validation text. NumericInput.vue imports nothing from vue-i18n and builds three messages as template literals directly: an invalid-number message quoting what was typed, a “must be ≥” message naming the field's minimum, and a “must be ≤” message naming its maximum. All three are produced on blur — the field commits on blur or on Enter — and every panel that embeds the widget shows them in English. A widgets namespace exists for exactly this kind of shared control text; this component does not use it. The geometry and topology editors' error prefixes. Those editors emit their failure context as a template literal that leads with the type name and the operation, so the leading phrase is English whatever the locale. The allowlist records the family as a ledger note rather than as matched entries. The API-error default. The generic fallback message in the HTTP helper is allowlisted deliberately, on the grounds that it sits in the same stream as the server's own English messages. A fourth class is untranslated by design rather than by escape: the dynamic label text on a Control-Tree node — a file-backed path, an engine type name, and the user's own words inside a server-composed mission title — and the identity strings the allowlist classifies alongside it, which are backend type names rendered inside a translated sentence, axis and unit column headers, and brand names. The role-label half of that same allowlist class is a different case again: stored English that never reaches the screen at all, because a labelKey always resolves ahead of it. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/i18n/index.ts — the vue-i18n instance and its fallback chain, SUPPORTED_LOCALES, normalizeLocale, applyLocale, the Quasar language-pack map, the shared collator, the storage key and the re-title registration. wwwroot-src/src/i18n/schema.ts — the English bundle as MessageSchema. wwwroot-src/src/i18n/schema.d.ts — the ambient augmentation that registers that shape as vue-i18n's global message schema. wwwroot-src/src/i18n/en/index.ts — the English bundle: the twenty-three namespaces assembled into one object. wwwroot-src/src/i18n/zh-Hant/index.ts and wwwroot-src/src/i18n/zh-Hans/index.ts — the same assembly, each annotated with MessageSchema. wwwroot-src/src/i18n/en/engineMessages.ts — the engine-notification renderings keyed by structured id; its English values are the eligibility gate for every swap. wwwroot-src/src/i18n/en/routes.ts — the strings the routes' meta.title keys resolve to. wwwroot-src/src/i18n/en/widgets.ts — the shared-widget namespace. wwwroot-src/src/i18n/README.md — the invariants written beside the bundles: the fallback rule, the never-translate list, the number and sorting rules and the vocabulary table. wwwroot-src/src/i18n/glossary.yaml — generated term data, imported by nothing. wwwroot-src/src/boot/i18n.ts — the plugin installation, the cached-locale fast path with its unawaited reconcile, the awaited race on a cache miss, and the guards around every locale step. wwwroot-src/quasar.config.ts — the boot list whose order places i18n after the authentication fetch patch. wwwroot-src/index.html — the static shell whose lang attribute is corrected at mount. wwwroot-src/package.json — build as the i18n scripts followed by quasar build, and vue-tsc as a separate script. scripts/lint-glossary.mjs — the four bundle checks and the adjudication tables they read. scripts/census.mjs — the raw display-string extraction, the allowlist subtraction and the per-file ratchet. scripts/i18n-allowlist.json — the classified exemptions, each with its reason. scripts/i18n-baseline.json — the per-file residual ceiling the census compares against. wwwroot-src/src/stores/appState.ts — the language reference, the available-code list, and the action that POSTs before applying the locale and rolls back on failure. wwwroot-src/src/api/preference.ts — the typed wrappers over the language endpoints and the ?lang=-bearing step-present key request. wwwroot-src/src/api/http.ts — currentLang(), the coded-error map and the app-locale rendering that skips English. wwwroot-src/src/api/sessionMessages.ts — the engine-notification localizer, its template-equality gate and the repeat-fold wrapper. wwwroot-src/src/components/controlTree/itemTypes.ts — the node's label, labelKey and labelParams fields and the nodeDisplayLabel and nodeDisplayInfo resolvers. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — the rendered-tree computed that calls the resolver, and the locale watcher that re-pulls the server-composed mission command titles without rebuilding the branch. wwwroot-src/src/components/controlTree/missionItemTypes.ts — the kind display names and their tree.mission.kind.* key twin, and the rule that drops the key whenever the entry carries a title. wwwroot-src/src/components/widgets/NumericInput.vue — the shared numeric field: blur-and-Enter commit, and the three hard-coded validation messages. wwwroot-src/src/components/AppMenuBar.vue — the language submenu, its hard-coded self-name map and the action it calls. wwwroot-src/src/components/explorerSort.ts — the only consumer of the shared collator, calling it in place so a switch is picked up. wwwroot-src/src/router/index.ts — the key-valued meta.title resolution and the hook the locale switch calls to re-title a parked tab. Environments/PreferenceController.cs — the language endpoints, the supported-code list and the 400 on an unlisted code. Environments/UserConfig.cs — the persisted language code, its English default and its XML round-trip. Environments/PresentCatalogService.cs — the per-request language resolution chain, the tag normalizer and the shipped catalog overlay. Missions/MissionController.cs — the per-request UI culture taken from the same chain and injected into command title composition. See Also Language Selection SubMenu — the menu gesture that drives this mechanism, and the only place a user changes the locale Translation Remarks — the terminology contract the bundles are written to, and the readings the vocabulary lint enforces"
  },
  "anatomy/platform/index.html": {
    "href": "anatomy/platform/index.html",
    "title": "Platform | HiAPI-C# 2025",
    "summary": "Platform The machinery every route sits on and no user can point at. A page in this folder documents something that has no owning screen: the Control-Tree engine two pages share, the id and route surface three pages hang off, the state that survives a navigation, the locale bundles behind every label, the gate in front of the whole app, and the host process under all of it. The boundary with Conventions is which side of the page the reader is on. Conventions holds a rule a page author must follow; Platform holds machinery a page author must understand and never touches. Two of these are ordinary routes rather than mechanisms — /login and /preference/log. They sit here because what they document is the platform surface, not a step in a machining workflow. Ordered from the machinery a page sits closest to, outward to the host process beneath it. Pages Control Tree — The engine both tree pages share: the node shape, the item-type registry, branch building, the selection gate and the panel host Tree Ids and Routes — The URL surface: the route table, the redirect-only paths, and how a ?tree= id is migrated and landed on the page that owns it Session State — The project epoch behind the keep-alive, the stores and module singletons outside it, and what is device-local Internationalization — Three locales over one English schema: the bundles, the single switch point, the build-gating lint, and the strings that never reach a bundle Login and Authentication — The optional login gate: the sign-in screen, the config switch that turns it on, the cookie scheme and fallback policy it registers, and the router guard in front of them Log Viewer Page — The read-only /preference/log screen: today's server log file, its auto-refresh, and the daily file sink behind it Program and Hosting — The ASP.NET Core host: the HiAPI start/stop pair, the all-singleton container, the SignalR hubs, the SPA fallback, and the configuration that pins the listening address See Also Conventions — the other cross-screen folder: the rules an author follows rather than the machinery an author reads Anatomy by Source Directory — the inverse index, for entering by the directory a change landed in"
  },
  "anatomy/platform/log-viewer.html": {
    "href": "anatomy/platform/log-viewer.html",
    "title": "Log Viewer Page | HiAPI-C# 2025",
    "summary": "Log Viewer Page The Log Viewer is the read-only screen at /preference/log, route name preference-log, that renders the web service's own log file for the current day. It is not a Control-Tree page and takes no ?tree= query: the whole page is one toolbar over one scrolling text area. Despite the route path it is not an entry of the Preference dropdown, and it is not under /util/. Reaching the Page The only navigation into the page is the Show Log button on the menu bar. It sits in the bar's right-hand group, after the active-page title and its separator and before the logout button, and it carries the article icon with the tooltip View the application log. The button is rendered unconditionally — no route, project, licence or authentication state hides it — so it is reachable from every page in the shell. The Preference dropdown carries the Language submenu, the CSV and CL Controller visibility checkboxes and Show Physics Options, and no log entry; the Page dropdown does not list the route either. The route sits inside the main layout, so the page renders under the same menu bar and footer as every other page, and it is behind the login gate whenever that gate is on — the router's navigation guard admits only the login route itself while the session is unauthenticated. The route carries an i18n title key, so the browser tab reads Log Viewer - HiNC and the menu bar's active-page indicator reads Log Viewer. What It Reads Two endpoints, both on the project controller, and both served from the same file: Request Answer GET /api/project/logs { date, content } for today's file; 404 with a message when there is none GET /api/project/download-log the same file as a text/plain attachment; 404 with the same message when there is none Both compose logs/log-{yyyy-MM-dd}.txt beneath the process's current working directory and date the name from the server's local clock. Neither supports a range or a tail: the whole file is read into memory and returned in full on every call, so an auto-refresh at a short interval re-transfers the entire log each tick. Any failure inside either handler answers 400 with the exception message. The two client wrappers part company on that 404. The wrapper over logs normalises it into an empty result rather than an error, which is what gives the page a clean “no log yet” state instead of a red panel; every other non-OK status there is raised as a typed error carrying the HTTP status and the response body. The download wrapper normalises nothing — 404 included, every non-OK status becomes that same typed error, a path the disabled-without-content Download button makes hard to reach. Because the controller declares no anonymous carve-out, both endpoints fall under the authenticated-user fallback policy when the login gate is enabled. The date badge shows whatever date the last answer reported. On the 404 path that date is not the server's — the client fills it from the browser's own clock in UTC — so with no log file present the badge can read a different day than the file name the server would have used. Refresh and the Auto Interval The page loads once on mount. After that every reload is driven by one of three things: the Refresh button, the Retry button inside the error panel, or the auto-refresh timer. Auto-refresh is off by default. The Auto toggle arms it and the interval select beside it chooses the period from a fixed list of 2 s, 5 s, 10 s and 30 s, defaulting to five seconds; the select is disabled while the toggle is off, but it keeps its value. The period is picked from that dropdown rather than typed, so it takes effect on selection. A change to either control tears the existing timer down, and a fresh one starts only while the toggle is still armed: an interval change therefore takes effect immediately but also restarts the countdown, while disarming the toggle simply stops the timer. Arming the toggle schedules the first automatic load one full interval later; it does not fetch straight away. Ticks are not coalesced with a request already in flight — each tick starts the same load unconditionally. Neither the toggle nor the interval is persisted. They are page-local state, held in neither the browser's local storage nor the server-side user preferences, so a browser reload returns both to their defaults. The Page Is Kept Alive The shell caches routed pages in a keep-alive keyed on the project epoch. Leaving the Log Viewer therefore deactivates it rather than unmounting it, and the page's teardown hook — the one that stops the timer — does not run. Two consequences follow. An armed auto-refresh keeps polling the log endpoint in the background after navigation away, until the keep-alive is rebuilt by a project change or the browser reloads. And returning to the page does not re-run the initial load: the previous content, its last loaded stamp, the toggle and the chosen interval are all still there, and the view refreshes on the next tick or on Refresh. Errors and Scroll Position A failed load fills the page's error state and also pushes one foreground line onto the shell's routine-progress footer, so the failure is visible from any page. The error panel takes precedence over content in the text area, so a failed refresh hides the text that was already loaded — but only until the next attempt starts, because the error text is cleared before that request goes out. The content itself is never discarded: it reappears the moment the attempt begins, and the error panel returns only if that attempt fails as well. With auto-refresh armed against an endpoint that keeps failing, the text and the panel therefore alternate on every tick. After a successful load the view scrolls to the bottom, but only while it is already stuck there — the scroll handler treats a distance of less than 30 px from the bottom as stuck. Scrolling up therefore freezes the position through an auto-refresh, and scrolling back to the bottom re-arms the follow behaviour. Level Filtering, and Where the File Comes From The page applies no filtering of its own. There is no level selector, no category selector, no search box and no date picker: it renders the file it is given, verbatim, in the order it was written. Which entries reach the file at all is decided at write time, by the host's logging filters rather than by anything on this screen — see Program and Hosting for those rules and how they differ from the console provider's. The sink is a daily file logger provider registered at startup against a logs folder under the process's current working directory. It writes one entry per line as [yyyy-MM-dd HH:mm:ss.fff] [Level] Category - message, appends the exception on its own lines when there is one, serialises appends behind a lock and swallows every I/O failure, on the principle that logging must never fault a request. Logging scopes are not rendered into the file. The application writes one Information line immediately after the host is built, so the file for the day the service starts has content before the first request arrives and a freshly started service shows something rather than an empty state. The sink recomposes the file name from the clock on every append, so a service left running past midnight has no file for the new day until something is logged, and the page shows its empty state until then. Only the current day's file is reachable. Previous days' files stay on disk and the page offers no way to open one. A file that exists but is empty renders the same empty state as a missing one; only the date badge can separate the two, since the empty file's date comes from the server's answer and the missing file's from the browser's UTC clock. The same controller also exposes a POST endpoint that appends a caller-supplied line to the same daily file. It writes with its own formatting rather than through the logger provider, and nothing in the shipped SPA calls it. Copy, Download, and What the Page Cannot Do Copy writes the loaded text to the system clipboard and reports the outcome as a toast, positive or negative. Download fetches the file as a blob from the download endpoint and saves it client-side under the name log-<date>.txt, repeating the date the last answer reported, and also ends in a toast. Both buttons are disabled while there is nothing loaded. The page cannot clear, truncate, rotate or delete the log — there is no destructive action on it at all, and no endpoint behind it that would perform one. It cannot reach another day, filter by level or text, or stream: refreshing is polling over the same whole-file request, with no hub connection and no server push. It is a viewer. Layout Log Viewer Page — a viewport-locked page sized from the layout's measured header and footer, so the window itself never scrolls Top Tool Bar Log Viewer Title Date Badge — outlined; carries the date the last answer reported, and reads today only before any answer has set one. Coloured as the primary accent while content is loaded and grey otherwise Last-Loaded Caption — last loaded: {time}, shown once a load has succeeded. The time is formatted in the application locale rather than the browser's, so it re-renders on a language switch; the hover title carries the same instant as an ISO 8601 UTC string Line Count Caption — shown only while content is loaded, where it reads {count} lines. The plural string's no lines and one line forms are out of reach: a zero count is exactly the state that hides the caption, and every writer ends its entry with a newline. The count is the number of newline-separated segments, so a file ending in a newline counts one more than it shows, and a multi-line exception counts as several Auto Toggle — arms auto-refresh; off by default. Tooltip Re-fetch the log file periodically Interval Select — 2 s / 5 s / 10 s / 30 s, defaulting to 5 s; disabled while Auto is off Refresh Button — reloads at once, and shows a spinner in place of its label while the request is in flight. Tooltip Reload the log file Copy Button — disabled without content. Tooltip Copy log content to clipboard Download Button — disabled without content. Tooltip Download today's log file Separator Log Area — a dark, monospaced, scrolling region filling the rest of the page. Long lines are not wrapped, so it scrolls in both directions. It shows exactly one of four things: Error Panel — an error icon, the failure message, and a Retry Button that repeats the load Empty Panel — a document icon, No log file for today., and the hint Log file will appear once the webservice writes its first entry. Log Content — the file's text, preformatted and read-only, with no folding, no line numbers and no per-line affordance of any kind Loading Spinner — with Loading log... beneath it, shown while a load is in flight and nothing has been loaded yet Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/pages/LogViewerPage.vue — the whole page: the toolbar, the four states of the log area, the auto-refresh timer and its watcher, the stick-to-bottom scroll rule, and the copy and download handlers. wwwroot-src/src/api/logs.ts — the typed wrappers over the two endpoints, the 404-to-empty normalisation with its browser-clock date fallback, and the error type carrying the HTTP status. wwwroot-src/src/router/routes.ts — the preference/log path, the preference-log route name and the title key the tab and the menu bar's active-page indicator resolve. wwwroot-src/src/router/index.ts — the login guard the route passes through, and the retitle hook that names the browser tab. wwwroot-src/src/components/AppMenuBar.vue — the always-visible Show Log button in the bar's right-hand group, and the Preference dropdown that carries no log entry. wwwroot-src/src/layouts/MainLayout.vue — the keep-alive that caches this page rather than unmounting it, and the project epoch that rebuilds the cache. wwwroot-src/src/stores/appState.ts — the message action that forwards a load failure to the footer's foreground channel. wwwroot-src/src/stores/routineProgress.ts — the foreground-message store that failure lands in. wwwroot-src/src/utils/pageFit.ts — the page-height function that locks the page to the measured viewport so only the log area scrolls. wwwroot-src/src/i18n/en/logs.ts — the page's own English strings: the title, the empty and loading states, the plural line count and the tooltips. wwwroot-src/src/i18n/en/menu.ts — the Show Log label and its tooltip. wwwroot-src/src/i18n/en/common.ts — the shared Auto, Refresh, Copy and Download labels. wwwroot-src/src/i18n/en/routes.ts — the Log Viewer route title. Environments/ProjectController.cs — the two endpoints the page reads, both resolving today's file under the working directory, plus the append endpoint nothing calls. Common/DailyFileLoggerProvider.cs — the sink: the per-day file, the entry format, the lock, the swallowed I/O failures and the null scope. Program.cs — registers that provider and its level filters, and writes the one startup entry right after the host is built. See Also Main Panel — the menu bar whose right-hand Show Log button is the only navigation into this page Preference Menu Dropdown — the dropdown this route's path is named after, and which carries no log entry of its own"
  },
  "anatomy/platform/login-and-auth.html": {
    "href": "anatomy/platform/login-and-auth.html",
    "title": "Login and Authentication | HiAPI-C# 2025",
    "summary": "Login and Authentication The sign-in screen is the /login route. Whether anyone ever reaches it is decided by one back-end setting — the Enabled flag of the Auth configuration section: with the flag off the service is open and the route sends every visitor straight back out, and with it on a cookie-authentication scheme plus a global authorization fallback policy lock every hub and every controller but the authentication one — the whole api/ surface apart from api/auth — until a visitor signs in. The route hosts no Control-Tree branch and takes no tree query argument. The Enable Switch, and Its Two Defaults AuthConfig binds the Auth section of configuration and is registered as one instance, so the authentication controller and the startup decision read the same object. Two different values answer the question “is the gate on by default”, and conflating them gets the answer wrong on a real instance: The class default is off. Enabled initialises to false, so a service whose configuration carries no Auth section — or an empty one — runs with no login at all. The shipped configuration turns it on. appsettings.json and the Development overlay both set Enabled to true and both supply one credential entry, so a service started from the repository as it ships demands a sign-in. Three further settings live in the same section. SessionHours defaults to 8 and is raised to 1 at registration if a smaller number is configured. SlidingExpiration defaults to true. Users is a list of username and password pairs and defaults to empty. That list is the whole credential store. Passwords are held in the configuration file in clear text and compared verbatim — a first-match scan for an exact username and password — so there is no hashing, no lockout, no rate limit and no user database behind it. The class documents the clear-text form as deliberate, because the project also ships as sample code. Every entry grants the same access; there are no roles. Enabled set to true over an empty list therefore admits nobody. What the Gate Registers The flag guards exactly two registrations at startup: a cookie authentication scheme, which becomes the application's default and only scheme, and a global authorization fallback policy requiring an authenticated user. The fallback policy is what does the locking. It applies to every endpoint carrying no authorization metadata of its own — every controller in the host assembly except the authentication one, and all eight SignalR hub routes. UseAuthentication and UseAuthorization are added to the request pipeline unconditionally and are no-ops when neither registration happened. See Program and Hosting for the pipeline order this sits in. Three places in the host carry AllowAnonymous, and they are the only ones that do: The authentication controller itself, marked at class level, so all three of its endpoints stay reachable under the policy that locks everything else. Both SPA fallbacks, so the client shell — which carries no data of its own — can load and show its own login screen. Two pipeline stages answer before the authorization stage is reached and are unaffected by the policy: static-file serving and the Swagger middleware. The first of those is what lets the login screen render before anyone has signed in — the built bundle and the brand image it draws are physical files under the web root. With the gate off, none of this is registered: every controller, every hub and both fallbacks are open, the login endpoint answers success without inspecting anything, the client's navigation guard short-circuits, and the login route bounces the visitor away as it mounts. The Cookie The scheme issues a cookie named HiNC.Auth. It is HttpOnly, its SameSite mode is Lax, and its secure policy is same as request — marked Secure when the request itself arrived over HTTPS and issued plainly otherwise, so a plain-HTTP run on a local network still works. That decision is one of the reasons forwarded headers are applied first in the pipeline, the HTTPS-redirection stage being the other: behind a TLS-terminating reverse proxy the scheme must be read from X-Forwarded-Proto rather than from the plain hop between proxy and service. The ticket carries exactly one claim, the name of the matched user. Its lifetime is the configured session length, refreshed on activity when sliding expiration is left on. Sign-in passes no authentication properties, so the ticket is not marked persistent and the cookie carries no Expires attribute: the browser holds it for the browser session, and the ticket's own expiry bounds a session left open. One event pair is overridden, and it is what makes a single-page client possible at all. A challenge answers 401 and a refusal answers 403, in place of the framework's default redirect to a server-rendered login page. Every protected call therefore fails as data the client can read rather than as a 302 that would arrive at the fetch layer as an HTML page. The Auth Endpoints The controller is routed at api/auth and holds three endpoints. Endpoint Behaviour GET status Reports whether the gate is enabled, whether this caller is authenticated, the caller's name, and a version string. It is anonymous, so it answers before sign-in and whether or not the gate is on. POST login With the gate off, returns success without inspecting the body. With it on, scans the configured users for an exact match and either answers 401 with an English message plus the stable code InvalidCredentials, or signs the caller in. POST logout Signs the caller out when the gate is on, and reports “not authenticated” either way. The version the status endpoint reports is the HiNc assembly version, ApiVersion(API). Because the endpoint is anonymous, that value is readable before sign-in, which is what lets the login screen and the menu bar show the same version mark. Nothing else in the host reads the signed-in identity — the status endpoint is its only consumer. Every application service is registered as a process-wide singleton — the host adds no scoped or transient registration of its own — so authentication decides admission rather than identity: two signed-in browsers drive the same project and the same session. See Session State for what that shared state consists of. The Client Side The Store A Pinia store holds the whole client-side picture: whether the gate is enabled, whether this session is authenticated, the user name, the version string, and a ready flag set once the first status probe has resolved. refresh reads the status endpoint; login and logout call their endpoints and update the same fields; a fourth action flips the store to logged-out with no round trip, for the interceptor below. Every transition re-drives the hub gate. The Navigation Guard One global beforeEach guard runs the whole client-side decision, in order: If the store is not ready yet, hydrate it from the status endpoint, inside a try/catch that swallows the failure. The ready flag is set only on success, so a failed probe is retried on the next navigation. If the gate reports disabled, allow the navigation. If the target is the login route, allow it. If the session is not authenticated, redirect to the login route with the blocked target's full path — query arguments, tree included — parked in a redirect argument. Otherwise allow it. What the guard does not do is protect anything. It is a navigation redirect: it runs on router navigations only, so it has no bearing on a direct api/ request, on a hub negotiate, or on a static asset, all of which are the fallback policy's business. It reads no per-route metadata, so there is no list of public routes beyond the login route itself and no notion of a role. And it fails open by construction — when the status probe throws, the store keeps the gate disabled and the navigation is allowed, so a back-end hiccup cannot lock a user out of an installation that has no gate. The 401 Interceptor A boot file wraps the global fetch once for the whole application. Every API module, and SignalR's own negotiate, call that global, so one wrapper covers a session that expires mid-use: on any 401 response, and only while the store says the gate is enabled, it marks the store logged out and pushes the login route with the current full path in redirect, unless the router is already there. The response is handed back unchanged, so the calling code still sees its own failure and handles it. Boot order is load-bearing here. The interceptor's boot file is declared ahead of the i18n one, and boot files are awaited in declaration order, so the locale probe made during startup goes through the patched fetch. The Hub Gate The shared-hub registry carries one tri-state gate that the store drives on every transition: undecided while the status probe is still resolving, closed while the gate is on and the session is signed out, and open for a signed-in session or a service with no gate. Undecided holds, so a first-paint race never fires a negotiate that is certain to fail; closed keeps every hub idle rather than letting the never-give-up reconnect schedule hammer a /negotiate that answers 401 by design. The store releases the gate even when the status probe fails, so a probe hiccup never strands the hubs of a service that has no login. Opening the gate resumes the connections a caller had already asked for, without the caller asking again. After a Successful Sign-In The login screen navigates with a full page load rather than a router navigation. The application's one-shot wiring — the project hub subscription and the first project-status fetch — sits behind a watcher on the auth predicate and runs once per page load, so reloading is what re-runs it with the cookie present. Signing Out The logout control sits at the right of the menu bar and renders only while the gate is enabled and the session is authenticated. It is labelled with the signed-in user name, falling back to Logout when the status carries no name, and its tooltip reads Log out. It posts the logout endpoint and then, in a finally, hard-navigates to /login — so a failed request still tears the page down and rebuilds the client from scratch, rather than leaving the singletons of an ended session wired up. Layout The route renders outside the shell layout, in a Quasar layout of its own — the same arrangement the catch-all not-found route uses. Nothing of the application frame is present: no menu bar, and therefore no Project, Page or Preference menu and no language submenu; no cached page panel; no routine-progress footer. The browser tab reads Login - HiNC. Login Page — a single card centred on an empty page Brand Section Brand image, above the literal title HiNC Version caption, v followed by the version string — drawn only when the status probe returned one Prompt caption — Please sign in to continue Separator Sign-In Form Username Text Field — autofocused on arrival, disabled while a sign-in is in flight Password Text Field — masked, with a trailing eye icon that toggles the text visible; the icon's accessible label alternates between Show password and Hide password Error caption — drawn in the negative colour, and only after a failed attempt Sign In Button — submits the form and shows a spinner while the request is in flight Pressing Enter in either field submits the same form. Neither field carries a validation rule, so an empty pair is submitted and refused by the server like any other wrong pair. The error caption shows the localized “Incorrect username or password” whenever the server pairs its refusal with the InvalidCredentials code, and the server's own English message for any other refusal that carries one. Two cases send the visitor away again as soon as the screen mounts. The mount hook hydrates the auth status if the first probe has not resolved yet, and then replaces the route with the parked redirect target — or with /, which redirects on to the Execution page — when the gate reports disabled or when the session is already authenticated. The locale the screen paints in is whatever the boot sequence resolved, because the stored language preference is served by an endpoint the fallback policy locks. With a browser-local cached locale the screen paints in that; without one the awaited probe fails and the locale falls back to the browser's own language, and to English after that. The screen's own strings ship in all three locales. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): Common/AuthConfig.cs — the bound shape: the enable flag and its class default, the session length, the sliding-expiration flag, and the clear-text user list. Common/AuthController.cs — the anonymous api/auth controller: the status projection, the first-match credential scan with its message and code pair, the single name claim it signs in, and the sign-out. Program.cs — the flag-guarded registration of the cookie scheme and the fallback policy, the cookie name and flags, the 401 / 403 event overrides, the forwarded-headers configuration ahead of them, and the two anonymous SPA fallbacks. wwwroot-src/src/pages/LoginPage.vue — the screen: its own Quasar layout, the card and its fields, the bounce on mount, and the full page load after a successful sign-in. wwwroot-src/src/router/routes.ts — the login route outside the shell layout, and the title key the tab shows. wwwroot-src/src/router/index.ts — the navigation guard: the once-only hydration, the disabled and login-route short circuits, and the redirect carrying the full path; also the retitle that composes the tab text from the route's title key. wwwroot-src/src/stores/auth.ts — the client-side state, the four actions, and the hub gate each of them re-drives. wwwroot-src/src/api/auth.ts — the three typed endpoint wrappers, and the mapping of the server's refusal code onto the localized message. wwwroot-src/src/boot/auth.ts — the global fetch wrapper that turns a 401 into a logged-out store and a push to the login route. wwwroot-src/quasar.config.ts — the boot-file order that puts the interceptor ahead of the locale probe. wwwroot-src/src/boot/i18n.ts — the locale resolution the login screen paints in, and its fallback chain when the language endpoint answers 401. wwwroot-src/src/composables/useSharedHub.ts — the tri-state hub gate and what each of its states does to a connection. wwwroot-src/src/App.vue — the one-shot wiring held behind the auth predicate, which is what the post-sign-in page load re-runs. wwwroot-src/src/components/AppMenuBar.vue — the logout control and the version badge, both drawn from the auth store. wwwroot-src/src/i18n/en/auth.ts — the screen's English strings. wwwroot-src/src/i18n/en/menu.ts — the Logout label the control falls back to, and its Log out tooltip. wwwroot-src/src/i18n/en/routes.ts — the Login route title the browser tab resolves. HiAPI Engine HiNc/MachiningProcs/MachiningProject.cs — the assembly version the status endpoint reports and the screen shows. See Also Program and Hosting — the host that binds the Auth section and registers the scheme, the fallback policy and the anonymous carve-outs described here Main Panel — the shell this screen renders outside of, and the menu bar that carries the logout control and the version badge"
  },
  "anatomy/platform/program-and-hosting.html": {
    "href": "anatomy/platform/program-and-hosting.html",
    "title": "Program and Hosting | HiAPI-C# 2025",
    "summary": "Program and Hosting Program.cs is the entire host of the HiNC web service: one class whose Main builds an ASP.NET Core application and runs it. It presents no screen of its own — it is the process that starts and stops HiAPI, registers every service the controllers and hubs resolve, maps those controllers and the eight SignalR hubs, serves the built Quasar SPA out of the web root, and falls back to the SPA shell for every URL the Vue router owns. BuildApp is public and returns the built application without starting it, so the build phase and the run phase are separable; Main calls it, writes one startup line to the log, and runs. HiAPI Lifetime The host brackets its whole life in one pair of HiAPI calls. AppBegin(API) runs once during BuildApp, after the service container is built and before the request pipeline is configured. It logs in every licence License holds, initialises the display engine (DispEngine), and opens the SQLite step-cache database at the path it is given, publishing it as SqliteStepStorage's default instance. The overload the webservice calls takes a logger and a cache-database path. AppEnd(API) unwinds the same set in reverse: it waits for queued background CubeTree frees to drain so no native delete runs against a half-torn-down runtime, disposes the step and identity storages, shuts the display engine down, and logs the licences out. Three separate events can reach AppEnd, and a static latch guarantees it runs at most once: IHostApplicationLifetime.ApplicationStopping — the ordinary graceful stop. AppDomain.CurrentDomain.ProcessExit — which still fires when a console window is closed outright. Console.CancelKeyPress — Ctrl+C and Ctrl+Break, which cancel the immediate termination and ask the lifetime for a graceful stop instead, so the first path runs. The cache-database path is Cache/{CacheDbId}.db beneath the admin directory. CacheDbId is the HiNC:CacheDbId configuration value when one is set and the hosting environment name otherwise. Supplying a path matters: SqliteStepStorage given none falls back to a single per-user file, so several instances on one account would otherwise share it. Two instances launched under different --environment names get different cache files with no further configuration. Startup Order Three registrations run before the builder exists, because each seeds a table that is read — or frozen — the moment anything else touches it: LocalProjectService.Reg() fills XFactory's default generator table with every type the simulation pipeline may deserialise, which is what every project XML read resolves against. UserConfig.Reg() adds the per-user preference file's own type to the same table; without it, a persisted preference file cannot be read back and every UserService resolution fails once one exists. Lang is appended to StringLocalizer's extended type list, so session-command titles resolve through that assembly's satellite resources. The type list is static, but each localizer builds its own resource-manager list lazily on its first lookup and keeps it, so a type added after a given localizer has been used never reaches that localizer. Registering before the builder exists is what puts the addition ahead of every first lookup. After the container is built and before the pipeline is assembled, the host wires the native core's log output into the application logger through CppLogUtil, sets the cache identifier, calls AppBegin, and then runs Seed(API) over the admin Resource root. The seeder copies in only the marked .default items, leaves unmarked items alone as user property, and skips the whole pass when its version stamp already matches the shipped resource assembly. Registered Services Every application service is registered as a singleton. The repository contains no AddScoped and no AddTransient call, so no service this host registers has a per-request lifetime and any state one of them holds is process-wide. Any shorter lifetime in the container is one of the framework's own registrations rather than an application service. Four registrations are worth reading closely: UserService is built by a factory rather than by type, so that its configuration path is assigned unconditionally — including when no preference file exists yet, which is the only way the first save can create one. When the file does exist, the factory deserialises it through XFactory. ProxyConfig is bound by hand into a plain singleton from the ProxyConfig configuration section. A separate services.Configure<ProxyConfig> call also registers it through the options system, but nothing resolves IOptions<ProxyConfig>; the plain singleton is what ProxyProjectService and the startup code receive. That binding happens once at startup and is not reloaded. ProxyProjectService is registered twice — once under its own type and once as IProjectService — so the container builds one instance per registration. Both hold nothing but the same two injected singletons, LocalProjectService and ProxyConfig, which is where all the state lives. AuthConfig is bound from the Auth section and registered as an instance, so the authentication controller and the pipeline decision below read the same object. See Login and Authentication for what it switches on. Six singletons are resolved eagerly at the end of BuildApp so they subscribe to their engine events at startup rather than when the first client happens to connect: the CL-strip broadcast service, the four per-sink message broadcast services, and the NC-program registry. Kestrel is configured with AllowSynchronousIO = true, which permits handlers to write to the response body synchronously. Controllers Controllers are added with AddControllers(), with the host's own assembly registered as an explicit application part, and reached by MapControllers() at the end of the pipeline. Every controller in the host assembly is attribute-routed, and every route template begins with api/ — most as api/[controller], the rest as an explicit kebab-case path such as api/mech/machine-tool or api/execution/cl-strip. No controller route sits outside api/, which is what makes the “everything else is the SPA” fallback rule below safe. One controller is exempt from the login gate: the authentication controller carries [AllowAnonymous] so it stays reachable when the fallback policy locks everything else. SignalR Hubs AddSignalR() is called without protocol configuration, and eight hub routes are mapped: Route Hub type What it carries /renderingHub RenderingHub server-rendered canvas frames and the input that drives them, one display engine per connection /shellMessageHub ShellMessageHub session-level routine and lifecycle messages /ncDiagnosticHub NcDiagnosticHub NC-pipeline diagnostics /stepDiagnosticHub StepDiagnosticHub step-anchored diagnostics /ncManipulationDiagnosticHub NcManipulationDiagnosticHub NC-manipulation diagnostics — writeback conversion and optimisation /executionStatusHub ExecutionStatusHub ExecutionStatusUpdated, SessionCursor and SessionStatusMessage, broadcast to all clients; the client-callable GetExecutionStatus() answers the caller alone, on the same ExecutionStatusUpdated name /clStripHub ClStripHub strip-chart display range, selected and entered step, and throttled data-update hints /cleanupHub CleanupHub index keys, and optional follow-up action keys, that a client registers against its connection with Add; the disconnect sweep finds none of them — see below The four message hubs share one base class and one contract — the client calls GetMessages(limit) and the server answers on MessagesUpdate — but they are deliberately separate routes rather than one hub with a discriminator, so a client subscribes to exactly the sink it wants and an idle panel means an idle hub rather than a lost connection. The cleanup hub is the one whose registry does not outlive the call that fills it. SignalR builds a fresh hub instance for every invocation, and the key dictionary Add writes to is an instance member rather than shared state, so the dictionary the disconnect handler walks is a different, empty one and releases nothing. Only IndexService — a singleton — is shared across those instances. The client does not depend on the hub for the release: useCleanupHub.ts keeps its own set of registered keys and posts each one to /api/Index/Remove before the component unmounts. That is the path that actually frees an entry. JSON Serialisation The controllers' serializer options carry two settings, both applied through AddJsonOptions. JsonNumberHandling.AllowNamedFloatingPointLiterals. Several engine values use double.PositiveInfinity as their “no limit” state — the optimizer's Max Feed Per Tooth and Preferred Force among them — and the snapshots the SPA reads carry those doubles straight into the response object. System.Text.Json refuses to write an infinite or NaN double as a JSON number, so without this setting every such response would fault during serialisation instead of returning. With it, those values travel as the JSON strings \"Infinity\", \"-Infinity\" and \"NaN\". The reading side is not uniform: the numeric input widgets take all three spellings case-insensitively, while the option-snapshot reader in the mission API recognises the two infinity spellings only and resolves anything else non-numeric — \"NaN\" included — to the fallback its caller passed, which is positive infinity for Max Feed Per Tooth and Preferred Force. Numeric Input/Output covers the client half of that boundary, and NC Optimization Option Panel (NC Optimization Config) the panel that leans hardest on it — including the two write endpoints that take a string body so the same spelling survives the round trip. JsonStringEnumConverter. Enums are read and written as their names rather than as integers, which is what the API wrappers expect and what keeps the OpenAPI schema self-describing. Both settings belong to the MVC controllers only. Hub payloads are serialised by SignalR's own protocol, which is left at its defaults, so neither the named floating-point literals nor the string enums extend to hub messages. The Request Pipeline The order the middleware is added in is load-bearing, and the host sets it explicitly rather than accepting the default arrangement: Forwarded headers first, honouring X-Forwarded-For and X-Forwarded-Proto so that every later stage sees the real client scheme. Both the known-proxy and the known-network lists are cleared, so those headers are accepted from any caller. Swagger — the Swashbuckle document and its UI, both middleware. MapOpenApi beside them registers the framework's own document as an endpoint instead, so that one is reached at step 8 with everything else that is routed. Default files, then static files, serving the built SPA and everything else physically present in the web root. UseRouting() — placed here on purpose. An application that never calls it gets routing inserted at the front of the pipeline instead, which would select the SPA fallback endpoint before the static-file middleware ran; that middleware stands down once an endpoint is chosen, so a directory URL under the web root would be answered by the Vue router's not-found view rather than by the directory's own default document. CORS, applying the AllowAll policy described below. HTTPS redirection, skipped in the Development environment. Authentication, then authorization. Both are no-ops when the login gate is off, because no scheme and no fallback policy are registered in that case. Endpoints — controllers, the eight hubs, and the two SPA fallbacks. A request answered before step 7 never reaches the authorization stage at all: the static-file middleware and the Swagger middleware both sit ahead of it and short-circuit the request when they match. The two SPA fallbacks are endpoints rather than middleware, so they do reach it, and both are marked AllowAnonymous — which is what lets the SPA shell, carrying no data of its own, load and show its own login view when the gate is on. The SPA Fallback Two fallback registrations serve index.html: util/file-explorer/{**location} — an explicit pattern with no file-name constraint. The bare fallback, for everything else. The bare form's implicit route pattern carries a nonfile constraint that rejects any URL whose last segment contains a dot. File Explorer deep links mirror real folder and file names into the URL, and those names routinely contain dots, so reloading or pasting such a location needs the explicit pattern. Genuine static assets cannot be shadowed by it, because the static-file middleware has already run by the time either fallback is reached. Serving the SPA The Quasar build writes its output directly into the host's web root — the front end's build configuration sets its distribution directory to the web service's wwwroot — so there is no copy step between building the SPA and serving it. The router runs in history mode, which is what makes the SPA fallback necessary: every client-side route is an extension-less URL the server has no endpoint for. The front-end build script runs the i18n census and glossary lint before invoking the Quasar build, so a build that fails those checks produces no new bundle. For front-end work the Quasar dev server runs on its own port and proxies the routes the backend owns to the running service. That proxy list holds /api, /swagger, /renderingHub, /executionStatusHub, /clStripHub, /cleanupHub, and /sessionMessageHub — a path the host maps no hub on. The four per-sink message hubs are absent from it, so the Session Messages panels receive no live messages through the dev server. OpenAPI and Swagger A single private constant holds the REST contract version. It is simultaneously the Swashbuckle document group name — so it appears in the document's route — and the version the UI displays, which is why it is defined in one place. It is raised by hand on a breaking REST change only, and is deliberately not tied to the assembly version or to the project-file format version. Both OpenAPI surfaces are exposed in every environment rather than behind a development gate, so an automated caller always has a machine-readable contract. The Swashbuckle UI is served at /swagger and its document at /swagger/{version}/swagger.json; the framework's own document is published under /openapi/. Schema ids are keyed on the full type name with the nested-type separator normalised. Without that, two controllers' nested request types that share a simple name collide and the document generator throws — which surfaces as an HTTP 500 from the document route rather than as a startup failure. XML documentation comments are folded in from the host assembly and from every referenced assembly whose name starts with Hi. Every read is skipped when its file is missing, and each referenced-assembly read carries a catch-all of its own on top of that, so one whose file is present but unreadable is ignored; the host assembly's read has no such catch-all. CORS One policy, named AllowAll, permits any origin, any method and any header, and it is applied globally. It does not allow credentials, so the response carries a wildcard origin and a cross-origin browser call cannot use the session cookie. The SPA is served from the same origin as the API and the hubs, so this constrains only callers hosted elsewhere. Logging The default providers are cleared and two are added: a console provider, and a daily file provider rooted at a logs folder beneath the process's current working directory. The file provider writes one line per entry to log-{yyyy-MM-dd}.txt and swallows every I/O failure, on the principle that logging must not fault a request or a startup. The two providers are filtered independently. The console follows the Logging:LogLevel section of configuration, which sets everything to Warning. The file provider carries its own code-set rules — Information for the application's own categories, Warning for Microsoft and System — and provider-specific rules take precedence over configuration's provider-neutral ones, so the file stays useful while the console stays quiet. Main writes one Information line immediately after the application is built, so the file for the day the service starts has content before the first request arrives. That guarantee stops at midnight: the provider recomposes the file name from the clock on every append, and creates nothing ahead of time, so a host left running into a new day has no file for it until the next entry is written. GET /api/project/logs reads the same directory. Configuration Configuration is the standard chain: appsettings.json, then appsettings.{Environment}.json, then environment variables, then command-line arguments. The keys this host reads are: Key What it controls Logging:LogLevel the console provider's levels AllowedHosts host filtering; shipped as a wildcard Kestrel:Endpoints the addresses the server binds ProxyConfig:AdminDirectory the admin working root, under which Resource and Cache live Auth the optional login gate HiNC:CacheDbId an explicit step-cache database id, overriding the environment name The Development overlay repeats the logging, admin-directory and authentication sections and declares no Kestrel section, so the listening address is the same under either environment. Kestrel Endpoints Win Kestrel:Endpoints is the authoritative source of the listening address. When it declares endpoints, Kestrel binds those and ignores addresses supplied any other way — ASPNETCORE_URLS, --urls, and the launch profile's applicationUrl alike — logging that it is overriding them. The shipped configuration declares one HTTP endpoint on loopback port 5000. The http launch profile names the same address, so the override is invisible there; the https profile also names an HTTPS address on a second port, and that address is one of the ones Kestrel discards, so launching under it still yields plain HTTP on 5000 and nothing else. To move a local instance to another port, set the Kestrel__Endpoints__Http__Url environment variable, which the environment-variable provider maps onto the same key. Setting ASPNETCORE_URLS alone changes nothing. The endpoint binds localhost, so the shipped configuration answers only on the machine it runs on. Reaching it from elsewhere means either overriding that key or placing a reverse proxy in front, which is the arrangement the forwarded-headers configuration handles. Environment and Working Directory The environment name reaches further here than usual. Both launch profiles set it to Development, which selects the Development overlay, skips HTTPS redirection, and — unless HiNC:CacheDbId overrides it — names the step-cache database file. Two paths follow the process's current working directory rather than the content root: the logs folder the file logger writes and the log endpoint reads, and the per-user preference file. An instance launched from the project directory finds both where they are expected; one launched from elsewhere puts them beside wherever it was started. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): Program.cs — the whole subject of this page: the pre-builder registrations, every service registration, the JSON and Swagger options, the CORS policy, the pipeline order, the eight MapHub calls, the two SPA fallbacks, the AppBegin / AppEnd pair and the three shutdown triggers. appsettings.json — the shipped listening address, the admin directory and the login section. appsettings.Development.json — the Development overlay, which declares no Kestrel section. Properties/launchSettings.json — the two launch profiles whose applicationUrl the Kestrel section overrides. Common/DailyFileLoggerProvider.cs — the per-day file logger the log endpoint reads back. Common/AuthConfig.cs — the shape bound from the Auth section. Common/AuthController.cs — the anonymous carve-out that keeps login reachable under the fallback policy. Common/NamedRootResolver.cs — resolves the admin, project and resource roots the seeder and the file endpoints work against. Common/CleanupHub.cs — the cleanup hub, and the per-invocation dictionary its disconnect handler walks. Common/IndexController.cs — the index remove endpoint the client calls before unmount. Disp/RenderingHub.cs — the canvas hub. Execution/SessionSinkHub.cs — the shared base and the four per-sink message hubs. Execution/ExecutionStatusHub.cs — the status, cursor and session-message hub. Execution/ClStripHub.cs — the strip-chart hub. Environments/UserConfig.cs — the preference type registered before the builder is created. Environments/ProjectController.cs — the log endpoints that read the daily file. wwwroot-src/src/composables/useCleanupHub.ts — the client's own key set and the index-remove calls that release it. wwwroot-src/src/api/mission.ts — the option-snapshot reader that maps the named-literal strings back to numbers, and the string-bodied setters that send them. wwwroot-src/quasar.config.ts — the build output directory that puts the bundle in the web root, the history router mode, and the dev-server proxy list. wwwroot-src/package.json — the build script that runs the i18n lint before the Quasar build. HiAPI Engine HiNc/HiNcKits/LocalApp.cs — AppBegin and AppEnd: licence log-in and log-out, display-engine start and finish, and the step-storage open and dispose. HiNc/HiNcKits/HiNcHost.cs — the cache-database identifier the host assigns at startup. HiNc/HiNcKits/ProxyConfig.cs — the admin-directory setting and its own default. HiNc/HiNcKits/ResourceSeeder.cs — the marked-defaults seeding pass and its version stamp. HiNc/SqliteUtils/SqliteStepStorage.cs — the step cache, and the per-user default path that makes an explicit per-instance path necessary. HiNc/MachiningProcs/ProxyProjectService.cs — the project service registered under two service types, holding only the singletons it is given. HiGeom/Common/StringLocalizer.cs — the static extended type list, and the per-instance resource-manager list each localizer builds on its own first lookup. See Also Session State — what survives a project change inside the singletons this host registers, and what is rebuilt Login and Authentication — the Auth section this host binds, and the cookie scheme and fallback policy it registers when the gate is on Rendering Canvas on Web Service Application — the canvas hub this host maps, and the per-connection display engine behind it"
  },
  "anatomy/platform/session-state.html": {
    "href": "anatomy/platform/session-state.html",
    "title": "Session State | HiAPI-C# 2025",
    "summary": "Session State Session state is what the web client still holds after the user moves from one screen to the next. It owns no route: the mechanism lives in the shell that wraps every route under / — a router outlet inside a <keep-alive> keyed on a project epoch — together with four Pinia stores, a family of module-level composables that deliberately sit outside the page lifecycle, and three browser storage keys. Every value in the client answers the same three questions: does it survive a navigation, does it survive a project change, and does it survive a browser reload. The Project Epoch MainLayout.vue renders the routed page inside a <keep-alive> whose :key is projectEpoch. That epoch is a plain integer ref declared in the layout component itself — it is not a store value, it is not provided to anything, and nothing outside the file reads it. Two watchers in the same file are the only writers, and each adds one to it: a watcher on the project store's projectPath, and a watcher on the project store's projectVersion. The key sits on the <keep-alive> element rather than on the page component inside it. Changing it therefore discards the cache itself along with every page instance held in it and builds a fresh one, which is why a page may rely on its own mount hook and never watch the project: both Control-Tree pages call their host's initialize() from onMounted, and that runs once per project rather than once per visit. The two inputs move for different reasons. projectPath is hydrated once at boot by the store's status fetch, assigned by New, Load and Save As from the response each returns, cleared outright by Close, and driven thereafter by a watcher inside the project store on the shared execution-status hub's status payload. A project change made in another tab, from a different browser, or outside the browser altogether therefore bumps the epoch here as well — and so, once, does the boot hydration on a service that already has a project open. projectVersion is a counter the store raises in exactly one place: ReLoad. The backend raises its project-changed event with the path it already had, so the broadcast cannot be told apart from a no-op; the client-side counter is what makes a reload remount. Save on the current path moves neither, so it does not remount. The epoch only counts up, and because it lives in the layout it starts again at zero on a browser reload — nothing reads its value, only its transitions. What a Navigation Costs The <keep-alive> carries no include, exclude or max, so every page reached under / is cached until the epoch changes. Leaving a route deactivates its component instead of unmounting it, and returning re-activates the same instance with its in-flight edits and its Control-Tree host intact. Scroll offsets are not part of that: the router's scrollBehavior resolves every navigation to the top of the page, and nothing saves an inner scroll position across a deactivation. The two routes declared outside the layout — the login screen and the not-found catch-all — are not cached at all. Three consequences the pages are written around: A cached page's watchers keep firing while another page is showing. The Control-Tree host compares the current route name against the one its scope owns before it writes the ?tree= query back, so an off-screen host cannot rewrite the visible page's URL. A global listener has to be dropped on deactivation, not on unmount. The Execution transport binds its F5–F8 shortcuts on mount and on activation and removes them on deactivation and unmount, so on any other page F5 falls back to the browser's own reload instead of starting the run. The Execution, General Setup and Tool House pages each track their own activation in a flag that feeds the rendering canvas's active prop. Such a page keeps its canvas mounted and its connection open while the backend engine stops rendering for it. The File Explorer page adds a route-leave guard that settles its editor buffer — flushing a pending auto-save, or prompting before discarding manual edits — and can refuse the navigation. The Stores Four Pinia stores are created against the single Pinia instance built at boot. None of them is inside the <keep-alive>, so a project change resets none of them; only a browser reload rebuilds them. project holds projectPath, projectVersion, the admin and project directories, a loading flag and the hasProject computed. Its actions post to the project endpoints and each throws a typed busy error on HTTP 409, which the backend returns when another project file operation is already running — the request is refused rather than queued. The store also owns the subscription to the shared execution-status hub and the watcher that adopts the path that hub broadcasts. appState holds the debug flag (initialised from whether the page is served from localhost), the physics-options and physics-licensed flags, the language code with the list of codes the server offers, and the Execution division-visibility record. loadServerPreferences, called from the layout's mount hook, hydrates those three groups in independently guarded steps, so a failing endpoint leaves the rest usable. A division-flag write is applied optimistically and rolled back on failure, with a monotonic sequence number so a late response cannot overwrite newer state. Its setMessage is a forwarder into the footer's foreground channel. auth holds whether the login gate is enabled, whether this session is authenticated, the user name, the version string the login screen shows, and a ready flag set once the first status probe resolves. Every transition re-drives the global hub gate described below. routineProgress backs the footer's two channels. The foreground channel keeps the latest entry plus a history capped at one hundred entries, which the footer's history button lists; the background channel is a single in-flight job with a message and an optional fraction and keeps no history at all, so it disappears when the job ends. A boot patch mirrors every Quasar toast into the foreground channel, so a toast stays reviewable after it fades. State Outside the Stores A second family of state lives at module scope in composables rather than in a store. The module is evaluated once per page load and its refs are created there, so every caller of the composable receives the same objects and nothing in a component's lifecycle creates or destroys them. Three of these hold project data and share one lifecycle idiom — useSpindleCapability, useSoftNcRunner and useToolHouse. Each exposes an idempotent ensureInstalled() that, on its first call only, opens a detached effect scope and watches hasProject: the state reloads when a project appears and is cleared when one closes. Every panel that reads the singleton calls ensureInstalled() in its own setup, and every call after the first does nothing. The consequence is the one that matters when reading a panel on screen: a mounted panel is not refreshed by a change made elsewhere. A project change unmounts and rebuilds every page, but it does not re-read a singleton — the installer is already installed, and the watch it installed is on a boolean that the load and new actions leave true. What each singleton holds is replaced only by an action on the composable itself, or by a consumer that asks for it explicitly: the Tool House page's mount hook calls the composable's reload(), while the spindle and controller panels call ensureInstalled() alone. The controller branch is the sharpest case. Its leaf panels fetch their own tables on mount and the tree builder re-fetches the runner snapshot it grows children from, but the shared snapshot the panels gate on — the brand, the chain axes, the per-group presence flags and the object key — is replaced only by a brand switch, an Object-Management install, or a close. The remaining module singletons carry no project data and exist to join components that are not in one another's tree: the Execution runtime flags the run page publishes for the nav bar, the sentence cursor shared by the Program file panel and the syntax view, the strip-chart group's reload tick and hovered x label, the two cycle-chart cursor marks the sim and sensor chart groups share, the parked cross-panel line jump, the transport's shared reset flag, and the shared-hub registry with its auth gate. Device-Local State Three localStorage keys hold state belonging to one browser profile on one machine. None of them is written into the project file and none is sent to the server. The tree-page view preferences key holds, per tree page, the column-visibility record and the two left-dock row states; and, shared across both pages, the dock pixel widths, the editor row height, the strip/step ratio, the two chart legend widths, the strip x-axis mode, the per-panel resize weights, the Control-Tree expansion list, the last selection per page, the two runner-suit checkboxes, and the three device-local panel switches for the 3D canvas, the CWE canvas and the sentence syntax view. Writes are debounced, and two earlier key names are read once as migration seeds when the current key is absent. The locale key is a paint-time hint only: the boot sequence applies it before mount so the first frame is already translated, then reconciles against the server value, which wins. The File Explorer key holds whether its editor pane is shown, the pane split, the auto-save switch and the sort order. What is not device-local is easy to mistake for it. The physics-options switch, the interface language and the Execution division-visibility flags live in the server's UserConfig, held by a singleton service and written to an XML file in the service's working directory. They are per install, not per browser: two browsers pointed at the same service read and write the same values. The machining project is server-side in the same way — one project is loaded at a time and every connected browser sees it, which is why the status-hub broadcast is what keeps a second tab honest. The URL carries the rest: the route, the ?tree= selection on the two Control-Tree pages, the browsed path on the File Explorer route, and the tab segments on the Tool House and Controller routes. Those come back on a reload from the address bar, and when a Control-Tree page is opened with no ?tree= the host lands on the stored last selection for that page, falling back to the page's root when the stored id is not in the current project's tree. What Navigation Project change Browser reload A page's own component state, including its Control-Tree host survives rebuilt rebuilt The four Pinia stores survives survives rebuilt Module-singleton composables survives survives rebuilt The localStorage preferences survives survives survives Route, ?tree=, browsed path and tab segments this is what changes survives survives Server preferences and the loaded project survives server-side survives SignalR Connections Most hubs are shared singletons built by one factory: the execution-status hub, the CL strip hub, and the four session-message sinks for shell, NC diagnostic, step diagnostic and NC-manipulation diagnostic messages. There is one connection per hub for the whole application, reference-counted by consumer. A component registers as a consumer when it calls the hub's composable and releases on its own unmount; when the count reaches zero the teardown waits out a short grace window, so the remount a project change forces — every consumer dropping and re-adding within the same render flush — keeps its connections rather than renegotiating them. The project store takes out a consumer registration on the execution-status hub when the store is created and never releases it itself, so that hub keeps a consumer no matter which page is showing. A global gate sits in front of all of them. While the optional login gate is enabled and the session is not authenticated — and while auth status is still resolving — hubs stay idle rather than negotiating into a 401. A logout or an intercepted 401 closes every connection; permitting again reconnects the ones a caller had asked for, without the caller asking twice. Reconnection is a dense burst of attempts, then a fixed cadence, then a slow tail that never gives up, and tab visibility or window focus starts a fresh burst immediately. Two kinds of connection are per instance rather than shared: Each rendering canvas opens its own connection to the rendering hub on mount and stops it on unmount. Because pages are cached, navigating away does not close one, and whether the backend engine stops drawing for it depends on the host. The Execution, General Setup and Tool House pages hand their activation flag to the canvas's active prop, which pauses the engine while the page sits off-screen; the Controller, Machine Tool and Mech Builder canvases and the File Explorer's STL preview bind no such prop, and the Execution page's CWE canvas pins it true, so all of those keep rendering until something unmounts them. Collapsing a panel does close one, unless that panel keeps its content mounted: the Execution page's 3D canvas panel does, so it survives a collapse, while the CWE panel beside it does not and its canvas connection goes with it. The cleanup hub is opened once per Control-Tree host and once each on the Controller and Tool House pages. Its composable also holds the set of IndexService keys that owner registered; on unmount it posts a removal for every one of them and then stops the connection, so a teardown releases the server-side objects the page had indexed even if the hub never connected. A shared connection therefore closes when its last consumer has been gone longer than the grace window, or when the auth gate shuts. A per-instance connection closes when the component owning it unmounts — which is what a project change does to every page at once, while the shared hubs ride that same remount out inside their grace window. Boot Order App.vue renders nothing but the router outlet and holds the wiring that must run exactly once per page load: subscribe the project hub, then fetch project status. Both sit behind a watcher on the auth predicate with a latch rather than behind a mount hook, because auth status may still be resolving at first paint. The router's own guard hydrates auth status before the first navigation and fails open, so a status hiccup cannot lock out an installation that has no login gate. The layout's mount hook then hydrates the server preferences. A successful sign-in navigates with a full page load rather than a router push, so the whole sequence runs again with the authentication cookie present. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/layouts/MainLayout.vue — the project epoch, its two watchers, the keyed <keep-alive> around the router outlet, the footer, and the server-preference hydration call. wwwroot-src/src/App.vue — the auth-gated one-shot wiring: the project hub subscription and the first status fetch. wwwroot-src/src/stores/index.ts — the Pinia instance the four stores are created against. wwwroot-src/src/stores/project.ts — the project path and version, the directories, the file actions and their busy error, the hub subscription, and the watcher that adopts the broadcast path. wwwroot-src/src/stores/appState.ts — the debug and physics flags, the language state, the Execution division config with its optimistic write and sequence guard, and the footer forwarder. wwwroot-src/src/stores/auth.ts — the login-gate state and the hub gate it drives. wwwroot-src/src/stores/routineProgress.ts — the footer's foreground history and its single live background job. wwwroot-src/src/composables/useViewPrefs.ts — the device-local view preferences: the shape, the defaults, the migration seeds and the debounced write. wwwroot-src/src/composables/useSoftNcRunner.ts — the controller singleton: the shared runner snapshot, the object key, and the install-once project watch. wwwroot-src/src/composables/useSpindleCapability.ts — the spindle singleton on the same lifecycle idiom. wwwroot-src/src/composables/useToolHouse.ts — the tool-house singleton and the coalesced reload the page calls on mount. wwwroot-src/src/composables/useSharedHub.ts — the shared-hub factory: consumer counting, the teardown grace window, the auth gate, the retry schedule and the focus recovery. wwwroot-src/src/composables/useExecutionStatusHub.ts — the status, cursor and message payloads the store and the footer read. wwwroot-src/src/composables/useClStripHub.ts — the strip snapshot and update counter the charts watch. wwwroot-src/src/composables/useSessionSinkHub.ts — the four message sinks and their notify-and-re-pull contract. wwwroot-src/src/composables/useCleanupHub.ts — the per-instance cleanup connection and the key set it releases on unmount. wwwroot-src/src/composables/useExecutionTransport.ts — the activation-scoped keyboard shortcuts and the shared reset flag. wwwroot-src/src/composables/useExecutionRuntime.ts — the runtime flags the run page publishes. wwwroot-src/src/composables/useSentenceCursor.ts — the shared source cursor and its install-once watch on step selection. wwwroot-src/src/composables/useStripChartGroup.ts — the group reload tick and the hovered x label. wwwroot-src/src/composables/useCycleSyncMark.ts — the per-group cycle-chart cursor mark the sim and sensor charts share. wwwroot-src/src/composables/useConversionJump.ts — the parked cross-panel jump. wwwroot-src/src/components/RenderingCanvas.vue — the per-instance rendering connection, its mount and unmount lifecycle, and the mounted guard that survives a mid-await teardown. wwwroot-src/src/components/panels/PanelExpansion.vue — the expansion row, and the keep-mounted flag that decides whether a collapse unmounts its content. wwwroot-src/src/components/AppFooter.vue — the two footer channels and the recent-message list. wwwroot-src/src/components/FileExplorer.vue — the explorer's own device-local preference key. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — the per-page host: the route-name guard on the ?tree= sync, the landing selection, and the cleanup registrations. wwwroot-src/src/pages/ExecutionPage.vue — the activation flag, the once-per-project initialization, and the panel that keeps the 3D canvas mounted through a collapse. wwwroot-src/src/pages/GeneralSetupPage.vue — the same lifecycle for the equipment host. wwwroot-src/src/pages/ToolHousePage.vue — the page that reloads its singleton explicitly on mount. wwwroot-src/src/pages/ControllerPage.vue, wwwroot-src/src/pages/MachineToolPage.vue, wwwroot-src/src/pages/MechBuilderPage.vue and wwwroot-src/src/components/StlPreviewPane.vue — the canvases mounted with no active binding. wwwroot-src/src/components/execution/StepVolumePanel.vue — the CWE canvas that pins active true and is stopped only by its own unmount. wwwroot-src/src/pages/FileExplorerPage.vue — the route-leave guard that settles the editor buffer. wwwroot-src/src/pages/LoginPage.vue — the full-page navigation after a successful sign-in. wwwroot-src/src/router/index.ts — the auth guard that hydrates status before the first navigation. wwwroot-src/src/router/routes.ts — which routes render inside the layout and which do not. wwwroot-src/src/boot/auth.ts — the fetch wrapper that turns a 401 into a logged-out store and a bounce to the login screen. wwwroot-src/src/boot/i18n.ts — the cached-locale fast path and the server reconcile. wwwroot-src/src/boot/routine-toast.ts — the toast mirror into the footer channel. wwwroot-src/src/i18n/index.ts — the locale storage key and the single place a locale change is applied. wwwroot-src/src/api/preference.ts — the typed wrappers over the preference endpoints the app-state store hydrates from. Environments/ProjectController.cs — the status, new, load, save, save-as, reload and close endpoints, and the conflict reply that becomes the client's busy error. Environments/PreferenceController.cs — the endpoints behind the server-held preferences. Environments/UserConfig.cs — the persisted user configuration: the physics switch, the language code, the graphic-cache limits, the step-present list and the Execution division config. Environments/UserService.cs — the singleton that owns that configuration and writes it to file. Execution/ExecutionStatusService.cs — the broadcast that carries a project change to every connected browser. Program.cs — where the user-configuration service is registered and its file path fixed. See Also Control Tree — the per-page host this epoch destroys and rebuilds, and the selection it restores from device-local storage Program and Hosting — how the SPA is served and hosted, and where the server-side singletons this page reads actually live Main Panel — the shell around the router outlet: the menu bar that fires the project actions and the footer that shows their outcome"
  },
  "anatomy/platform/tree-ids-and-routes.html": {
    "href": "anatomy/platform/tree-ids-and-routes.html",
    "title": "Tree Ids and Routes | HiAPI-C# 2025",
    "summary": "Tree Ids and Routes The web client addresses itself with two things: a vue-router path, and — on the two Control-Tree pages — a tree query argument naming the selected tree node, as in /general-setup?tree=equipment/fixture/geometry. This page is the reference for both surfaces: the route table, the redirect-only paths that keep older bookmarks resolving, the id-migration chain, and the resolver that decides which page owns a given ?tree= id. The router runs in HTML5 history mode, so every one of these paths is a real URL the server has to answer. Important Nothing here promises that a Control-Tree id is stable. The guarantee is narrower and exact: an id keeps resolving, because every regroup adds a migration hop to migrateLegacyTreeId rather than rewriting the previous one. The ids themselves have moved repeatedly, and a page that quotes one is quoting a value that can move again. The Route Table / is the shell-layout record itself; every route below it except the login and catch-all records is one of its children, so each renders inside the Main Panel's frame and menu bar. Path Route name What it owns / — The shell layout. It carries no page of its own; its empty child redirects to the Execution route. /execution execution The run cockpit and the Execution Control Tree, whose selection rides ?tree=execution/…. /general-setup general-setup The equipment Control Tree, whose selection rides ?tree=equipment/…. /machine-tool machine-tool The machining chain on a canvas of its own, beside a left column that shows either a read-only identity panel or the chain's XML source — two states of one column, chosen with a GUI/XML toggle. A load button installs a chain file into the project. Carries no Page-menu entry and is reached by URL. /controller/:tab? controller The superseded HardNcEnv controller surface. The optional segment mirrors the active tab. /tool-house/:toolId(\\d+)?/:tab?/:subtab? tool-house The tool library and the per-tool editor. The three optional segments carry the selected tool and the two nested tab levels. /preference/log preference-log The Log Viewer, reached from the menu bar's Show Log button. It is not under /util/. /util/file-explorer/:location(.*)* util-file-explorer The File Explorer. Its catch-all mirrors the browsed location — root display name followed by the relative segments — into the path. /util/mech-builder util-mech-builder The Mechanism Builder. /login login The sign-in form. It sits outside the shell layout and carries its own Quasar layout. /:catchAll(.*)* — The 404 page, likewise outside the shell layout: it prints the unmatched full path and offers one button back to the Execution route. The menu bar's Page dropdown holds every one of these that is menu-reachable, in setup order: Tool House, General Setup and Execution, then File Explorer and Mechanism Builder below a separator, then the legacy Controller below a second one. The Log Viewer has a button of its own rather than a menu entry, and /machine-tool has neither — it is reached by URL. The Tool House route's tool segment is constrained to digits, but all three of its segments are optional, so a non-numeric segment in the tool position is not rejected: the router skips the tool parameter and reads that segment as the tab, which is what makes /tool-house/cutter a working tab deep link with no tool named. The consequence is that the record absorbs three segments when the first is a number and only two when it is not, and a URL carrying more than the record can absorb — /tool-house/abc/def/ghi — falls through to the catch-all. An unrecognised tab name is not an error either: the page canonicalises it to that level's default, as The Tool House Translation sets out. Redirect-Only Paths These records carry no component. They exist so that a link minted before the corresponding editor moved into a Control Tree still lands on the editor. Path Lands on /spindle-capability/:tab? /general-setup?tree=equipment/spindle, with /<tab> appended when the segment is one of thermal, gear-shift, dry-run, power, torque. An unrecognised segment is dropped and the branch root is selected. /equipment/spindle /general-setup?tree=equipment/spindle /fixture/:rest(.*)* /general-setup?tree=equipment/fixture — any trailing path is discarded. /workpiece/:rest(.*)* /general-setup?tree=equipment/workpiece — any trailing path is discarded. /equipment/background-coolant /general-setup?tree=equipment/background. Background and Coolant are two separate tree nodes; the redirect picks Background. /mission /execution?tree=execution/mission The five spindle tab names are declared in treeRoutes.ts as SPINDLE_TABS, and imported by wwwroot-src/src/router/routes.ts — which is the list the redirect tests its :tab? segment against. The equipment tree does not import that constant: it spells the same five segments as literals while building the equipment/spindle/<seg> children, so redirect and branch agree by convention rather than through a shared list — renaming a spindle section is therefore an edit in two places. The Tool House name lists below are the other case, genuinely shared. The ?tree= Query Selection and URL are synced two ways by the Control-Tree host, one instance per tree page. URL to selection. A watcher on the query drives applyRouteSelection(), and it is registered immediate, so an id belonging to another page redirects on the first tick rather than after this page's first tree build. The host also calls the same function once the tree has actually been built, which is when a deep link can finally be honoured. Selection to URL. A watcher on the selected id replaces the tree argument, preserving the rest of the query. It uses router.replace, so browsing the tree does not fill the browser's history with one entry per node. The comparison that breaks the loop is made against the raw query rather than the migrated form, which is what makes an older id canonicalise: opening ?tree=controller selects the node and then rewrites the URL to ?tree=equipment/controller. Neither watcher touches the URL unless the current route name is the page's own. The shell layout keeps every visited page alive, so a host whose page is not showing keeps receiving route changes, and without the guard it would write another page's URL. The selection watcher does one thing before that guard: it records the id as this page's last selection. That ordering is load-bearing, because a selection can move while its page is off screen — unticking a CSV or CL Controller checkbox steps the equipment host off that node onto the equipment root, and the Preference menu that carries those checkboxes is open on every page — and the landing selection has to have followed it. That same checkbox flip is a third writer of the tree argument, and the one place the guard is absent. The equipment host watches both checkboxes, and when the standing selection is a node the flip removes, it replaces tree with equipment — the rest of the query preserved — before stepping the selection off. The route name is not consulted there, so the replacement goes to whichever route is showing. What applyRouteSelection Does The change is ignored unless this page owns the current route. The raw query is migrated into today's id. If its first segment names a different page and that segment is one of the known roots, the location is replaced with the route that owns it and the pass stops. An empty query falls back to the landing selection: the persisted last id for this page when that id exists in the tree just built, otherwise the page's root node — which is always present once the tree is built, so the editor column always has something to show. An id the built tree does not contain is ignored — the current selection stands and the URL keeps the unrecognised value until the next selection overwrites it. This is deliberate: the redirect in step 2 fires only for known roots, because sending an unroutable id back to the same page would loop. Otherwise every ancestor prefix of the id is added to the expanded set so the node is visible, and the selection is requested through the same gate a tree click uses. A panel holding unsaved edits may refuse the switch, and a refusal re-points the URL at the selection that actually stands. The Id the URL Names, Before the Tree Exists treePathOfRoute() — the raw query put through migrateLegacyTreeId — is not read only by the selection logic. The equipment tree consults it while it is being built, to decide whether to materialise the CSV Controller and CL Controller nodes: each is normally shown only when its Preference checkbox is ticked, and a URL naming one reveals it regardless. That reveal has to happen at build time precisely because step 4 above refuses an id the built tree lacks, so a bookmark to a switched-off node would otherwise dead-end. Only the URL reveals a node this way; the persisted last selection does not, so a node the user has just unticked while standing on it does not resurrect itself. Id Migration migrateLegacyTreeId is one pass of ordered guards over the whole id; the first that matches returns, and an id matching none is returned unchanged. An id shaped like Becomes controller, controller/… equipment/controller, equipment/controller/… spindle, spindle/… equipment/spindle, equipment/spindle/… mission, mission/… execution/mission, execution/mission/… equipment/mission, equipment/mission/… execution/mission, execution/mission/… any id ending in /contours/tray, or containing /contours/tray/ the same id with that segment spelled fluting The last rule renames one segment in place and leaves its children — baseline, flute-<i>, side, bottom — untouched, so a deep link into a flute contour survives the engine's Fluting type naming. The two mission rules cover the two id shapes separately rather than chaining, because the first matching guard returns. The function is applied at four points, which is what makes the guarantee hold in practice: to the raw ?tree= query, on every read; to the persisted last selection, before it is looked up in the tree; to the persisted list of expanded node ids, once when a host is constructed, so an older expansion set still unfolds the branches it names; as the first step of routeForTreeId, so the id-to-page resolver never sees an unmigrated id. Note what the first rule implies: a bare ?tree=controller selects the equipment/controller branch — the current controller editor on the General Setup page — and has nothing to do with the /controller route, which is the separate legacy HardNcEnv surface. Landing an Id on Its Page TREE_PAGE_ROOTS lists the first segments that name a page: execution, equipment and toolhouse. spindle is absent on purpose — migration folds it into equipment/… before any root check runs, so no root check ever sees it. routeForTreeId migrates the id, then dispatches on its first segment: toolhouse — the Tool House route, with the id's segments translated into path params (below). equipment — the General Setup route, carrying the migrated id as ?tree=. anything else — the Execution route, carrying the migrated id as ?tree=. This is a fall-through, not a test for execution, so an unrecognised id handed to this function lands on the Execution page. Reaching it with a genuinely unroutable id is prevented upstream: the host calls the function only for ids whose root is in TREE_PAGE_ROOTS. The returned location replaces the whole current location. Only the tree argument survives the hop; any other query argument on the URL being redirected away from is dropped, and the Tool House form carries no query at all. The Tool House Translation The Tool House page keeps its state in path segments rather than a query, so an id arriving from another page has to be translated. routeForTreeId walks the segments of toolhouse/tool-<n>/<tab>/<subtab>: segment two contributes toolId when it is tool- followed by an integer; segment three contributes tab when it is one of general, cutter, holder, clamping, intelligent; segment four contributes subtab when it is one of the cutter sections — material, profile, contours, upper-beam, opt — or one of the holder sections, geometry and resolution. Only the sub-tab step is nested inside the tab step: an unrecognised tab discards the sub-tab with it, whereas the tool step is tested on its own, so a second segment that is not tool-<n> costs the toolId param alone and the tab still translates. Everything deeper than the last segment the URL can carry is discarded either way — an id pointing at a single flute contour under …/cutter/contours/fluting/… lands on the nearest tab the URL can express. The same three name lists are imported by the page itself, so the tab set and the translation cannot drift apart. Once on the page, the tab segments are kept in step with the tabs by useRouteTabs, the composable the Controller route uses as well. It gives each tab level one route param, a valid-name set and a default; a nested level may declare which parent values make it apply, and while its parent is something else the level is dormant — its segment is dropped from the URL while its reference quietly remembers the last value, so returning to that parent tab returns to the sub-tab it had. The Tool House sub-tab level applies under cutter and holder only, and both its valid set and its default depend on which of the two is showing. A segment the level does not recognise resolves to that default rather than failing. Canonicalisation runs on the first mount and on every keep-alive re-entry, which is why a bare /controller becomes /controller/coordinate-table and a bare /tool-house acquires its tab segments. The tool segment is not one of the composable's levels: the page fills it in itself, adopting the URL's tool when the project holds it and the first tool in the list otherwise, then replacing the URL with what it adopted. That resolver reacts to the toolId param and to the tool list rather than to page activation, so it also re-points the URL when the list changes underneath it. The Tool House page never reads or writes ?tree=. A toolhouse/… id reaches it only by way of the redirect above, which is issued by one of the two tree pages' hosts. Reading an Id An id's first segment names the page that owns it, and therefore the folder that documents it: ?tree= root Route Documented under execution/… /execution Execution Page equipment/… /general-setup General Setup Page toolhouse/… /tool-house/… Tool House Page The remaining segments are the branch path, one segment per level of the tree, and the branch's own page sits in that folder — equipment/workpiece/material/cutting-parameter is the Cutting Parameter item of the Workpiece branch on the General Setup page. Most segments are kebab-case role names; the two list-backed branches, Mission entries and Program files, use a positional index instead. Every segment comes from the node id, never from the label the user reads: the General Setup page's root node is labelled General Setup and carries the id equipment. A label is a display string — the translation of the node's labelKey where it has one, and otherwise raw data such as an NC file name or a mission command's user-typed title, as Control Tree sets out — while an id is neither translated nor taken from data. Two consequences follow. A ?tree= link is locale-independent, and an id can never be read off what is on screen. Titles A route's meta.title holds an i18n key, such as routes.execution, not a title. The router resolves it through the active locale in an afterEach hook and sets the document title to the translated name followed by - HiNC; a route with no key — the catch-all — leaves the bare product name. The sibling name: is the route id used by every programmatic navigation and is never translated; the two must not be confused, which is why the route table above lists them side by side. The same resolver is handed to the i18n module through registerRetitle, so that switching language re-titles a parked tab without a navigation. The registration is indirect because the router already imports the i18n module for its translation function, and importing back would close a cycle. Serving These URLs History mode means the browser sends the whole path to the server on a refresh or a pasted link, so the back end maps two SPA fallbacks. The bare fallback carries an implicit constraint that rejects any URL whose last segment contains a dot, which is exactly the shape a File Explorer deep link takes, since those mirror real file names. An explicit fallback for the explorer's path is therefore mapped ahead of it with no such constraint. Static assets cannot be shadowed by either, because static-file serving runs earlier in the pipeline. Both fallbacks allow anonymous access, so the SPA itself always loads and the sign-in decision is made in the client. That decision is a navigation guard: it hydrates the authentication status once, lets every navigation through when the back end reports the feature disabled, and otherwise sends an unauthenticated visitor to the login route with the original full path — ?tree= included — parked in a redirect query. A successful sign-in replays that path as a full page load rather than a router navigation, so the application re-initialises with the cookie present. A visitor who is already signed in, or who arrives while the feature is off, is sent straight back out of the login route to the same parked path. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/router/routes.ts — the route table, the redirect-only records, the login route outside the shell layout, and the trailing catch-all. wwwroot-src/src/router/treeRoutes.ts — migrateLegacyTreeId, TREE_PAGE_ROOTS, routeForTreeId, the three tab-name lists it shares with the Tool House page, and SPINDLE_TABS, which only the spindle redirect reads. wwwroot-src/src/router/index.ts — the history-mode router factory, the authentication guard, and the retitle hook registered with the i18n module. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — the tree-page host: rawTreePathOfRoute, treePathOfRoute, the two selection/URL watchers and the unguarded controller-checkbox watcher beside them, landingSelection, applyRouteSelection and syncUrlBack, plus the build-time reveal of a URL-named CSV or CL controller node. wwwroot-src/src/composables/useRouteTabs.ts — the tab-to-param sync used by the Tool House and Controller routes, including dormant levels and the keep-alive re-entry canonicalisation. wwwroot-src/src/pages/ToolHousePage.vue — consumes the shared tab lists, resolves the tool from its path param, and navigates by route name when the tool changes. wwwroot-src/src/pages/FileExplorerPage.vue — mirrors the browsed location into the route's catch-all param and back. wwwroot-src/src/pages/MachineToolPage.vue — the component behind the URL-only machine-tool route. wwwroot-src/src/pages/NotFoundPage.vue — the catch-all component, carrying its own layout. wwwroot-src/src/pages/LoginPage.vue — reads the guard's redirect argument and replays it. wwwroot-src/src/composables/useViewPrefs.ts — the browser-local store holding the per-page last selected id and the expanded-node list that migration is applied to. wwwroot-src/src/components/AppMenuBar.vue — the menu entries that navigate by route name. wwwroot-src/src/i18n/en/routes.ts — the English strings the meta.title keys resolve to. wwwroot-src/src/i18n/index.ts — registerRetitle and the locale switch that calls it. wwwroot-src/quasar.config.ts — selects history mode and names the build output folder the server serves. Program.cs — the two SPA fallbacks, the explorer-specific one ahead of the bare one. See Also Control Tree — the tree these ids name: how a node id is formed and what a branch is made of Main Panel — the shell whose menus navigate to these routes and whose keep-alive cache makes the route-name guards necessary Execution Page — the busiest consumer of ?tree=, and the page a fall-through id lands on"
  },
  "anatomy/shell/bottom-message-bar.html": {
    "href": "anatomy/shell/bottom-message-bar.html",
    "title": "Bottom Message Bar | HiAPI-C# 2025",
    "summary": "Bottom Message Bar The Bottom Message Bar displays application-level notifications at the bottom of the Main Panel. This is the UI Error Notification channel — see Message Management for how it fits into the overall message architecture. Message Handling The Bottom Message Bar is connected to MessageBoardUtil (or ILogger with level-filtered treatment). When a notification is triggered: The Brief Message Text Field content is updated The message is appended to the daily log file at logs/log-{DateTime.Now:yyyy-MM-dd}.txt The second step belongs to the logging path rather than to the bar, and the footer does not share it. The footer is fed by the routine-progress store: what lands there is client-side, and it reaches the server's daily log only when the server logged it too — no part of the shell posts a message to the log-append endpoint. Message Types The MessageFlag determines the display behavior: Flag Display Behavior Exception Alert style, shown in Message Bar Warning and above Shown in Message Bar Info and below Logged only, not shown in Message Bar Note When the message is an Exception, the brief message shows Message while the full exception details are logged to file. Platform-Specific Layouts Web Application The web version docks a single dense bar along the bottom of the layout — AppFooter.vue, not a stack of toasts: Routine Progress Footer Bar Brief Message Text Field — the latest foreground message behind its severity glyph, reading Ready while there is none, with the full text and caption on hover Recent Messages Button — a history menu over the capped foreground list, with a clear action Session Status Strip — the live execution cursor and latest session message, rendering nothing at all until there is activity Background Progress Zone — one in-flight job's spinner or progress ring and its message, which disappears when the job ends Transient notifications are a second channel beside the bar rather than the bar itself: toasts are Quasar notifications, anchored bottom-right and auto-hiding on a timeout that does not vary with severity. A boot patch mirrors every one of them into the footer's foreground history, which is what keeps a toast reviewable after it fades. Show Log Button The Show Log button is the only entrance to the log screen. It is a router link in the menu bar's right-hand group — not on this bar — and it opens the Log Viewer as a full page inside the shell. See Log Viewer Page for that screen's toolbar, its auto-refresh interval, its copy and download actions and the states of its text area. See Also Main Panel — the window frame this bar is docked in Session Message Panel — the session-scoped message surface, as distinct from this app-level one"
  },
  "anatomy/shell/index.html": {
    "href": "anatomy/shell/index.html",
    "title": "App Shell | HiAPI-C# 2025",
    "summary": "App Shell The frame every route renders inside. MainLayout.vue is mounted once and stays mounted: the menu bar across the top, the notification bar along the bottom, and a router outlet between them that each page fills. Nothing here belongs to one screen, and nothing here disappears when the route changes. Ordered outward from the window frame: the panel that hosts every route, then the bars it docks, then the menus it drops. Pages Main Panel — The window itself: the menu bar, the router outlet, and the chrome that stays put while pages come and go Bottom Message Bar — The UI-notification channel docked at the bottom of the Main Panel, and how a message reaches it Session Message Panel — The four session message sinks and the tabbed panel that presents them; a runtime reset clears three of them and leaves the NC Manipulation sink standing Preference Menu — The Preference dropdown: the settings it carries, and where the web client keeps the ones it does not Language Selection SubMenu — The nested language picker, and when the chosen locale is applied See Also Conventions — the rules the shell applies, message handling first Widgets — the reusable controls the shell and every page embed"
  },
  "anatomy/shell/language-selection-submenu.html": {
    "href": "anatomy/shell/language-selection-submenu.html",
    "title": "Language Selection SubMenu | HiAPI-C# 2025",
    "summary": "Language Selection SubMenu The submenu locates on the Preference Menu Dropdown. It is the only place the application offers for changing the interface language. What that choice sets in motion — the message bundles, the locale applied before the first frame, the single switch function and everything that re-renders behind it — is Internationalization; this page covers the gesture. The submenu's model is the application-state store rather than a service handed down by the parent component: it reads the current code and the available-code list from that store and calls the store's language action. Both values are hydrated by the store's server-preferences load, which the shell layout runs on mount — a separate path from the one that decides which locale the first painted frame uses. Layout Language Selection SubMenu Language Row — one plain row per code in the store's available-code list, so the rows are whatever the server reports rather than a fixed set of three. Each carries the language's own name from a hard-coded label map, falling back to the raw code for anything the map does not name, with that code beneath it as a caption; the row matching the current language is drawn in the active state. No row carries a radio button or a checkbox. The parent entry captions the current language, so it reads without opening the submenu. Choosing a row closes the popup and makes one call, the store's language action. The store writes the new code optimistically, POSTs it, adopts the current and available lists the server echoes back, and only then switches the live catalogue — so the interface text flips after the server has accepted the value, and the confirmation toast already reads in the language just picked. A rejected write rolls the store back and changes no interface text at all. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/AppMenuBar.vue — the nested Preference → Language ▸ popup: the row loop over the available codes, the hard-coded self-name map, the active-row marker, and the handler whose single call is the store's language action. wwwroot-src/src/stores/appState.ts — the current-code and available-code state, the language action with its optimistic write, its POST-then-apply order and its rollback, and the server-preferences load the shell layout runs on mount. wwwroot-src/src/api/preference.ts — the typed wrappers over the two language endpoints. Environments/PreferenceController.cs — GET /api/preference/language and its POST twin, both answering success, current and available; languageCode is the name of a field in the POST request body only. An unlisted code is rejected with 400, and an accepted one is written to the persisted UserConfig.LanguageCode and saved. See Also Translation Remarks — the terminology every translated label is held to Preference Menu Dropdown — the dropdown this sub-menu hangs from Internationalization — the bundles and the switch point this menu drives"
  },
  "anatomy/shell/main-panel.html": {
    "href": "anatomy/shell/main-panel.html",
    "title": "Main Panel | HiAPI-C# 2025",
    "summary": "Main Panel The Main Panel is the primary window of the HiNC application, providing navigation and access to all major features. Key Models Project Service: injects ProxyProjectService, the IProjectService implementation that reaches the session's project across the connection User Service: UserService Layout Structure Top Navigation Menu Brand logo, and the HiAPI version as an outlined badge beside it. The badge carries the HiNc assembly version reported by the anonymous authentication-status probe the router runs before the first route resolves, so it needs neither a loaded project nor a signed-in session; it is omitted only while that probe has reported no version. Project Menu Dropdown Project Path Text Field — readonly; reads “No Project Loaded” until a project is loaded New MenuItem Load MenuItem ReLoad MenuItem Save MenuItem Save As MenuItem Close Project MenuItem (below a separator) ReLoad, Save, Save As and Close Project are disabled until a project is loaded, and New, Load and Save As open the shared file-picker dialog with a .hincproj filter. The picker is allowed the Admin and Project roots and is denied the Resource root, which holds read-only templates the project endpoints cannot save through; it asks for the Admin root by name, so that is where it opens, and it seeds its path box with the directory holding the loaded project, or with the admin root itself when there is none. The Project root is one of the two only while a project is loaded: the roots endpoint lists a root only when its directory resolves, and the project directory resolves to nothing until a project is open, so with no project the picker offers Admin alone. Page Menu Dropdown — the three workflow pages in setup order (fill the tool house, set up the equipment, run), then the utilities. Tool House MenuItem Open Tool House Page General Setup MenuItem The equipment Control Tree — Machine Tool, Spindle Capability, Background, Coolant, Fixture, Workpiece, Controller, in that order — plus the shared equipment canvas. Two further controller branches, CSV Controller and CL Controller, are hidden by default and are switched on from the Preference dropdown. Execution MenuItem Open Execution Page File Explorer MenuItem (below a separator). See Util Pages. Mechanism Builder MenuItem Open Mechanism Builder Page Legacy-Controller MenuItem (below a separator) Open Legacy Controller Page The dropdown is not every route the application has. The Machine Tool page stays reachable by URL for its chain-only canvas preview, the Log Viewer is reached by the Show Log button, and the Fixture, Workpiece, Spindle Capability, Mission and Background / Coolant paths resolve as redirects into the two tree pages. Preference Menu Dropdown Show Log Button — a button, not a menu item. It sits on the menu bar's right side and routes to the Log Viewer page. The Log Viewer presents the server's application log for the current day, with a manual refresh, a selectable auto-refresh interval, copy to the clipboard, and download of the day's log file for offline analysis. Central Page Panel — one router outlet wrapped in a keep-alive cache keyed on a project epoch: an integer the layout owns, raised by two watchers and read by nothing else. The first watches the project store's path, which New, Load and Save As each assign from the response they get back, which Close Project clears, and which a store-level watcher on the shared execution-status hub adopts from every broadcast — so a project change made in another tab, from another browser, or outside the browser altogether bumps the epoch here as well, and so does the boot status fetch, once, on a service that already has a project open. The second watches a counter the store raises in exactly one place, ReLoad, which is what makes a re-read of the same path remount at all: the backend raises its project-changed event with the path it already had, so the broadcast cannot be told apart from a no-op. Assigning the path it already holds moves neither watcher, so Save on the current path does not remount and neither does a Save As written back onto the path already open. A bump discards every cached page and rebuilds it, so each page initializes on its own mount hook rather than watching for project changes itself. Bottom footer — the routine-progress bar: the latest foreground message with a recent-messages history menu on the left, the live session status in the middle, and in-flight background job progress on the right. See Message Section on Main Panel. The menu bar carries no run tool bars at all: the transport controls ride the Execution Page‘s primary panel header and the view controls ride its canvas panel header. What the menu bar keeps instead is the page's set of column quick-toggles, the connection badge, the active page's title, the Show Log button and — when authentication is on — the logout button. The toggles follow whichever tree page is current: four on the Execution page (control dock, canvas, strip charts, step info) and three on General Setup (control dock, content, canvas); the Tool House page lays itself out with plain splitters and gets none. The connection badge is Execution-only — the other pages’ canvases carry their own in-panel badges. Project Menu Behavior The Project Path Text Field displays the current project path when a project is loaded. It is implemented as a pure text field (not a button) that allows users to select and copy the path. The Project Menu manages MachiningProject with the following operations: Operation Description Example New Creates a new project See DemoBuildGeomOnlyMachiningProject Load Opens an existing project See DemoUseMachiningProject ReLoad Re-reads the current project from disk, same path — Save Saves the current project See DemoBuildGeomOnlyMachiningProject Save As Saves the project to a new location See DemoBuildGeomOnlyMachiningProject Close Closes the current project and clears the shell — Every Project action reports through two channels: a background progress line on the footer while it runs, then a toast when it lands — positive on success, a “busy” warning when a concurrent action has already claimed the service (HTTP 409), negative otherwise. What a project change drives in the shell is the layout's keep-alive epoch, not a canvas view: every cached page is discarded and rebuilt. Note Project actions report through the toast helper and the routine-progress footer store, and none of them routes a message through MessageUtil. Project I/O is asynchronous, so the shell stays responsive during file I/O. Platform-Specific Differences Web Application The Execution Page is the landing route — / redirects to /execution The page URL and panel state are synchronized (bi-directional navigation) There is no Environment dropdown. Machine Tool, Fixture, Workpiece, Controller, Background / Coolant and Spindle Capability are branches of the General Setup page's Control Tree, and Tool House and Execution are pages of their own; the remaining paths resolve as redirects into those pages. The menu bar is therefore Project ▾ | Page ▾ | Preference ▾, and the Controller page is reached from Page ▾ as Legacy-Controller. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): Environments/PreferenceController.cs — the endpoints behind the Preference dropdown. Environments/ProjectController.cs — the project endpoints: status, new, load, save, reload, saveas and close, plus the log endpoints. Environments/UserService.cs — the shell's user model. wwwroot-src/src/components/AppMenuBar.vue — the whole navigation menu. wwwroot-src/src/components/AppFooter.vue — the routine-progress footer the layout docks. wwwroot-src/src/layouts/MainLayout.vue — the shell that hosts the menu bar, the keep-alive page panel and the footer. wwwroot-src/src/router/routes.ts — the routes the Page dropdown targets and the redirect-only legacy paths. wwwroot-src/src/i18n/en/menu.ts — the menu bar's English labels. wwwroot-src/src/stores/project.ts — the six Project actions and the busy error a 409 becomes. wwwroot-src/src/stores/routineProgress.ts — the foreground-message and background-progress store the Project handlers share with the footer. wwwroot-src/src/composables/useToast.ts — the toasts every Project action ends in. wwwroot-src/src/composables/useViewPrefs.ts — the device-local per-page column visibility and the CSV / CL controller switches. wwwroot-src/src/composables/useConnectionsHealth.ts — the aggregate state behind the Execution connection badge. wwwroot-src/src/components/widgets/FileExplorerDialog.vue — the shared picker New, Load and Save As open. wwwroot-src/src/components/widgets/ColumnToggleIcon.vue — the glyph each column quick-toggle draws. wwwroot-src/src/pages/LogViewerPage.vue — the Log Viewer the Show Log button opens. See Also Execution Page — the landing page the shell routes to Preference Menu Dropdown — the third menu on the bar Bottom Message Bar — the notification bar the shell docks along the bottom General Setup Page — the equipment page the Page menu reaches Tree Ids and Routes — the route table this bar navigates, and how a ?tree= id lands on the page that owns it Session State — the keep-alive this shell wraps the router view in, and what a project change destroys Login and Authentication — the gate in front of this shell, and the sign-out entry on this bar Log Viewer Page — the screen the Show Log button opens"
  },
  "anatomy/shell/preference-menu.html": {
    "href": "anatomy/shell/preference-menu.html",
    "title": "Preference Menu Dropdown | HiAPI-C# 2025",
    "summary": "Preference Menu Dropdown The Preference dropdown holds the application's display settings, and it is on the Main Panel. The server-backed ones are service-wide rather than per-account: one UserService singleton holds one UserConfig, saved to a single UserConfig.xml resolved against the process working directory, so every browser signed in to that service reads and writes the same values. The sign-in cookie carries a user-name claim that nothing outside the authentication endpoints reads, and no preference endpoint is keyed on an account. The dropdown has two models: Language and Show Physics Options bind the appState store, hydrated from and written back through /api/preference/*, where the server keeps them on UserConfig; the CSV / CL Controller checkboxes bind the device-local useViewPrefs singleton, persisted in the browser's localStorage and never sent to the server. Layout Preference Menu Dropdown Step Present Preference Button Web application: the editor belongs to the Execution page's Step Info column, where a small icon button in the Step Properties panel header opens it as a modal next to the list it configures. Graphic-Cache Dropdown Web application: an entry of the Execution page's extended tool bar, under Meshed Geom ▾, which gathers the workpiece rendering-cache settings. Its write is the one preference write that does not persist. POST /api/preference/graphic-cache clamps the requested size between the stored limits, assigns the three fields on the live UserConfig and returns, without calling UserService.SaveUserConfig(). The new value is service-wide and takes effect at once, but it reaches the file only when some later preference save writes the config out. Language Selection SubMenu The persisted value is UserConfig.LanguageCode; the web application reaches it through GET/POST /api/preference/language, whose response also names the language codes the server supports. In the web application the parent row captions the current language and the sub-menu marks the active code. A successful switch flips the interface text at once, so the confirmation toast already reads in the just-picked language. CSV Controller CheckBox Web application only. The model is useViewPrefs().showCsvController — device-local, stored in the browser's localStorage, not in UserConfig. It is off by default. Checking it adds the CSV Controller node to the General Setup page's Control Tree; unchecking removes it, moving the selection away first when that node is the selected one. The caption under the box says whether the loaded project plays CSV — This project plays CSV, or Not used by this project — read from the referenced flag of GET /api/mech/csv-runner. Opening the dropdown fetches both runner snapshots in parallel, but the fetch is guarded on a loaded project: with none, neither request is made and both captions are cleared to blank. A snapshot that fails to arrive leaves its caption blank as well, so a blank caption states nothing about the project. The guard reaches the captions only — neither checkbox is disabled by it. CL Controller CheckBox The same, for useViewPrefs().showClController, the CL Controller Control Tree node and GET /api/mech/cl-runner. Show Physics Options CheckBox The model is UserConfig.ShowPhysicsOptions, reached in the web application through GET/POST /api/preference/show-physics-options. The checkbox is disabled and unchecked if UserService.IsPhysicsLicensed is false: the GET returns the flag ANDed with the licence and the POST forces false without it. Show Log Button See Message Section. It is not a Preference-dropdown entry: it sits on the menu bar's right side as an always-visible button that opens the Log Viewer page. So the web application's Preference dropdown carries the Language submenu, the CSV Controller and CL Controller visibility checkboxes, and the Show Physics Options checkbox. A server write that fails raises a negative toast and rolls the item back in appState, so the dropdown never shows a language or a physics flag the server did not take. Source Code Path See HiNC App Anatomy for git repository links. wwwroot-src/src/components/AppMenuBar.vue — the Preference ▾ dropdown itself and the menu bar's Show Log button. wwwroot-src/src/stores/appState.ts — the model of the two server-backed items, with the boot-time hydration and the write-back actions. wwwroot-src/src/composables/useViewPrefs.ts — the device-local localStorage singleton behind the two controller checkboxes. wwwroot-src/src/api/preference.ts — typed wrapper over /api/preference/language and /api/preference/show-physics-options. wwwroot-src/src/api/csvRunner.ts, wwwroot-src/src/api/clRunner.ts — the referenced flag each controller caption reports. wwwroot-src/src/components/controlTree/useControlTreeHost.ts — builds or omits the two controller nodes and rebuilds the tree when either checkbox flips. wwwroot-src/src/i18n/en/menu.ts — the dropdown's labels and captions. wwwroot-src/src/pages/LogViewerPage.vue — the page the Show Log button routes to. Environments/PreferenceController.cs — the endpoints. The step-present, show-physics-options, language and execution-layout writes persist through UserService.SaveUserConfig(); the graphic-cache write is the exception, and returns without one. Environments/UserConfig.cs — the persisted LanguageCode and ShowPhysicsOptions properties. Environments/UserService.cs — owns the single UserConfig the service holds, writes it to UserConfigPath, and answers the physics licence check. Program.cs — the one UserService registration behind every server-backed item here, and the configuration path it resolves against the process working directory. See Also Main Panel — the menu bar this dropdown sits on Language Selection SubMenu — the only sub-menu this dropdown nests Graphic-Cache SubMenu — one of the two entries the web client hosts elsewhere Step Present Preference Page — the other entry the web client hosts elsewhere Log Viewer Page — the log screen this menu's namesake route serves Hidden Controller Branches — the two equipment nodes the CSV and CL entries reveal, and what a link to one does while its box is off"
  },
  "anatomy/shell/session-message-panel.html": {
    "href": "anatomy/shell/session-message-panel.html",
    "title": "Session Message Panel | HiAPI-C# 2025",
    "summary": "Session Message Panel Session messages are partitioned by kind into four sinks on LocalProjectService (obtained via dependency injection): ShellProgress — session-level routine / lifecycle messages (ShellProgress). Session-scoped: the property is null outside BeginSession/EndSession. NcDiagnosticProgress — play-time NC-pipeline diagnostics (NcDiagnosticProgress), anchored to the NC source block that raised them wherever the diagnostic has one. StepDiagnosticProgress — diagnostics anchored to a motion step (StepDiagnosticProgress). NcManipulationDiagnosticProgress — NC-manipulation diagnostics: a second NcDiagnosticProgress, written by ConvertClToNcFiles and OptimizeNcFiles, held apart from the play-time sink so writeback findings never mix into the play pipeline's. The panel surfaces each sink in its own tab, so one tab holds one message kind. ResetRuntime — which a project change runs — empties the first three, so each of them holds the current project only; the manipulation sink is outside that sweep, cleared only at the start of the conversion or optimization run that fills it, and its rows therefore survive a project change. Layout Tab Bar (each tab carries a floating count badge, drawn only while its sink holds messages) Shell Tab NC Diagnostics Tab Step Diagnostics Tab NC Manipulation Tab Per-Tab Content Filter Toolbar Severity Filter Dropdown Category Filter Dropdown Message Text Filter Input Reset Button (this tab's three filters, nothing else) Export Button Matched / Total Badge (also the tab's hub connection indicator) Message Table Message Table (per tab) Each tab renders its sink's message list — Messages, Messages, or Diagnostics for the two NC-diagnostic sinks — as rows of: Severity (colour-coded via GetSeverity()) Anchor — the kind-specific position: none for shell messages, the NC sentence ordinal (Sn <n>) for both the play-time and the manipulation NC diagnostics, and the motion step with its sentence ordinal (S<step> · Sn <n>) for step diagnostics; an NC diagnostic raised at pipeline level rather than at a source block carries none Message — GetCategory(), GetId() and GetNotification() Only take the last filtered elements (e.g. 500–1000) for user experience. Find the usage example in the code: internal static void DemoUseSessionMessageHost(LocalProjectService localProjectService) { // Session messages are partitioned by kind into three sinks on LocalProjectService: // - ShellProgress: session-level routine / lifecycle messages // (session-scoped: null outside BeginSession/EndSession). // - NcDiagnosticProgress: NC-pipeline diagnostics, anchored to the NC source sentence. // - StepDiagnosticProgress: diagnostics anchored to a motion step. ShellProgress shellProgress = localProjectService.ShellProgress; List<IMessage> shellMessages = shellProgress == null ? new List<IMessage>() : shellProgress.Messages.ToList(); foreach (IMessage message in shellMessages) Console.WriteLine( $\"Shell [{message.GetSeverity()}] {message.GetId()}: {message.GetNotification()}\"); foreach (NcDiagnostic diagnostic in localProjectService.NcDiagnosticProgress.Diagnostics.ToList()) { var ncLine = diagnostic.SentenceCarrier?.GetSentence()?.FirstIndexedFileLine; Console.WriteLine( $\"NC [{diagnostic.GetSeverity()}] {diagnostic.GetId()}: {diagnostic.GetNotification()}; \" + $\"File: {ncLine?.FilePath}; LineNo: {ncLine?.GetLineNo()}; NC: {ncLine?.Line}\"); } foreach (StepDiagnostic diagnostic in localProjectService.StepDiagnosticProgress.Messages.ToList()) Console.WriteLine( $\"Step {diagnostic.StepIndex} [{diagnostic.GetSeverity()}] \" + $\"{diagnostic.GetId()}: {diagnostic.GetNotification()}\"); File.WriteAllLines(\"output-session-messages.txt\", shellMessages.Select(m => $\"[{m.GetSeverity()}] {m.GetId()}: {m.GetNotification()}\")); } Add the update-table event per sink: MessageAdded / MessageAdded, and for the session-scoped shell sink the app-lifetime bridge OnShellMessageAdded (with the matching Cleared events). The updating process has to be called by Loose Manner for user experience. Note The message display should be real-time. Behavior of Export Button Every tab has its own Export, and it carries that tab's sink alone. It writes the rows the tab is holding — the recent window pulled from that sink, narrowed by that tab's severity, category and text filters — as a CSV of Index,Count,Severity,Category,Id,Anchor,Notification,Detail, named after the sink it came from. It is disabled while the filters match nothing. SignalR Implementation (Webapi Only) One hub per sink — /shellMessageHub, /ncDiagnosticHub, /stepDiagnosticHub, /ncManipulationDiagnosticHub — each with a GetMessages(int limit) pull returning MessagesUpdate { messages, totalCount }. A per-sink broadcast service subscribes its sink's MessageAdded/Cleared and raises a coalesced MessagesChanged notification via LooseRunner; the client re-pulls the recent window on each notification (loss-free regardless of how many appends coalesced). The client components connect to the hubs they display to receive real-time updates. Source Code Path See HiNC App Anatomy for git repository links. wwwroot-src/src/components/execution/SessionMessagePanel.vue (tabbed panel) wwwroot-src/src/components/execution/SessionMessageTab.vue + MessageRow.vue (per-tab list) wwwroot-src/src/composables/useSessionSinkHub.ts (the four hub composables) Execution/SessionSinkHub.cs (the SignalR hub base; one hub per sink) Execution/SessionSinkBroadcastService.cs + ShellMessageBroadcastService.cs, NcDiagnosticBroadcastService.cs, StepDiagnosticBroadcastService.cs, NcManipulationDiagnosticBroadcastService.cs (subscribe-and-rebroadcast) Execution/SessionSinkDtos.cs (typed DTOs) See Also Execution Page — the page whose main column hosts this panel Bottom Message Bar — the app-level notification bar, as distinct from these session sinks"
  },
  "anatomy/tool-house/cutter/apt-profile-panel.html": {
    "href": "anatomy/tool-house/cutter/apt-profile-panel.html",
    "title": "APT Profile Panel | HiAPI-C# 2025",
    "summary": "APT Profile Panel The main model is AptProfile and its property AptProfile.Apt. See Cutter Geometry. GeneralApt is the generalization of the other IAptBased types. These fields have no panel of their own: they are rendered inline by the Flute Profile section of the cutter, the Control-Tree node whose role path is toolhouse/tool-<id>/cutter/profile, reached at /tool-house/:toolId/cutter/profile under the page route /tool-house/:toolId?/:tab?/:subtab?. That same section carries the Profile Type selector above the fields. Layout Web Layout Flute Profile Section Profile Type Selection Dropdown General APT (GeneralApt) Ball APT (BallApt) Column APT (ColumnApt) Cone APT (ConeApt) Taper APT (TaperApt) First row, always present Diameter Input Field (mm) Length of Cut Input Field (mm) Type-dependent rows, one field per row, in this order Round Radius (Rc) Input Field (mm) Round Ring Radius (Rr) Input Field (mm) Round Ring Height (Rz) Input Field (mm) Bottom Cone Angle (Alpha) Input Field (deg) Top Cone Angle (Beta) Input Field (deg) Which of the five type-dependent fields appear is decided by a per-APT-type table held in the panel itself, not by testing the APT object's interfaces: Profile Type Fields shown General APT Rc, Rr, Rz, Alpha, Beta Ball APT none — Diameter and Length of Cut only Column APT Rc Cone APT Alpha Taper APT Rc, Rz, Alpha, Beta The interface casts live one layer down, on the read side: the cutter DTO builder fills rc_mm, rr_mm, rz_mm, alpha_deg and beta_deg by casting the APT to IAptRc, IAptRr, IAptRz, IAptAlpha and IAptBeta, and emits null for a cast that fails. Taper APT is where the panel's table and the engine's types disagree. TaperApt is declared over IAptBased, IAptRz, IAptAlpha and IAptBeta and carries no round radius, so the table's Rc entry gives a Taper profile a Round Radius box that the DTO fills with null — the field reads 0 — and the value the panel sends back is not read by the server's Taper branch, which builds the APT from Diameter, Rz, Alpha, Beta and Flute Height alone. Rc on a Taper APT is therefore inert in both directions. Features Every edit re-sends the whole profile. Changing the type, or any one field, builds a fresh shaper-profile request carrying the type, Diameter, Length of Cut and only those of Rc / Rr / Rz / Alpha / Beta that the chosen type's table lists, and the server replaces the cutter's AptProfile with a newly constructed APT of that type. The panel then clears the tool cache so the canvas redraws. Clearing a field is ignored. The shared numeric input emits null for an empty box, and the panel returns on null instead of committing, so a blanked box keeps the previous value rather than writing 0. Because the profile changes the flute geometry, the server does more than drop the cutter's cached solids: it also re-aligns the tool's holder-to-cutter anchor transformer, so the cutter is re-placed under the holder at its new height instead of rendering with a wrong exposed length. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/toolhouse/CutterSectionPanel.vue — the shipped home of these fields: the Profile Type selector, Diameter, Length of Cut, the per-type field table, and the whole-profile commit. wwwroot-src/src/components/controlTree/toolHouseItemTypes.ts — builds the profile section node this panel renders. wwwroot-src/src/router/treeRoutes.ts — maps that node's role path onto the page's :subtab param. wwwroot-src/src/components/widgets/NumericInput.vue — the numeric field behind every APT input: unit as a suffix, commit on blur or Enter, no G4. wwwroot-src/src/i18n/en/toolhouse.ts — the exact labels: \"Round Radius (Rc)\", \"Round Ring Radius (Rr)\", \"Round Ring Height (Rz)\", \"Bottom Cone Angle (Alpha)\", \"Top Cone Angle (Beta)\", “Diameter”, “Length of Cut”, and the five APT type names. wwwroot-src/src/api/toolHouse.ts — setShaperProfile and the shaper-profile DTO shape, which carries only the fields the selected APT type lists. Mech/CutterController.cs — the shaper-profile endpoint: it builds a ColumnApt, ConeApt, BallApt, TaperApt or GeneralApt from the DTO, assigns a new AptProfile, and runs the cache-clear and re-align hook. Mech/CutterDtoBuilder.cs — the read side that emits aptType, diameter_mm, fluteHeight_mm and the five interface-cast fields."
  },
  "anatomy/tool-house/cutter/cutter-panel.html": {
    "href": "anatomy/tool-house/cutter/cutter-panel.html",
    "title": "Cutter Panel | HiAPI-C# 2025",
    "summary": "Cutter Panel Overview The key component is ICutter. A tool carries at most one cutter, and two concrete types answer to that interface: MillingCutter and FreeformRemover. This panel is where the type is chosen, and it holds the cutter's own General fields. It is the Cutter tab of the Tool House Page, reached at /tool-house/:toolId/cutter under the page route /tool-house/:toolId?/:tab?/:subtab?. It is the panel of the Control-Tree Cutter node under the selected tool — the node whose role path is toolhouse/tool-<id>/cutter. Layout Web Layout Cutter Node Panel Title Label — Cutter Cutter Type Selector — Milling Cutter / Freeform Remover / None Milling Cutter branch, rendered only while the type is Milling Cutter Shank Mass Input Field (g) Hone Radius Input Field (um) Relief Angle Input Field (deg) Sections Hint Caption — points at the section tabs below Freeform Remover branch — one caption, toolhouse.cutter.freeformRemoverUnavailable, saying the editor is not available here No-cutter branch — one hint, toolhouse.cutter.noCutterHint, inviting the reader to pick Milling Cutter The three numeric fields are the cutter's General fields, and they sit here under the Metadata-on-container convention — a container's own General fields are edited on the container's panel instead of in a General child. They are plain, always-editable inputs: one label each, no label switching and no auto-computed mode, and all three commit together through the general endpoint, which accepts exactly shankMass_g, honeRadius_um and reliefAngle_deg. A blanked box commits nothing, so clearing a field never writes a zero. The type also decides what grows below the node. A Milling Cutter grows the cutter's section tabs — Material, Flute Profile, Flute Contours, Upper Beam, Optimization — as the nodes whose role paths end in .../cutter/material, .../cutter/profile, .../cutter/contours, .../cutter/upper-beam and .../cutter/opt; Material is the one gated behind the Advanced Physics preference. Selecting one replaces this panel with that section's own panel; see Milling Cutter Panel. A Freeform Remover or no cutter grows nothing, so the Cutter node is a leaf and the caption or hint is the whole surface; see Freeform Remover Panel. This panel carries no object management of its own. Object management for the tool library sits on the tool-house root node, where the Object Management Menu Button is bound to the whole .MachiningToolHouse file rather than to a per-cutter file. Features Committing a type is one server call plus a cache clear. Milling Cutter calls EnsureCutter, which keeps the tool's existing MillingCutter and only creates one when the tool has none; None calls ClearCutter, which drops the tool's cutter altogether. The panel then clears the tool cache, re-reads the tool and emits a structure change for its own node, which is how the section tabs appear or disappear with the type. Cache clearing is not a step the user performs. ICutter implements IClearCache, and every cutter endpoint that changes a field or a geometry clears the cache server-side before it answers: the field endpoints call ClearCache() on the milling cutter directly, while the ones that change flute or beam geometry go through the controller's resync hook, which clears the cache and re-aligns the tool's holder-to-cutter anchor transformer so the cutter is re-placed under the holder at its new height. On top of that the panels call clearToolCache(toolId), which clears the tool's cached solids and the holder's, so the tool canvas redraws. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/toolhouse/ToolCutterPanel.vue — the Cutter node's panel: the Milling Cutter / Freeform Remover / None selector, the Shank Mass / Hone Radius / Relief Angle fields, the Freeform Remover caption and the no-cutter hint. Commits a type change through ensureCutter or clearCutter followed by clearToolCache. wwwroot-src/src/components/controlTree/toolHouseItemTypes.ts — registers this panel as the ToolCutter item type; its cutter child builder grows the section tabs only for a MillingCutter, and gates Material on the Advanced Physics preference. wwwroot-src/src/components/controlTree/toolhouse/CutterSectionPanel.vue and wwwroot-src/src/components/controlTree/toolhouse/CutterContoursPanel.vue — the panels those section nodes render. wwwroot-src/src/components/controlTree/toolhouse/ToolHouseRootPanel.vue — the tool-house root panel, which carries the Object Management Menu Button for the .MachiningToolHouse file. wwwroot-src/src/components/widgets/ObjectManagementMenuButton.vue — the reused object-management dropdown that root panel mounts. wwwroot-src/src/components/widgets/NumericInput.vue — the shared numeric field behind the three General inputs; it commits on blur or Enter and reverts an unparseable entry. wwwroot-src/src/pages/ToolHousePage.vue — the routed page that hosts the tool list and the tab cascade this panel appears in; the route is /tool-house/:toolId?/:tab?/:subtab?. wwwroot-src/src/i18n/en/toolhouse.ts — the toolhouse.cutter.* strings this panel renders: cutterType, shankMass, honeRadius, reliefAngle, sectionsHint, freeformRemoverUnavailable, noCutterHint, millingCutter, freeformRemover. The None option's label comes from common.options.none in wwwroot-src/src/i18n/en/common.ts. wwwroot-src/src/api/toolHouse.ts — the typed wrapper: /api/ToolHouse for the house and the tool-level fields, /api/Cutter for every cutter mutation, plus ensureCutter, clearCutter, setGeneral and clearToolCache. Mech/CutterController.cs — the cutter backend at /api/Cutter: EnsureCutter / ClearCutter, the shaper-profile, fluting, general and opt-limit endpoints, the upper-beam endpoints and the material and coating-layer endpoints. Every field and geometry mutator clears the cutter cache before it answers. Mech/CutterDtoBuilder.cs — the single source of truth for the read-side cutter DTO (integralMode, general, shaperProfile, fluting, optLimit, material), shared by CutterController and the tool detail in ToolHouseController. Mech/ToolHouseController.cs — the tool detail that embeds that cutter DTO and that this panel reads on mount, plus the tool-cache clear the panel calls after every commit."
  },
  "anatomy/tool-house/cutter/freeform-remover-panel.html": {
    "href": "anatomy/tool-house/cutter/freeform-remover-panel.html",
    "title": "Freeform Remover Panel | HiAPI-C# 2025",
    "summary": "Freeform Remover Panel The key model is FreeformRemover: a cutter whose removal volume comes from two referenced geometries — a non-cutting strut and a cutting shaper — anchored to the holder buckle. This cutter is offered in the Cutter Type selector and nowhere else. There is no Freeform Remover editor here and no freeform-remover endpoint in the backend, so nothing on this surface can create or change one — the shipped caption says as much, naming the WPF client and HiNcRcl. Layout Web Layout Cutter Node Panel, the Cutter tab of the Tool House Page at /tool-house/:toolId/cutter — the Control-Tree node toolhouse/tool-<id>/cutter Cutter Type Selector — its second option, Freeform Remover, is this cutter Freeform Remover Caption (toolhouse.cutter.freeformRemoverUnavailable) — the panel's whole body while that option is showing Nothing else on this surface belongs to this cutter. The Shank Mass / Hone Radius / Relief Angle fields on that panel are gated to the Milling Cutter branch, and the cutter's child builder grows section tabs only for a MillingCutter, so the Cutter node is a leaf here: no Material, Flute Profile, Flute Contours, Upper Beam or Optimization section appears. See Cutter Panel for the panel these live on. Geometry Definitions Strut Geometry — The non-cutting portion (holder/shank) Used for collision detection Shaper Geometry — The cutting portion Defines cutting surfaces Used for material removal simulation Features Picking Freeform Remover is a no-op that does not stick. The panel makes no API call for that option — it sets the selector locally, clears the tool cache, then re-reads the tool, and the re-read is what puts the selector back to Milling Cutter or None. The model on the tool is left exactly as it was. A tool that already carries a freeform remover reads as None. The tool detail casts the tool's cutter to a MillingCutter and reports both hasCutter and the embedded cutter DTO from that one cast, so a non-milling cutter comes back as no cutter at all, and the selector — which derives its value from those two fields — shows None. The Freeform Remover option is therefore reachable by the user's click but never by a load. That makes one sequence worth knowing before using the web page on such a tool: picking Milling Cutter calls EnsureCutter, which returns the tool's existing cutter only when it is already a MillingCutter and otherwise assigns a new one — so on a tool holding a freeform remover, that choice replaces it. Leaving the selector alone leaves the freeform remover intact, which is what a round trip through the web page does by default. Cache clearing needs no user action: there is nothing to clear for this cutter, since no endpoint mutates it, and the tool-cache clear the selector performs only drops the tool's and the holder's cached solids so the canvas redraws. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/toolhouse/ToolCutterPanel.vue — the only web surface this cutter has: the selector option, the caption shown in its place, and the branch of the type handler that makes no call. wwwroot-src/src/components/controlTree/toolHouseItemTypes.ts — its cutter child builder grows sections only for a MillingCutter, so this cutter's Cutter node is a leaf. wwwroot-src/src/i18n/en/toolhouse.ts — toolhouse.cutter.freeformRemover, the option label, and toolhouse.cutter.freeformRemoverUnavailable, the caption; the zh-Hans and zh-Hant files carry the same keys. Mech/ToolHouseController.cs — the tool detail, which casts the cutter to a MillingCutter and reports hasCutter from that cast; this is why the selector cannot come back showing Freeform Remover. Mech/CutterController.cs — EnsureCutter / ClearCutter and every cutter mutation, all MillingCutter-only; the backend has no freeform-remover endpoint."
  },
  "anatomy/tool-house/cutter/index.html": {
    "href": "anatomy/tool-house/cutter/index.html",
    "title": "Cutter Tab | HiAPI-C# 2025",
    "summary": "Cutter Tab The Cutter tab of the Tool House page, reached as /tool-house/:toolId/cutter and, for its inner editors, /tool-house/:toolId/cutter/:subtab. The tab's own panel chooses the cutter type and holds the identity fields every cutter has; the type chosen decides which editor grows below it. Ordered with the tab's own panel first, then one page per cutter type, then the profile editor the types share. Pages Cutter Panel — The tab itself: the cutter type selector and the fields common to every cutter Milling Cutter Panel — The shipped cutter type: material, profile, flute contours, upper beam and optimization limits Freeform Remover Panel — The freeform removal volume, and where it is edited APT Profile Panel — The five APT profile types the shaper profile offers, shared by the cutter editors See Also Tool House Page — the page these tabs belong to Holder Tab — the sibling tab, and the other half of a tool Stick Tool Panel — the tool node whose tab cascade this tab belongs to"
  },
  "anatomy/tool-house/cutter/milling-cutter-panel.html": {
    "href": "anatomy/tool-house/cutter/milling-cutter-panel.html",
    "title": "Milling Cutter Panel | HiAPI-C# 2025",
    "summary": "Milling Cutter Panel The key model is MillingCutter, the one cutter type edited here in full. This cutter is not one panel but the section tabs the Cutter Panel grows once a Milling Cutter is assigned: the Control-Tree nodes under toolhouse/tool-<id>/cutter, reached at /tool-house/:toolId/cutter/:subtab under the page route /tool-house/:toolId?/:tab?/:subtab?. The five :subtab values are material, profile, contours, upper-beam and opt. The cutter's General fields — Shank Mass, Hone Radius, Relief Angle — are not among them: they sit on the Cutter node's own panel. Layout Web Layout Cutter Section Tabs, in this order Material Section — grows only while the Advanced Physics preference is on Flute Profile Section Flute Contours Section Upper Beam Section Optimization Section Material is the only physics-gated section. Flute Profile, Flute Contours, Upper Beam and Optimization grow for every Milling Cutter. The preference behind the gate is the SPA's Advanced Physics option, held as isShowPhysicsOptions in the app-state store and read from the server's preference endpoint, which reports it as on only while the physics feature is licensed. Integral mode is read-only. The cutter DTO reports it, and the Material section reads it to decide whether the Shank Material picker applies, but no endpoint sets it. Material Section Material Section (.../cutter/material) Flute Material Applies CutterMaterial Intro caption naming the .CutterMaterial extension Material File Selector Menu Dropdown — Browse Resource…, plus Clear once a file is picked Readonly path TextBox with the placeholder “No flute material selected” Name and note caption beneath the picker, the two joined on one line Shank Material, rendered only while the cutter's integral mode is Insert End Applies IStructureMaterial Intro caption naming the .xml structure material and the .CutterMaterial alternative Material File Selector, filtered to .xml — same Browse Resource… menu, with the placeholder “Default: AlloySteel42CrMo” Name and note caption beneath the picker Solid-End Note, shown in place of that block for a solid-end cutter — the shank material mirrors the flute material, so it has no separate setting Coating Layers Manages CoatingLayerList Add Layer Button One sequence hint above the whole list: the sequence starts from the surface, #0 is the outermost / air-exposing layer, and each layer is a .CoatingMaterial plus a thickness in um One row per ThermalLayer1D, all controls on that one line Index Badge #i Coating Material File Selector — Browse Resource…, placeholder “No coating material” Thickness Input Field (um) — Length_um Move Toward Surface Button, disabled on the first row Move Toward Body Button, disabled on the last row Delete Layer Button Empty state caption “No coating layers.” All three pickers are resource-only, which is what leaves the dropdown with a single browse entry: the absolute Browse item is hidden and only Browse Resource… remains. The picked material's name and note are rendered as a caption line under the picker rather than as a tooltip on a readonly name box. The mirroring for a solid-end cutter is enforced server-side: loading a flute material onto a solid-end cutter assigns the same material as the shank material, and unsetting it clears both. For an insert-end cutter, unsetting the shank material resets it to the built-in AlloySteel42CrMo rather than to nothing. Every coating endpoint answers with the whole cutter DTO, so the row list re-renders from the server's own ordering after an add, a move or a delete. Default Resource The default resources of Material live in the built-in Resource folder the server exposes as a named root of its own — not in the project folder. Each picker opens Browse Resource… into its own subfolder of that root: StructureMaterial — the Shank Material picker CutterMaterial — the Flute Material picker CoatingMaterial — the coating rows' pickers Flute Profile Section Flute Profile Section (.../cutter/profile) Profile Type Selection Dropdown General APT (GeneralApt) Ball APT (BallApt) Column APT (ColumnApt) Cone APT (ConeApt) Taper APT (TaperApt) The APT fields themselves, rendered inline in this same panel The five types are all wrapped by AptProfile, with a different Apt assigned; which fields appear depends on the type. See APT Profile Panel for the field list and the per-type table that drives it. See the DemoBuildMachiningProject sample in the Hi.Sample repository for creating the APT profile and setting it on the cutter. CustomSpinningProfile is not offered here; the five APT types are. Flute Contours Section This part manages Fluting. It is a stem, not a leaf: the section node carries only the type selector, and the fluting itself is a sub-tree of nodes below it. Flute Contours Section (.../cutter/contours) Title Label — Fluting Fluting Type Selection Dropdown Uniform (shared baseline) — UniformFluting Free (per-flute) — FreeFluting — unset — A caption describing the chosen kind, or “Fluting unset.” while none is set Fluting Node, grown only once a fluting is set — labelled Uniform Fluting or Free Fluting For a uniform fluting: Flute Number Input Field (minimum 1) For a free fluting: a “Flutes: n” caption and an Add Flute Button, with a “No flutes yet” hint while the list is empty Flute Contour Node(s) One Baseline Contour node (.../fluting/baseline) for a uniform fluting; one Flute n node (.../fluting/flute-{i}) per flute for a free fluting Setup Angle Input Field (deg) Delete This Flute Button — free fluting only Side Contour Sub-Node (.../baseline/side, .../flute-{i}/side) Kind Selector — Const Helix / Freeform / — unset — Const Helix Side Contour form: Helix Angle (deg), Radial Rake Angle (deg), Radial Relief Angle (deg) Freeform Side Contour form: the span-position table, ordered by Z Bottom Contour Sub-Node (.../baseline/bottom, .../flute-{i}/bottom) Kind Selector — Slide / Freeform / — unset — Slide Bottom Contour form: Outer Radius (mm), Cutter Length on Bottom Projection (mm), Eccentric Angle (deg), Disk Angle (deg), Axial Rake Angle (deg) Freeform Bottom Contour form: the span-position table, ordered by R Both freeform forms share one span-position table: four numeric columns — R (mm), A (deg), Z (mm), R.Ang (deg) — one row per 4D span position, with an insert-next button that clones the row and a double-click to remove it. The header wording mirrors the CSV field order the wire format uses, and the R.Ang column carries a tooltip explaining that the radial angle feeds the bottom-surface loft. A flute contour is always committed as a whole. Editing a Setup Angle, a side contour or a bottom contour re-sends the entire contour: a uniform fluting re-sends the fluting with its current flute number, and a free fluting updates the slot at its index. Free flute node ids are positional, so adding or deleting a flute rebuilds the branch to re-point them. Picking — unset — in the Fluting Type selector is inert — the panel returns without a call, because the backend exposes no way to null a fluting. Picking — unset — on a Side or Bottom Contour, in contrast, does commit: it clears that contour on the flute. Upper Beam Section The upper beam is the cutter's shank / body above the flute. Upper Beam Section (.../cutter/upper-beam) Intro caption Warnings Banner — one orange banner per geometry issue the backend reports, e.g. an ExtendedCylinder beam whose FullLength sits below the flute top Geometry Management Control, limited to the six IGetStl kinds an upper beam can be Cylindroid ExtendedCylinder TransformationGeom StlFile Box3d GeomCombination The banner is persistent rather than a transient toast: the same unreasonable settings fail thermal physics at run time as configuration errors, so they are surfaced at edit time. Creating a geometry here is container-aware — the server builds it, sets it as the cutter's upper-beam geometry, auto-links an ExtendedCylinder to the flute with a valid seed length, and indexes it under the same key so the per-kind editor edits it in place. Each later edit resyncs the cutter and refreshes the warning list. Optimization Section This part manages MillingCutterOptOption. Optimization Section (.../cutter/opt) Enable Optimization Checkbox Controls whether the limits below are shown and active When optimization is enabled: Limit by Theoretical Minimum Feed Per Tooth Checkbox Limit by Relief Angle Checkbox Min Feed Per Tooth Input Field (mm) Max Feed Per Tooth Input Field (mm) Yielding Utilization Factor Input Field The reciprocal of the Yielding Safety Factor the server stores; the panel converts in both directions Hint caption: typical values run 0.33 (conservative) to 1.0 (aggressive) Both checkboxes are plain labelled checkboxes — neither displays a computed value. The server's defaults when a limit set is written without them are a Yielding Safety Factor of 3 (a utilization factor of about 0.33), a Max Feed Per Tooth of 999, and both limit flags on. The minimum uncut chip thickness itself is not on this surface: no cutter endpoint returns it, and no field displays it. Features Every web edit is a whole-object commit followed by a cache clear. The Flute Profile panel re-sends the entire shaper profile on any field change — only the fields the selected APT type carries are included — then clears the tool cache. The contour panels re-send the whole flute contour. The optimization panel re-sends the whole limit set. The material and coating endpoints each answer with the full cutter DTO, which the panels re-render from. A blanked numeric box commits nothing. The shared numeric field emits null for an empty entry, and every cutter panel returns on null rather than writing a zero, so clearing a field leaves the stored value alone. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/toolHouseItemTypes.ts — the item-type registry and the child builders: the cutter's five sections, the Material physics gate, and the fluting / flute / side / bottom sub-tree. wwwroot-src/src/router/treeRoutes.ts — role-path to route translation; CUTTER_SECTIONS pins material, profile, contours, upper-beam and opt, and it also translates a …/contours/tray… id onto the fluting segment the node carries, so both spellings of the engine's Fluting type family resolve. wwwroot-src/src/components/controlTree/toolhouse/ToolCutterPanel.vue — the parent Cutter node: the type selector plus the cutter's General fields. wwwroot-src/src/components/controlTree/toolhouse/CutterSectionPanel.vue — the one panel shared by the material / profile / upper-beam / opt sections, keyed off the node's last role segment. It renders the Flute Profile fields inline and delegates the other three. wwwroot-src/src/components/toolhouse/MaterialDiv.vue — the Material section: flute material, the insert-end-only shank material, the solid-end note, and the coating list. wwwroot-src/src/components/toolhouse/CoatingLayersDiv.vue — the coating rows: index badge, material picker, thickness, move toward surface / body, delete. wwwroot-src/src/components/controlTree/toolhouse/CutterContoursPanel.vue — the Flute Contours stem: the Fluting Type selector. wwwroot-src/src/components/controlTree/toolhouse/FlutingPanel.vue — the concrete fluting node: Flute Number for uniform, the flute count and Add Flute for free. wwwroot-src/src/components/controlTree/toolhouse/FluteContourPanel.vue — one flute contour node: Setup Angle, and Delete This Flute for a free flute. wwwroot-src/src/components/controlTree/toolhouse/FluteSideContourPanel.vue and wwwroot-src/src/components/controlTree/toolhouse/FluteBottomContourPanel.vue — the two sub-nodes: kind selector plus the matching form. wwwroot-src/src/components/controlTree/toolhouse/fluteContourNode.ts — the shared load and commit logic behind those three panels, and the rule that a contour is committed whole. wwwroot-src/src/components/toolhouse/fluting/ConstHelixSideContourDiv.vue, wwwroot-src/src/components/toolhouse/fluting/SlideBottomContourDiv.vue, wwwroot-src/src/components/toolhouse/fluting/FreeformSideContourDiv.vue and wwwroot-src/src/components/toolhouse/fluting/FreeformBottomContourDiv.vue — the four contour parameter forms. wwwroot-src/src/components/toolhouse/fluting/SpanContourPosListDiv.vue — the R / A / Z / R.Ang span-position table both freeform forms share. wwwroot-src/src/components/toolhouse/UpperBeamDiv.vue — the Upper Beam section: the six allowed geometry kinds, the container-aware create, the resync-on-edit and the warnings banner. wwwroot-src/src/components/geom/GeometryEditor.vue — the shared geometry editor that section reuses. wwwroot-src/src/components/toolhouse/MillingCutterOptLimitDiv.vue — the Optimization section, including the Yielding Utilization Factor conversion. wwwroot-src/src/components/widgets/NumericInput.vue — the numeric field every cutter form uses: no G4, commit on blur or Enter, revert on an unparseable entry. wwwroot-src/src/components/widgets/FilePathInput.vue — the picker behind the material selectors; its resource-only mode hides the absolute Browse item and leaves Browse Resource…. wwwroot-src/src/stores/appState.ts — holds isShowPhysicsOptions, the Advanced Physics preference that gates the Material section. wwwroot-src/src/i18n/en/toolhouse.ts — every label quoted above: cutter.*, material.*, contour.*, fluting.*, upperBeam.* and opt.*. wwwroot-src/src/api/toolHouse.ts — the typed wrapper over /api/Cutter: shaper profile, fluting, the free-contour CRUD, the material and coating endpoints, the upper beam and the opt limit. Mech/CutterController.cs — the cutter backend: the APT construction from the profile DTO, the fluting builders, the opt-limit defaults, the solid-end shank-material mirroring, and the cache clear every field and geometry mutator performs. Mech/CutterDtoBuilder.cs — the read-side cutter DTO: integral mode, general, shaper profile, fluting, opt limit and material. Mech/ToolHouseController.cs — the tool detail that embeds that DTO, which every cutter section refreshes from. See Also Extended Cylinder Panel — the Upper Beam's kind that exists for this cutter, and the one surface that gives it a start section"
  },
  "anatomy/tool-house/holder/cylindroid-holder-panel.html": {
    "href": "anatomy/tool-house/holder/cylindroid-holder-panel.html",
    "title": "Cylindroid Holder Panel | HiAPI-C# 2025",
    "summary": "Cylindroid Holder Panel The key model is CylindroidHolder: a holder revolved from a Z-R profile, carrying its own name and note and its own STL tessellation resolution. The holder occupies two child sections of the Holder node under the selected tool — Geometry and Resolution, the nodes whose role paths end in .../holder/geometry and .../holder/resolution, reached at /tool-house/:toolId/holder/geometry and /tool-house/:toolId/holder/resolution. Its Name, readonly Abstract Note and Note are edited one level up, on the Holder Panel itself, under the Metadata-on-container convention. Layout Web Layout Geometry Section Cylindroid Panel — the reusable Z-R pair table, driven by a model key Initializing Caption — stands in for the editor until the holder's cylindroid has been published under a key Resolution Section Resolution Hint Caption — names the STL tessellation resolution used for display and collision meshing Linear Resolution (mm) Input Field Angle Resolution (deg) Input Field Feature The two web sections reach the model by different routes, and that difference is why the holder resync belongs to one of them and not the other. Geometry. The section mounts the reusable Cylindroid editor on a key. Get publishes the holder's own Cylindroid in the index service under a per-session -HolderCylindroid key and hands that key back — but only when the caller supplies its session key; with no session key the response carries a null key and the section shows its initializing caption in the editor's place. The key names the same object the holder holds, so an edit lands on the holder's geometry directly. Because that generic editor mutates the bare geometry and holds no reference back to the holder, the section issues the holder resync itself after each geometry edit: UpdateGeometryContent runs UpdateByCylindroid() and then ClearCache(), recomputing the holder topology before regenerating the solid — clearing the cache alone would skip the recompute. The slave column mounts only the selected node's panel, so at most one holder-geometry panel is alive at a time and the shared key never collides. Resolution. The section writes the polar resolution straight onto the holder: SetPolarResolution assigns a fresh PolarResolution2d built from the two values and calls ClearCache(), so the server regenerates the solid cache at the new tessellation. No topology resync is involved on this path. Get also returns the current pair, which is how the two fields are seeded; a null resolution on the model is reported as 0 mm / 0 deg. Guards sit on both sides. Every action on the controller answers Not Found for an unknown tool id and Bad Request when the tool's holder is not a CylindroidHolder; SetPolarResolution additionally rejects a linear or angle value that is not greater than zero, and the Resolution section refuses to send a non-positive value at all. Both fields commit on blur or Enter. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/toolhouse/HolderSectionPanel.vue — both sections in one panel, chosen by the last segment of the node's role path: the Cylindroid editor on the indexed key plus the resync on change, and the linear-mm / angle-deg fields with their positive-value guard. wwwroot-src/src/components/geom/CylindroidEditor.vue — the reusable Z-R profile editor the Geometry section wraps, driven by model key. wwwroot-src/src/components/controlTree/toolhouse/ToolHolderPanel.vue — the parent Holder node's panel, which hosts this holder's Name, readonly Abstract Note and Note and commits them through setCylindroidHolderName / setCylindroidHolderNote. wwwroot-src/src/components/controlTree/toolHouseItemTypes.ts — grows the two child sections for a CylindroidHolder and routes both to the HolderSection item type. wwwroot-src/src/api/cylindroidHolder.ts — the typed wrapper over /api/CylindroidHolder: getCylindroidHolder, updateCylindroidHolderGeometry, setCylindroidHolderName, setCylindroidHolderNote, setCylindroidHolderResolution. wwwroot-src/src/i18n/en/toolhouse.ts — the two section labels, the tessellation hint, the two field labels and the initializing caption. Mech/CylindroidHolderController.cs — GET Get (name / note / abstract note, the polar resolution, and — with a session key — the indexed cylindroid key) plus POST UpdateGeometryContent | SetName | SetNote | SetPolarResolution. See Also Polar Resolution 2D Panel — the resolution editor this panel embeds Cylindroid Control — the shape editor this panel's Geometry surface embeds, and the shape whose tessellation the Resolution surface governs"
  },
  "anatomy/tool-house/holder/freeform-holder-panel.html": {
    "href": "anatomy/tool-house/holder/freeform-holder-panel.html",
    "title": "Freeform Holder Panel | HiAPI-C# 2025",
    "summary": "Freeform Holder Panel The key model is FreeformHolder: a holder whose shape comes from a referenced geometry, typically an STL, positioned by two anchor transformers — one to the spindle, one to the cutter. The holder occupies four child sections of the Holder node under the selected tool — Geometry, Geom To Spindle, Geom To Cutter and Resolution, the nodes whose role paths end in .../holder/geometry, .../holder/geom-to-spindle, .../holder/geom-to-cutter and .../holder/resolution, reached at /tool-house/:toolId/holder/:subtab. Its Name, readonly Abstract Note and Note are edited one level up, on the Holder Panel itself, under the Metadata-on-container convention. The three shape sections are not holder-specific editors. They are the same generic Geometry and Transformer slots the Fixture branch of the General Setup page is built from: a kind picker on the section node, and the chosen kind's own editor on the child node below it. So an STL holder is picked as StlFile and its source file set through the shared StlFile editor, a TransformationGeom holder grows Inner Geometry and Inner Transformer nodes, a GeomCombination holder grows one node per item, and each placement grows the chosen transformer kind's editor — Static Translation for the usual (0, 0, h) offset. Layout Web Layout Geometry Section Geometry Type Selector — None / Box3d / Cylindroid / StlFile / TransformationGeom / GeomCombination The chosen kind's editor, on the child node the kind grows Geom To Spindle Section — where the holder sits relative to the spindle Transformer Type Selector — Static Translation / Static Rotation / Static Freeform / Dynamic Translation / Dynamic Rotation / General Transform / No Transform The chosen kind's editor, on the child node the kind grows Geom To Cutter Section — where the cutter sits relative to the holder Transformer Type Selector and the chosen kind's editor, as above Resolution Section Resolution Hint Caption — names the STL tessellation resolution used for display and collision meshing Linear Resolution (mm) Input Field Angle Resolution (deg) Input Field Feature The generic editors reach the holder's own members, and that is what makes the split work. When the Holder node's children are built, the page calls FreeformHolderController's Get with its session key; the server publishes the holder's Geom, GeomToSpindleTransformer and GeomToCutterTransformer in the index service under three per-session keys (-HolderGeom, -HolderGeomToSpindle, -HolderGeomToCutter) and hands the keys back. The keys name the very objects the holder holds, so an edit through a kind editor lands on the holder directly. The keys are returned even when a member is empty — nothing is published then, the section's picker reads an empty slot, and picking a kind fills that same key — which is how a freshly switched-to Freeform holder, whose geometry starts empty, gets its first shape. Picking a kind is a container-aware create, not a bare New. The Geometry picker calls CreateGeometry, which builds the geometry, sets it as the holder's Geom and publishes it under the section's key (None clears the geometry). A placement picker first creates the transformer through the kind's own New endpoint and then attaches it with UpdateGeomToSpindleTransformer or UpdateGeomToCutterTransformer. Without the attach, only the index-service entry would change and the holder would keep pointing at its old transformer. Because the generic editors hold no reference back to the holder, every edit at or below a section ends in the holder resync the page wires onto the section: a geometry edit calls UpdateGeometryContent, a placement edit re-attaches the transformer under its key. Both run UpdateByGeom() to regenerate the solid, ClearCache(), and AlignAnchorByExposedCutterHeight() to re-place the cutter under the holder — clearing the cache alone would leave the cutter where it was. The page then refreshes the tool list and the canvas. The Resolution section writes the polar resolution straight onto the holder: SetPolarResolution assigns a fresh PolarResolution2d and the holder swaps its solid for one born with the new value, keeping the geometry. Get also returns the current pair, which is how the two fields are seeded. Guards sit on both sides. Every action on the controller answers Not Found for an unknown tool id and Bad Request when the tool's holder is not a FreeformHolder; SetPolarResolution rejects a linear or angle value that is not greater than zero, and the Resolution section refuses to send one. Fields commit on blur or Enter. Switching a tool to Freeform is a committing choice. SetHolderType assigns a new FreeformHolder only when the tool does not already carry one, so a holder authored elsewhere — through HiNcRcl, say — survives a round trip through this page with its geometry, anchors and resolution intact. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/toolHouseItemTypes.ts — grows the four child sections for a FreeformHolder: reads Get to publish the three members, binds the Geometry section to the generic Geometry item type and the two placements to the generic Transformer item type (with the create hooks and the resync chain), and routes Resolution to the HolderSection item type. wwwroot-src/src/components/controlTree/GeometrySlotPanel.vue / TransformerSlotPanel.vue — the kind pickers on the three shape sections; the chosen kind's editor lives on the child node (wwwroot-src/src/components/geom/geometryEditors.ts, wwwroot-src/src/components/topo/transformerEditors.ts). wwwroot-src/src/components/controlTree/toolhouse/HolderSectionPanel.vue — the Resolution section, dispatching on the holder type to FreeformHolderController for a Freeform holder. wwwroot-src/src/components/controlTree/toolhouse/ToolHolderPanel.vue — the parent Holder node's panel, which hosts this holder's Name, readonly Abstract Note and Note and commits them through setFreeformHolderName / setFreeformHolderNote. wwwroot-src/src/api/freeformHolder.ts — the typed wrapper over /api/FreeformHolder: getFreeformHolder, createFreeformHolderGeometry, updateFreeformHolderGeometry, resyncFreeformHolder, updateFreeformHolderGeomToSpindle, updateFreeformHolderGeomToCutter, setFreeformHolderName, setFreeformHolderNote, setFreeformHolderResolution. wwwroot-src/src/i18n/en/toolhouse.ts — the two placement section labels (toolhouse.node.geomToSpindle / geomToCutter) and the Freeform sections hint; the zh-Hans and zh-Hant files carry the same keys. Mech/FreeformHolderController.cs — GET Get (name / note / abstract note, the polar resolution, and — with a session key — the three member keys) plus POST CreateGeometry | UpdateGeometry | IndexCurrentGeometry | UpdateGeometryContent | UpdateGeomToSpindleTransformer | UpdateGeomToCutterTransformer | SetName | SetNote | SetPolarResolution. See Also Polar Resolution 2D Panel — the resolution editor this panel embeds Fixture Page — the other user of the generic Geometry and Transformer slots this holder's shape sections are made of"
  },
  "anatomy/tool-house/holder/holder-panel.html": {
    "href": "anatomy/tool-house/holder/holder-panel.html",
    "title": "Holder Panel | HiAPI-C# 2025",
    "summary": "Holder Panel This section describes the user interface and behavior for managing different types of tool holders in the application. Tool holders are crucial components in defining a complete tool assembly. Note While tool holders are essential components in real-world machining operations, some users may choose not to define them in simulation environments for convenience, particularly when collision detection is not a primary concern. The system allows for this flexibility, though it's recommended to include holders for accurate representation and comprehensive collision analysis. The primary models involved are subclasses of IHolder. Two common types are: Cylindroid Holder: Represents holders with a cylindrical geometry. See CylindroidHolder. Freeform Holder: Represents holders with more complex, freeform geometry, often defined by STL files. See FreeformHolder. Each holder type has its own user interface elements for defining its geometry and properties. This panel is the Holder tab of the Tool House Page, reached at /tool-house/:toolId/holder. It is the panel of the Control-Tree Holder node under the selected tool — the node whose role path ends in .../holder. Layout Web Layout Holder Node Panel Title Label Holder Type Selector — None / Cylindroid Holder / Freeform Holder Holder branch, rendered while the type is Cylindroid or Freeform Name TextField (editable) Abstract Note TextField (readonly, derived by the model) Note TextField (editable) Sections Hint Caption — names the sections below for the current type No-holder branch — one hint, toolhouse.holder.noHolderHint, inviting the reader to pick Cylindroid Holder or Freeform Holder The three identity fields belong to whichever holder the tool carries. They sit on this panel under the Metadata-on-container convention — a container's own General fields are edited on the container's panel instead of in a General child — and they commit through the per-type holder controller's SetName and SetNote (CylindroidHolderController or FreeformHolderController), not through ToolHouseController. No holder leaves the panel without them. The type also decides what grows below the node. A Cylindroid holder grows two child sections, Geometry and Resolution — the nodes whose role paths end in .../holder/geometry and .../holder/resolution; see Cylindroid Holder Panel. A Freeform holder grows four — Geometry, Geom To Spindle, Geom To Cutter and Resolution; see Freeform Holder Panel. Selecting a section replaces this panel in the slave column with that section's own panel. None grows no children, so the Holder node is a leaf and the hint is the whole surface. This panel carries no object management of its own. Object management for the tool library sits on the tool-house root node, where the Object Management Menu Button is bound to the whole .MachiningToolHouse file rather than to a per-holder file. Feature Committing a type is one server call plus a cache clear. SetHolderType maps the selector value onto the holder classes: none clears the tool's holder, while cylindroid and freeform each assign a new holder only when the tool does not already carry one of that class — so re-picking the type a tool already has keeps the holder it has, and the edits on it, rather than replacing it. When the caller passes its session key the server re-indexes the resulting holder under that session's holder key, and removes that entry for None, so the session key keeps pointing at the tool's current holder. The response carries the holder's class name and its abstract note. The panel then calls ClearToolCache, which clears the tool's cached solids and, when the holder implements IClearCache, the holder's own cache as well, so the tool canvas redraws against the new holder. Finally it emits a structure change for its own node, which is how the Geometry and Resolution sections appear or disappear with the type. GetHolder reports the same pair — class name and abstract note — and is what the panel reads on mount to seed the selector; an unknown tool id answers Not Found. The panel then reads the per-type controller's Get (CylindroidHolderController or FreeformHolderController) to fill the three identity fields; for a Freeform holder that same call also publishes the holder's geometry and two placements under the session's keys for the sections below. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/controlTree/toolhouse/ToolHolderPanel.vue — the Holder node's panel: the None / Cylindroid / Freeform selector, the holder's Name / readonly Abstract Note / Note (committed through the per-type controller) and the no-holder hint. Commits a type change through setHolderType followed by clearToolCache. wwwroot-src/src/components/controlTree/toolHouseItemTypes.ts — registers this panel as the ToolHolder item type; its holder child builder grows Geometry and Resolution for a CylindroidHolder, Geometry / Geom To Spindle / Geom To Cutter / Resolution for a FreeformHolder, and nothing for None. wwwroot-src/src/components/controlTree/toolhouse/HolderSectionPanel.vue — the panel behind the Cylindroid holder's two sections and both holders' Resolution section, dispatching on the last segment of the node's role path and on the holder type. wwwroot-src/src/components/controlTree/toolhouse/ToolHouseRootPanel.vue — the tool-house root panel, which carries the Object Management Menu Button for the .MachiningToolHouse file. wwwroot-src/src/api/toolHouse.ts — getHolder, setHolderType and clearToolCache, plus the HolderType union (None / CylindroidHolder / FreeformHolder) the selector's three values map onto. wwwroot-src/src/api/cylindroidHolder.ts / wwwroot-src/src/api/freeformHolder.ts — get…Holder, set…HolderName and set…HolderNote for each holder type, behind the three identity fields. wwwroot-src/src/i18n/en/toolhouse.ts — the toolhouse.holder.* strings this panel renders: holderType, abstractNote, sectionsHint, freeformSectionsHint, noHolderHint, cylindroidHolder, freeformHolder. Mech/ToolHouseController.cs — POST SetHolderType, GET GetHolder and POST ClearToolCache, the three endpoints behind the selector. Per-holder-type editing lives in the dedicated holder controllers."
  },
  "anatomy/tool-house/holder/index.html": {
    "href": "anatomy/tool-house/holder/index.html",
    "title": "Holder Tab | HiAPI-C# 2025",
    "summary": "Holder Tab The Holder tab of the Tool House page, reached as /tool-house/:toolId/holder and, for its inner editors, /tool-house/:toolId/holder/:subtab. The tab's own panel chooses the holder type; the type chosen decides which editor grows below it, and each type carries its own geometry and resolution. Ordered with the tab's own panel first, then one page per holder type. Pages Holder Panel — The tab itself: the holder type selector and the fields common to every holder Cylindroid Holder Panel — The revolved Z-R profile holder, its geometry and its polar resolution Freeform Holder Panel — The freeform holder, and where its geometry is edited See Also Tool House Page — the page these tabs belong to Cutter Tab — the sibling tab, and the other half of a tool Stick Tool Panel — the tool node whose tab cascade this tab belongs to"
  },
  "anatomy/tool-house/index.html": {
    "href": "anatomy/tool-house/index.html",
    "title": "Tool House Page | HiAPI-C# 2025",
    "summary": "Tool House Page The Tool House is a page of its own at /tool-house/:toolId?/:tab?/:subtab?, reached from the menu bar's Page ▾ dropdown. The key model is MachiningToolHouse. The model UserService is the server-side Environments/UserService.cs, which Mech/ToolHouseDisplayController.cs reads EnablePhysics from. Layout Three columns, left to right, in two nested resizable splitters — the tool house and its tool list, the selected tool's editor tabs, and the tool canvas. Creating a tool opens no window of its own: New Tool adds a default tool and the user sets it up in the editor tabs. Tool House Page Tool List Column Tool House Root Panel Object Management Menu Button file extension is .MachiningToolHouse, load type Hi.Machining.MachiningToolHouse, HiMech The managed object is the whole tool house, not one tool New Tool Button (disabled until the project has a tool house) Ready / No-Project Badge Tool-count caption with the pick hint — replaced, while the project has no tool house, by an empty-state block naming New Tool and the Object Management button's .MachiningToolHouse extension Tool List one router-link row per tool: the Tool ID badge, then the tool's note — or the auto abstract note as an italic caption when the note is empty Selected Tool Editor Column Stick Tool Panel — the tool's five tabs: General, Cutter, Holder, Clamping, Int. Holder Viewer Column Viewer ToolBar RenderingCanvas Tool Bar Display Options Menu Dropdown — three flat groups, no submenus Head Label: Cutter Show Cutter CheckBox Head Label: Holder Show Holder CheckBox Show Geometry Anchor CheckBox Show Spindle Buckle CheckBox Show Cutter Buckle CheckBox Head Label: Holder Rendering Mode Solid / Edge / Hide Radio Buttons Selected-Tool Badge Rendering-Connection Badge RenderingCanvas The DispEngine.Displayee is MillingToolEditorDisplayee. The three anchor-and-buckle flags of HolderEditorDisplayee and the Holder Rendering Mode radios are all disabled while Show Holder is off, so a child option is reachable only when its parent is on. The menu is one flat list of labelled groups rather than nested submenus, which is what keeps it one click deep. The cutter's shape mode is not a control here. The server picks it when the canvas binds: InitializeDisplay sets ShapeMode to Solid Bounding Shape whenever UserService.EnablePhysics is false, and the Display Options dropdown offers no switch for it. The left column carries no editing of its own. Tool ID and Note are edited on the selected tool's General tab, where Duplicate and Delete are per-tool icon buttons, so the list stays a plain navigation column of router links. There is no batch selection and no batch action. The Tool ID can not be repeated. Create Tool takes the largest existing ID plus 1 (or 1 in an empty house), Duplicate Tool inserts the clone at the first free ID past both the source and the largest existing ID, and renaming a tool onto an ID the house already holds is refused as a conflict. When the canvas first binds, InitializeDisplay attaches the MillingToolEditorDisplayee and snaps the camera to the isometric view. Each later tool selection re-points that displayee's MillingToolGetter at the chosen tool and calls the renderingCanvas.DispEngine.SetViewToHomeView(). Duplication Button Use Duplicate(params object[]) to duplicate the tool; the clone joins the house under a fresh ID. Tool Row Note A tool's row shows its note when the note exists and is not an empty string; otherwise it shows the AbstractNote, set in an italic caption so the auto-derived text reads as a fallback. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA). The page is built on the shared Control Tree: the tool nodes on the left, the selected node's tab cascade in the middle, the canvas on the right. wwwroot-src/src/router/routes.ts — declares the route itself: path tool-house/:toolId(\\d+)?/:tab?/:subtab?, name tool-house. wwwroot-src/src/components/AppMenuBar.vue — the Page ▾ dropdown; its first item targets the tool-house route. wwwroot-src/src/router/treeRoutes.ts — declares TOOL_TABS, CUTTER_SECTIONS and HOLDER_SECTIONS, and routeForTreeId / migrateLegacyTreeId, which map a Control-Tree id onto this page's tab params. wwwroot-src/src/composables/useRouteTabs.ts — the :tab? / :subtab? URL sync, defaulting to general, and to profile under Cutter / geometry under Holder. wwwroot-src/src/composables/useToolHouse.ts — the module-singleton state every tool-house panel and the canvas share: the tool list, the active tool, the tool-house key and the rendering connection id. wwwroot-src/src/pages/ToolHousePage.vue — routed page: ToolHouseRootPanel + tool list on the left, the tool's own five-tab strip in the middle, ToolHouseSetupPanel on the right, in two nested resizable <q-splitter> panes. Cutter and Holder grow a second, URL-synced sub-tab strip from the tab node's children, and NodeTabCascade.vue hosts the active tab's panel and the levels nested below it. wwwroot-src/src/components/controlTree/NodeTabCascade.vue — the nested-level host the page mounts inside the active tab. wwwroot-src/src/components/toolhouse/ToolHouseSetupPanel.vue — the canvas column: one RenderingCanvas bound server-side to MillingToolEditorDisplayee, following the page's selected tool, with the Display Options dropdown (Show Cutter / Show Holder + the 3 anchor-and-buckle flags + the Holder Rendering Mode radios). wwwroot-src/src/components/widgets/DisplayOptionsMenu.vue — the generic groups/items dropdown that panel feeds, which is why the menu is flat groups rather than nested submenus. wwwroot-src/src/components/controlTree/toolHouseItemTypes.ts — the tool house's ItemType registry: one tool node per tool, and each tool node's …/cutter, …/holder, …/clamping, …/intelligent children. wwwroot-src/src/components/controlTree/toolhouse/ToolHouseRootPanel.vue — the tool-house root node: Object Management over the MachiningToolHouse + New Tool. The button's own entries are Load, Save As, Copy, Paste and XML; the Load Resource entry is conditional on a resourceDirectory prop this panel does not pass, so it is absent here. wwwroot-src/src/components/controlTree/toolhouse/ToolNodePanel.vue — one tool's General tab: Tool ID / Note / auto Abstract Note + Duplicate / Delete. Mounting it points the tool canvas at that tool. wwwroot-src/src/components/controlTree/toolhouse/ToolCutterPanel.vue — the Cutter stem: cutter type selector plus the MillingCutter identity fields (Shank Mass / Hone Radius / Relief Angle). wwwroot-src/src/components/controlTree/toolhouse/CutterSectionPanel.vue — the cutter's inner tabs, keyed off the node's role path (material / profile / upper-beam / opt). Flute Profile is edited inline; the others dispatch to wwwroot-src/src/components/toolhouse/MaterialDiv.vue (which grows CoatingLayersDiv.vue), wwwroot-src/src/components/toolhouse/UpperBeamDiv.vue and wwwroot-src/src/components/toolhouse/MillingCutterOptLimitDiv.vue. wwwroot-src/src/components/controlTree/toolhouse/CutterContoursPanel.vue — the Flute Contours stem: the fluting type selector only. The selected fluting's editor grows below it. wwwroot-src/src/components/controlTree/toolhouse/FlutingPanel.vue — the concrete fluting node and its fluting-level fields; uniform fluting grows one Baseline Contour, free fluting one tab per flute. wwwroot-src/src/components/controlTree/toolhouse/FluteContourPanel.vue — one flute contour node (baseline, or flute-<i> for a free fluting): hosts Setup Angle, with Side Contour and Bottom Contour as sub-tabs. fluteContourNode.ts carries the shared re-commit. wwwroot-src/src/components/controlTree/toolhouse/FluteSideContourPanel.vue / FluteBottomContourPanel.vue — kind selector + editor, dispatching to wwwroot-src/src/components/toolhouse/fluting/ConstHelixSideContourDiv.vue, FreeformSideContourDiv.vue, SlideBottomContourDiv.vue and FreeformBottomContourDiv.vue; the two freeform editors share SpanContourPosListDiv.vue for the per-flute position list. wwwroot-src/src/components/controlTree/toolhouse/ToolHolderPanel.vue — the Holder stem: holder type selector plus the holder's Name / Note / auto Abstract Note, committed through the per-type holder controller. wwwroot-src/src/components/controlTree/toolhouse/HolderSectionPanel.vue — the Cylindroid holder's Geometry (the Z-R profile, via wwwroot-src/src/components/geom/CylindroidEditor.vue) and both holders' Resolution tabs; resyncs the Cylindroid holder (UpdateByCylindroid()) after each geometry edit. A Freeform holder's Geometry / Geom To Spindle / Geom To Cutter tabs are the generic Geometry / Transformer Control-Tree slots (wwwroot-src/src/components/controlTree/GeometrySlotPanel.vue / TransformerSlotPanel.vue), wired by toolHouseItemTypes.ts to FreeformHolderController's keys and resync. wwwroot-src/src/components/controlTree/toolhouse/ToolClampingPanel.vue — the Clamping tab: ExposedCutterHeight = PreservedDistance + FluteHeight; changing either field updates the other on the server. wwwroot-src/src/components/controlTree/toolhouse/ToolIntelligentPanel.vue — the Intelligent Holder tab; a thin wrapper over wwwroot-src/src/components/toolhouse/IntelligentHolderDiv.vue (Observation Location: ObservationAnchorReference dropdown + relative Z + ring radius). wwwroot-src/src/api/toolHouse.ts — typed wrapper over three server modules: ToolHouseController (/api/ToolHouse), CutterController (/api/Cutter) and ToolHouseDisplayController (/api/mech/tool-house-display). wwwroot-src/src/api/cylindroidHolder.ts / wwwroot-src/src/api/freeformHolder.ts — typed wrappers over CylindroidHolderController / FreeformHolderController. Mech/ToolHouseController.cs — the tool-house collection and the tool-level fields. REST endpoints: GET /, GET /{id}, GET /GetHolder, GET/PUT /{id}/observation, PUT /{id}/note | exposed-height | preserved-distance, POST /Initialize | Update | SelectTool | CreateTool | DuplicateTool | RenameTool | SetHolderType | ClearToolCache, DELETE /DeleteTool. Mech/CutterController.cs — cutter editing, the /api/Cutter sibling of ToolHouseController. REST endpoints at /api/Cutter/*: POST EnsureCutter | ClearCutter, PUT /{id}/shaper-profile | fluting | general | opt-limit, FreeFluting child CRUD at /{id}/fluting/contours[/{index}], GET/POST /{id}/upper-beam[/create | /resync], and the material endpoints /{id}/flute-material/*, /{id}/shank-material/*, /{id}/coating-layers/*. Mech/ToolHouseDisplayController.cs — REST endpoints at /api/mech/tool-house-display/* for display options (initialize, select-tool, show-cutter / show-holder / show-geom-anchor / show-spindle-buckle / show-cutter-buckle, holder-rendering-mode, cutter-shape-mode, clear-cache). initialize attaches the MillingToolEditorDisplayee and snaps to the isometric view; select-tool re-points the MillingToolGetter and snaps to the home view. It also reports enablePhysics from UserService. Mech/CylindroidHolderController.cs — holder-aware layer over a tool's CylindroidHolder. REST endpoints at /api/CylindroidHolder/*: GET Get (returns name / note / abstract note / resolution + indexes the holder's Cylindroid), POST UpdateGeometryContent | SetName | SetNote | SetPolarResolution. UpdateGeometryContent is the post-edit resync (UpdateByCylindroid() + ClearCache()) that the generic CylindroidController cannot perform. Mech/FreeformHolderController.cs — the Freeform counterpart. REST endpoints at /api/FreeformHolder/*: GET Get (name / note / abstract note / resolution + indexes the holder's geometry and two placement transformers under per-session keys), POST CreateGeometry | UpdateGeometry | IndexCurrentGeometry | UpdateGeometryContent | UpdateGeomToSpindleTransformer | UpdateGeomToCutterTransformer | SetName | SetNote | SetPolarResolution. Every shape edit ends in UpdateByGeom() + ClearCache() + AlignAnchorByExposedCutterHeight(), the resync the generic geometry and transformer controllers cannot perform. Environments/UserService.cs — the web client's own per-user service, living on the server; ToolHouseDisplayController reads EnablePhysics from it. Note The fluting type is named loosely on the wire, and every spelling resolves. PUT /{id}/fluting accepts UniformFluting / uniform and FreeFluting / free, and equally UniformContourTray / FreeContourTray. A Control-Tree id whose cutter branch reads …/contours/tray… resolves to the …/contours/fluting… node. One cutter type has no editor here, and the app says so where the type is chosen: the FreeformRemover. Selecting it keeps the existing model intact and shows a note — FreeformRemover editor is not yet available in the web frontend. Use the WPF client or HiNcRcl for now. Three smaller surfaces are absent for the same reason: the InsertCutter and FluteInnerBeam physics groups, and the CustomSpinningProfile shaper-profile type — the profile tab offers the five APT types (General / Ball / Column / Cone / Taper). See Also Cutter Tab — the cutter half of a tool, and the editors each cutter type grows Holder Tab — the holder half, and the editors each holder type grows Stick Tool Panel — the selected tool’s tab cascade, which those two tabs belong to General Setup Page — the equipment these tools are mounted into"
  },
  "anatomy/tool-house/stick-tool-panel.html": {
    "href": "anatomy/tool-house/stick-tool-panel.html",
    "title": "Stick Tool Panel | HiAPI-C# 2025",
    "summary": "Stick Tool Panel The term stick is for not only milling, but other remover like electric discharge machining tool. On the shipped web client the Stick Tool Panel is the toolhouse/tool-<n> node of the Tool House Page: picking a tool in that page's left list mounts it, and its editor is the tab strip filling the page's middle column. The key model is MillingTool. Layout Tool Node (toolhouse/tool-<n>) General Tab Tool ID TextField — the T-number; committing it renames the tool Note TextField (editable) Abstract Note (read-only, auto-derived, with a one-click copy button) Duplicate Button and Delete Button (icon buttons on the tab's title bar) Cutter Tab Cutter Panel Holder Tab Holder Panel Clamping Tab Exposed-Cutter-Height numeric field Preserved-Distance-Between-Flute-and-Spindle-Nose numeric field Int. Holder Tab Observation Location Reference Anchor Dropdown (ObservationAnchorReference) — its options are the MillingToolAnchorReference names the server sends with the observation: None, Tool Tip, Holder Anchor, Spindle Buckle Anchor Relative-Z-From-Reference numeric field (RelativeHeightFromObservationAnchor_mm) Observation-Ring-Radius numeric field (ObservationRingRadius_mm) All five tabs ship unconditionally: the Int. Holder tab is one of the five TOOL_TABS, and the tool node always grows its …/intelligent child. Nothing gates it on UserService.EnablePhysics. Object Management is house-level rather than per-tool: the Object Management Menu Button sits on the Tool House root panel with file extension .MachiningToolHouse (load type Hi.Machining.MachiningToolHouse, HiMech) and covers the whole house, while the tool node offers Duplicate and Delete for the single tool. There is no per-tool object-management button, and no separate tab for the identity fields — the Abstract Note and Note sit on the General tab, alongside Tool ID and the Duplicate / Delete buttons. Tabs and the URL The tabs are TOOL_TABS — General, Cutter, Holder, Clamping, Int. Holder — declared in wwwroot-src/src/router/treeRoutes.ts, and those same five names are the :tab? segment of the page route /tool-house/:toolId?/:tab?/:subtab?. General is the tool node's own panel; the other four are the tool node's children (…/cutter, …/holder, …/clamping, …/intelligent), registered in wwwroot-src/src/components/controlTree/toolHouseItemTypes.ts. Cutter and Holder are type-selector stems, so each grows a second, URL-synced sub-tab strip — the :subtab? segment, from CUTTER_SECTIONS (Material / Flute Profile / Flute Contours / Upper Beam / Optimization — Material only while the shell's Show Physics Options preference is on) and HOLDER_SECTIONS (Geometry / Resolution). The levels below that — Flute Contours to fluting to flutes to side and bottom contour — nest inside wwwroot-src/src/components/controlTree/NodeTabCascade.vue, which the page mounts inside the active tab. wwwroot-src/src/composables/useRouteTabs.ts keeps both segments in the URL, defaulting to general, and to profile under Cutter / geometry under Holder. Selecting another tool keeps the tab segments: only the tool part of the URL moves, so the reader stays on the tab they were reading. A Control-Tree id addressing any of these levels is translated into the page's route params by routeForTreeId, and an id deeper than the URL carries lands on the nearest tab. Note The Exposed-Cutter-Height and Preserved-Distance-Between-Flute-and-Spindle-Nose are directly related: ExposedCutterHeight = PreservedDistance + FluteHeight, so each value changes when the other is changed. Editing Preserved Distance commits PUT /api/ToolHouse/{id}/preserved-distance, whose response carries the recomputed pair and fills both fields; editing Exposed Height commits PUT /api/ToolHouse/{id}/exposed-height, which answers without a body, so the panel re-reads the tool to pick up the new preserved distance. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA). The tool node is a set of tabs on the Tool House page rather than a panel of its own: wwwroot-src/src/router/treeRoutes.ts — declares TOOL_TABS (general / cutter / holder / clamping / intelligent) with CUTTER_SECTIONS and HOLDER_SECTIONS, and routeForTreeId, which turns a toolhouse/tool-<n>/<tab>/<subtab> Control-Tree id into the /tool-house route params. wwwroot-src/src/pages/ToolHousePage.vue — renders the five-tab strip, mounts only the active tab's panel, and keeps the tab segments when the selected tool changes. wwwroot-src/src/components/controlTree/toolHouseItemTypes.ts — the Control-Tree ItemType registry: buildToolChildren emits the tool node's …/cutter, …/holder, …/clamping and …/intelligent children, General being the tool node's own panel. wwwroot-src/src/components/controlTree/toolhouse/ToolNodePanel.vue — the General tab: Tool ID / Note / read-only auto Abstract Note with copy, plus Duplicate and Delete. Mounting it points the tool canvas at that tool. wwwroot-src/src/components/controlTree/toolhouse/ToolCutterPanel.vue — the Cutter tab's type selector (Milling Cutter / Freeform Remover / None) plus the MillingCutter identity fields. wwwroot-src/src/components/controlTree/toolhouse/ToolHolderPanel.vue — the Holder tab's type selector (None / Cylindroid / Freeform) plus the Cylindroid holder's Name / Note / auto Abstract Note. wwwroot-src/src/components/controlTree/toolhouse/ToolClampingPanel.vue — the Clamping tab and its two coupled fields. wwwroot-src/src/components/controlTree/toolhouse/ToolIntelligentPanel.vue — the Int. Holder tab; a thin wrapper over wwwroot-src/src/components/toolhouse/IntelligentHolderDiv.vue, which holds the Observation Location controls and reads no physics flag. wwwroot-src/src/components/controlTree/NodeTabCascade.vue — hosts the active tab's panel and the levels nested below it. wwwroot-src/src/composables/useRouteTabs.ts — syncs the :tab? / :subtab? params with the URL. wwwroot-src/src/composables/useToolHouse.ts — the module-singleton state every tool-house panel is a thin view over: the tool list, the active tool, and the rendering connection id. Mech/ToolHouseController.cs — [Route(\"api/[controller]\")], so /api/ToolHouse: the tool-level fields the tool node edits — PUT /{id}/note | exposed-height | preserved-distance, GET/PUT /{id}/observation, POST DuplicateTool | RenameTool | SetHolderType, DELETE DeleteTool. Mech/CutterController.cs (/api/Cutter) and Mech/CylindroidHolderController.cs (/api/CylindroidHolder) — the server surface behind the Cutter and Holder tabs. wwwroot-src/src/api/toolHouse.ts — the typed client for those endpoints. See Also Tool House Page — the page this tool node sits in, and where the tool list and the route live Cutter Tab — the cutter half of the tab cascade Holder Tab — the holder half"
  },
  "anatomy/util/file-explorer.html": {
    "href": "anatomy/util/file-explorer.html",
    "title": "File Explorer Page | HiAPI-C# 2025",
    "summary": "File Explorer Page The File Explorer page is a server-side filesystem browser covering three named roots: AdminDirectory — server-wide admin area. ProjectDirectory — the currently-loaded project directory (omitted from the root list when no project is loaded). ResourceDir — the shared resource tree under AdminDirectory + \"Resource/\". wwwroot-src/src/components/FileExplorer.vue holds the whole browser — toolbar, tree, editor panel and preview. wwwroot-src/src/pages/FileExplorerPage.vue is a thin route wrapper around it, and wwwroot-src/src/components/widgets/FileExplorerDialog.vue mounts the same component in a modal as the app's file picker (see Picker Mode). Note Absolute filesystem paths never leave the server through the File Explorer's own endpoints. The /roots endpoint returns only { name, displayName }, and Common/FileExplorerController.cs routes every exception message through a scrub that replaces root prefixes with the tokens <Admin> / <Project> / <Resource> before returning it. That scrub is private to that controller, so it does not cover the STL preview endpoints the editor column also calls — see STL Preview Pane. Layout File Explorer Page Toolbar Root Selector Dropdown — display-name only, sourced from GET /roots; a caller that locks the root gets the name as plain text instead. Up Button Path Input — editable; Enter navigates. Refresh / New Folder / New File / Upload Buttons. Sort Dropdown — sort key (Name / Size / Modified / Type), Ascending / Descending, and a “Folders first” checkbox. Editor Panel Toggle (edit_note pencil) — shows or hides the editor slave panel. Breadcrumb Row — single-click navigation up the tree, plus a file-type filter select whenever the host supplies filters. The page supplies none, so the select belongs to picker mode. Explorer | Editor Splitter — the divider collapses to zero width while the editor panel is hidden. Listing Tree (<q-tree>) — lazy: a folder lists its children the first time it is expanded. Each row is icon + name + a fixed-width size / modified tail, with the hover action strip laid over that tail so nothing reflows when the pointer enters a row. Ordering follows the toolbar's sort control. Row select: Directory → expand it and make it the current directory (the toolbar ops and the URL follow). Text file → load it into the editor panel; .stl → open the STL preview in that same slot. Both only while the panel is shown. Row double-click on a file opens it in the editor panel — or the preview, for an .stl — even when the panel is hidden. This is the gesture that opens a file for editing; the action strip deliberately carries no Edit button, since a second pencil beside Rename's drive_file_rename_outline would be two near-identical icons meaning different things. The empty editor's own hint has not followed that decision — it reads \"Click a file (or its Edit action) to load it here.\", naming an action no row offers. Actions: Download (files), Download ZIP (folders), Extract ZIP (.zip only), Rename, Duplicate, Delete (double-click to confirm). Pick Column (picker mode only) — a radio or a checkbox on every pickable row, rendered as an empty cell elsewhere so unpickable rows keep the same indent. Editor Slave Panel (right) Bar — Root / relative/path label with a red * while the buffer is dirty, language select, Auto Save checkbox, Save button (disabled while Auto Save is on), close icon. Body — <TextEditor> wrapping CodeMirror 6, filling the panel. STL Preview — an .stl row hands this slot to <StlPreviewPane>, a server-rendered 3D view that replaces the editor's bar and body and stays up until it is closed; see STL Preview Pane. The text buffer and any unsaved edits survive underneath and return when the preview closes. Behavior Path-traversal defence. Every request is resolved via Path.GetFullPath and validated with Hi.Common.PathUtils.PathUtil.IsDescendant(root, absolute) before any IO. Attempts like relativePath=../outside are rejected with HTTP 400. Duplicate. POST /copy tries {name}-Copy-00 through {name}-Copy-19 and returns the first free slot; 400 if all 20 are taken. UTF-8 without BOM. WriteText uses a cached new UTF8Encoding(encoderShouldEmitUTF8Identifier: false) so round-tripped files do not accumulate a 3-byte BOM on every save. Binary gating. /read-text reports a binary file rather than refusing it: it answers content=null, isBinary=true, and the panel toasts. The client decides before the round-trip — an extension set (.stl, .zip, .dll, .exe, images, .pdf, Office documents, .sqlite / .db, …) keeps a click on a binary row from opening the editor at all, and .stl is routed to the STL preview instead. Line endings. The buffer is LF-normalized on load, because CodeMirror 6 joins lines with LF and would otherwise echo a normalize-only change that falsely dirties a freshly opened CRLF file. Save converts back to the style the file was read with. Auto Save. Checked, the panel writes 800 ms after typing stops and the Save button disables. Switching files, closing the panel and leaving the page each flush a pending write first; with Auto Save off, dirty edits raise a discard confirm instead, and settleEditorBeforeClose() keeps the user on the page when that confirm is cancelled. Per-device view prefs. Editor shown, splitter position, Auto Save and the sort spec persist in localStorage under hinc.fileExplorer.viewPrefs.v1. Nothing is written until one of them is changed, and the page's own default is editor shown — so a first visit, a private window or a cleared browser all open with the editor panel up and single-click file opening already live. Dialog instances seed the splitter, Auto Save and the sort from that blob and write those three back, but they neither read nor write the panel-visibility part: a picker always opens with the editor panel hidden, and a one-off edit inside one does not rearrange the page. Picker Mode The same component runs inside wwwroot-src/src/components/widgets/FileExplorerDialog.vue, which adds an apply bar and emits each pick as \"{rootName}:{relativePath}\". Props steer it: pickable (file / folder / any / none) turns the pick column on, multi swaps radios for checkboxes, filters supplies the file-type dropdown (“All Files” is appended when the caller's list omits it), lockRoot and allowedRoots narrow the root switcher, and mode: 'save' turns the path input into a save target with a forcedExtension appended on confirm. That dialog is how the app opens and saves files: the menu bar's Project ▾ entries, the Object Management Menu Button, FilePathInput, the Mission command panels, the Machine Tool page, and the Mechanism Builder's Load and both Save As actions. Syntax Highlighting wwwroot-src/src/components/widgets/TextEditor.vue wraps CodeMirror 6 so the editor gets real syntax highlighting for the common project-file formats listed below. Stack: codemirror + @codemirror/state + @codemirror/view (core). @codemirror/lang-xml + @codemirror/lang-json + @codemirror/lang-markdown + @replit/codemirror-lang-csharp + the in-repo mission-script mode from wwwroot-src/src/components/widgets/missionScriptLanguage.ts (5 language modes). @codemirror/autocomplete, wired only when a completion source is supplied. Props: modelValue (two-way), language: 'xml' | 'json' | 'markdown' | 'csharp' | 'mission-script' | 'text' (default text), readonly, and completionSource — an optional CodeMirror completion source that overrides the language-provided completions, read once at mount. Language and readonly are swapped via Compartment.reconfigure, so the view never has to tear down on mode change. Extension → language mapping lives in wwwroot-src/src/components/widgets/editorLanguage.ts (single source of truth imported by both TextEditor.vue and FileExplorer.vue): Language Extensions xml xml, hincproj, CoatingMaterial, CutterMaterial, Holder, WorkpieceMaterial, mp, MillingPara, SpindleCapability, StickMachiningTool, general-mech, mt markdown md, markdown json json csharp cs, csx mission-script none — the mode is picked from the editor's language select, and wwwroot-src/src/components/mission/ScriptCommandPanel.vue sets it directly on its own editor text (fallback) everything else, including .nc / .ptp / .mpf / .h / .csv The language select in the editor bar offers all six modes, so an auto-detected mode can be overridden per file. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/FileExplorer.vue — the browser itself: toolbar, sort control, breadcrumb + filter, the lazy tree with its hover actions, the editor slave panel with Auto Save, the STL preview slot, and the view prefs. wwwroot-src/src/pages/FileExplorerPage.vue — routed page at /util/file-explorer; parses and mirrors the location in the URL and guards the route leave. wwwroot-src/src/components/widgets/FileExplorerDialog.vue — modal wrapper: apply bar, save mode, \"{rootName}:{relativePath}\" picks. wwwroot-src/src/components/explorerSort.ts — sort keys, comparators, DEFAULT_SORT and coerceSortSpec behind the Sort dropdown. wwwroot-src/src/components/widgets/fileFilter.ts — the FileFilter shape driving the file-type select. wwwroot-src/src/utils/collapsibleSplit.ts — collapses the editor divider while the panel is hidden. wwwroot-src/src/components/StlPreviewPane.vue — the 3D preview that takes over the panel for .stl files, over Disp/StlPreviewController.cs. wwwroot-src/src/components/widgets/TextEditor.vue — CodeMirror 6 wrapper. wwwroot-src/src/components/widgets/editorLanguage.ts — extension → EditorLanguage mapping. wwwroot-src/src/components/widgets/missionScriptLanguage.ts — the in-repo mission-script mode. wwwroot-src/src/api/fileExplorer.ts — typed wrapper over /api/file-explorer/*. wwwroot-src/src/router/routes.ts — /util/file-explorer entry (route name util-file-explorer). wwwroot-src/src/components/AppMenuBar.vue — Page → File Explorer entry, below the separator that follows the three workflow pages. Common/NamedRootResolver.cs — resolves AdminDirectory / ProjectDirectory / ResourceDir; shared with every other controller that reads or writes under a named root. Common/FileExplorerController.cs — REST endpoints under /api/file-explorer: Method Path Notes GET /roots List available roots; Project is omitted when no project is loaded. Returns display names only. GET /list?rootName=&relativePath= Directories-first, name-ascending listing; the client re-sorts it per the toolbar's sort control. GET /read-text?… UTF-8 text; when the file is detected as binary returns content=null, isBinary=true. POST /write-text Body {rootName, relativePath, content}; creates parents as needed. POST /create-file Fails if target exists. POST /create-directory Recursive create; no-op if already a directory. POST /rename Body {rootName, relativePath, newRelativePath}; refuses cross-root moves. POST /copy {name}-Copy-00..-Copy-19; uses Hi.Common.FileLines.FileUtil.CopyDirectory for directories. DELETE /delete?… Files → delete, directories → recursive; refuses to delete the root itself. GET /download?… Streams a file as application/octet-stream. GET /download-zip?… Zips a directory in-memory and streams application/zip. POST /upload?… Multipart single-file upload; overwrites target. POST /extract-zip Body {rootName, relativePath}; extracts next to the archive into <name>/. Addressing The browsed location is mirrored into the URL by an optional catch-all: /util/file-explorer/{RootTitle}/{relative/path}. The bare /util/file-explorer still resolves through the named route the menu uses, so both a deep link and a plain menu click land correctly. Browsing rewrites the URL with router.replace, and an external URL change — a paste, a bookmark, browser back — drives the explorer the other way. The named roots (Admin / Project / Resource) are the only addressing the client sees, and the absolute path is formed and kept on the server — subject to the error-message caveat noted at the head of this page. See Also File Explorer (manual) — the end-user task: the roots, and renaming a file to move it Object Management Menu Button — shares the XML editor dialog pattern and targets the same project / resource folders through a different endpoint family. Mechanism Builder Page — drives its Load and both Save As operations through this browser's dialog wrapper. STL Preview Pane — the 3D preview this page's editor column hands over to for an .stl row."
  },
  "anatomy/util/index.html": {
    "href": "anatomy/util/index.html",
    "title": "Util Pages | HiAPI-C# 2025",
    "summary": "Util Pages The utility pages are the ones not tied to the main machining workflow. They support side-tasks — browsing the server filesystem and building a generic mechanism XML — and are reachable from the menu bar's Page ▾ dropdown, below the separator that follows the three workflow pages (Tool House / General Setup / Execution). Their routes are /util/file-explorer and /util/mech-builder; the dropdown itself is built in wwwroot-src/src/components/AppMenuBar.vue over the menu.page.* strings in wwwroot-src/src/i18n/en/menu.ts, and both routes are declared in wwwroot-src/src/router/routes.ts. The two pages share a component, not just a menu section. The File Explorer's browser (wwwroot-src/src/components/FileExplorer.vue) also runs inside a modal wrapper, wwwroot-src/src/components/widgets/FileExplorerDialog.vue, and that wrapper is the app's file picker: it is what the Mechanism Builder's Load and both Save As actions open, and what the menu bar's Project ▾ entries open. One page documents the browser, the other a page built on it. Pages File Explorer — server-side filesystem browser over three named roots (Admin / Project / Resource), with a lazy-loading tree, an editor slave panel running CodeMirror 6, an STL preview, zip pack / extract, and rename / duplicate / delete. The same component is the app's modal file picker. Mechanism Builder — editor for a standalone GeneralMechanism: anchor / branch graph, per-branch transformer, per-anchor geometry and display colour, with server-side Load and Save As through the File Explorer's picker. STL Preview Pane — the 3D preview that takes over the File Explorer's editor column for an .stl row: its cancellable load, the rendering connection it owns, and the transform it can bake into the file. Legacy-Controller — the legacy controller screen, reachable from Page → Legacy-Controller below the second separator. The General Setup page's Controller branch is the settings face for the SoftNcRunner; this page stays reachable while it carries settings that tree has no editor for. Where Neighbouring Editors Live Three editors a reader might expect here are shipped surfaces of other pages: Cutter editor — a Tool House Control-Tree branch, not a util page: wwwroot-src/src/components/controlTree/toolhouse/ToolCutterPanel.vue with its section, contour and flute panels, over Mech/CutterController.cs, reached through the tool-house route. The Rake-face angles — plain cutter fields: radialRakeAngle_deg in wwwroot-src/src/components/controlTree/toolhouse/FluteSideContourPanel.vue and axialRakeAngle_deg in wwwroot-src/src/components/controlTree/toolhouse/FluteBottomContourPanel.vue. A .MillingPara or .mp file opens as XML in the File Explorer's editor panel. Color Index Time Chart — a strip chart on the Execution page: wwwroot-src/src/components/execution/charts/StripIndividualChart.vue, mounted by wwwroot-src/src/pages/ExecutionPage.vue under the colorIndexTimeChart panel flag that Environments/ExecutionDivConfig.cs persists. It plots the user-picked inspecting key live per step."
  },
  "anatomy/util/mech-builder.html": {
    "href": "anatomy/util/mech-builder.html",
    "title": "Mechanism Builder Page | HiAPI-C# 2025",
    "summary": "Mechanism Builder Page The Mechanism Builder page edits a standalone GeneralMechanism — its anchor topology, per-branch ITransformer, and per-anchor optional geometry inside a Solid. Unlike the project-scoped editors (Fixture / Workpiece / ToolHouse / Spindle Capability), this page is user-scoped — no project needs to be loaded. Key Model: GeneralMechanism Related Model: GeneralXyzabcChain + GeneralXyzabcMachineTool (used by “Save As Machine Tool”) Layout Mechanism Builder Page Three Fixed Columns — equal width, separated by 1px borders, none of them draggable. Every column keeps its header pinned; the graph and the editor cards scroll inside their own region below it. Column 1: Graph Title + File Menu + Add Anchor Button. File Menu New — discards the current mechanism and starts an empty one with a root anchor. Load… — opens the server file picker (Admin / Project / Resource) filtered to *.GeneralMechanism / *.xml; the backend parses the picked file in place and records its directory so ReLoad can re-read it. That filter matches none of the shipped mechanisms, which are named .general-mech beside the machine tool they belong to; the dialog's appended All Files entry is what reaches them, and the backend parses whatever is picked. ReLoad — re-parses the file last loaded (disabled until a file has been loaded). The entry is spelled ReLoad, with the second capital. Save As General Mechanism — writes a .GeneralMechanism XML to the picked server location and retargets ReLoad at it. Save As Machine Tool — wraps the mechanism in a GeneralXyzabcMachineTool and writes a .MachineTool XML to the picked server location, leaving the open-mechanism pointer where it is. The envelope is the Xyzabc machine tool; the menu entry names neither that nor the file type. Add Anchor — creates a standalone anchor, connected to nothing, and selects it. File Line — the loaded file's relative path, or an “unsaved” caption while the mechanism has no file. Graph — mermaid diagram of anchors (nodes) + branches (edges), scrolling inside its own region; node / edge click selects. The selected anchor is filled green and the selected branch's edge is stroked green. Column 2: Selected Item Editor — content depends on selection: Anchor selected: header with a Root badge on the root anchor, an Extend button, and a delete button (double-click; absent on the root). Identity Card — the anchor's Guid, an inline name field (debounced), and an “Add Branch” select that connects this anchor to the picked one. Geometry Card — a Geometry checkbox attaches or removes the anchor's Solid, and a badge shows the current geometry type. While attached the card carries a display-colour control and mounts the geometry editor over five kinds: Box3d, Cylindroid, StlFile, TransformationGeom and GeomCombination. CubeTreeFile and ExtendedCylinder are absent because the backend's create-geom does not construct them. TransformationGeom still exposes its own inner geometry and inner transformer through the nested editor. Branch selected: header with a delete button (double-click). Identity Card — the branch's Guid, an inline name field (debounced), and the fletch → arrow anchor chips naming the two anchors it joins. Transformer Card — Transformer Select Panel (7 transformer kinds). Column 3: Display — RenderingCanvas Tool Bar, a rendering / disconnected badge, and RenderingCanvas bound to DelegateFuncDisplayee(() => MechService.GeneralMechanism as IDisplayee). Server File Picker — one FileExplorerDialog shared by Load and both Save As actions. Behavior New-anchor auto-naming. Newly-created anchors receive placeholder names (NewAnchor-001, NewAnchor-002, …) — the first NewAnchor-{i:000} no descendant anchor already carries. Inline rename is debounced 400 ms. Extend. The anchor editor's Extend button creates a new anchor and the branch from the selected one to it in a single call, then selects the new anchor. This is the normal way a chain grows; Add Anchor leaves the new anchor unconnected. Branch add filter. The “Add Branch” select inside the anchor editor filters out the selected anchor itself and anchors already directly connected, in either direction. A new branch starts on NoTransform. Root protection. The root anchor cannot be deleted; double-click delete on any other anchor works. Branch transformer swap. TransformerSelectPanel uses a parent-aware onCreate hook that calls POST /branch/{id}/update-transformer, so the new transformer takes effect on the next frame without a re-init round-trip. Same idiom as Fixture Page. Geometry cache invalidation. Geometry edits POST to anchor/{id}/refresh-geom-cache, which triggers the same Solid.ClearCache() pattern used across the project. Anchor display colour. The colour input authors an #rrggbb that persists inside the mechanism's <Solid> element, so every consumer of the file shows the same colour; a reset button drops the authored value and an “auto” badge marks the stable Guid-seeded fallback the 3D view otherwise renders with. Solid.Display reads the colour per frame, so the canvas follows without a cache refresh. DelegateFuncDisplayee. The RenderingCanvas is wired through a delegate so edits render next frame without IndexService churn. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/pages/MechBuilderPage.vue — routed page at /util/mech-builder: File menu, the three columns, the anchor / branch editors, the display-colour control, the picker wiring and the canvas. wwwroot-src/src/components/mech/MechBuilderGraph.vue — lazy mermaid loader + click-proxy onto mermaid node / edge DOM. Mermaid is dynamic-imported so the first bundle stays slim (~1 MB raw split into its own chunk); labels are emitted quoted, which the parser requires for CJK text. wwwroot-src/src/components/widgets/FileExplorerDialog.vue — the server file picker behind Load and both Save As actions. wwwroot-src/src/components/geom/GeometryEditor.vue — the geometry switchboard the anchor's Geometry card mounts. wwwroot-src/src/components/topo/TransformerSelectPanel.vue — the branch transformer switchboard. wwwroot-src/src/api/generalMechanism.ts — typed wrapper over /api/general-mechanism/*, including the three server-file operations and the anchor colour endpoints. wwwroot-src/src/api/transformer.ts — the seven transformer kinds and their New endpoints. wwwroot-src/src/api/geometry.ts — GeometryKind, the union the anchor's allowed kinds are drawn from. wwwroot-src/src/utils/path.ts — stripDefaultMarker, which sheds the .default ownership marker from the name offered on save. wwwroot-src/src/router/routes.ts — /util/mech-builder entry (route name util-mech-builder). wwwroot-src/src/components/AppMenuBar.vue — Page → Mechanism Builder entry. Mech/MechBuilder/GeneralMechanismService.cs — DI singleton that holds the current mechanism + last BaseDirectory + RelFile. Mech/MechBuilder/GeneralMechanismController.cs — /api/general-mechanism/* CRUD over anchors / branches / per-anchor geometry and colour; server-side Load, Reload and XML Save As for both GeneralMechanism and GeneralXyzabcMachineTool envelopes. Mech/MechBuilder/GeneralMechanismDisplayController.cs — /api/general-mechanism/display/* view init and the isometric reset-view. Common/NamedRootResolver.cs — resolves the three named roots the picker offers. Program.cs — registers GeneralMechanismService as a DI singleton. IndexService Keys The mechanism state is persistent across pages (unlike Fixture which re-initialises on mount), so mechanism keys are not registered with useCleanupHub. Stale keys are harmless; they are re-pointed on the next index-transformer / index-geom call. general-mechanism.current — the mechanism itself (informational; DelegateFuncDisplayee bypasses IndexService at render time). general-mechanism.branch.{guid:N}.transformer — stable per-branch transformer key used by TransformerSelectPanel. general-mechanism.anchor.{guid:N}.geom — stable per-anchor key for whatever geometry the anchor's Solid holds, used by GeometryEditor. index-geom indexes that geometry without replacing it, so re-selecting an anchor leaves a non-TransformationGeom geometry intact. File IO Load and both Save As actions go through one server file picker — the File Explorer's dialog wrapper — over the three named roots AdminDirectory / ProjectDirectory / ResourceDir. The XML is read and written by the backend at the picked path; nothing travels through the browser. The picker opens on the root and folder of the last successful operation, starting at ResourceDir, where the shipped mechanism templates live, and a save offers the current file's name with the .default ownership marker stripped and the target extension forced (.GeneralMechanism or .MachineTool). The File menu has New / Load… / ReLoad plus the two Save As entries; there is no plain “Save” that overwrites the last path. Saving a General Mechanism retargets ReLoad at the new file; saving a Machine Tool deliberately does not, because it is a separate file type that does not replace the open mechanism pointer. See Also Fixture Page — parent-aware onCreate transformer rebind pattern reused for Branch. Transformers — the shared 7-transformer switchboard. Geometry Management Control — embedded under the anchor editor. Machine Tool — where a project's chain is loaded, replaced and previewed, next to this user-scoped builder. File Explorer — the server-side browser this page's Load and Save As dialogs are built on. Spindle Capability Page — the project-scoped editor with the same Load / Reload / Save As pattern. Mechanism Builder (manual) — the end-user task: driving this editor, and what a machine chain built in it must be named."
  },
  "anatomy/util/stl-preview-pane.html": {
    "href": "anatomy/util/stl-preview-pane.html",
    "title": "STL Preview Pane | HiAPI-C# 2025",
    "summary": "STL Preview Pane The STL Preview Pane is the server-rendered 3D view that takes over the File Explorer's editor column while an .stl file is open. It is neither a route nor a dialog of its own: it renders inside the right-hand slave panel of /util/file-explorer, and of the modal file picker built on the same browser component, replacing the text editor's bar and body for as long as an STL is selected. It carries its own rendering connection, its own copy of the file's triangles, and a Transform section that can bake a pose back into the file on disk. Where It Renders The File Explorer mounts the pane on the root-relative path of the STL being previewed; the named root and that path are both pinned when the preview opens, so switching the explorer's root closes the preview rather than silently re-targeting it. Three gestures open one, and all key on the stl extension alone: Selecting the row, but only while the editor slave panel is showing. Submitting the file's path in the toolbar's path field, under that same panel-showing guard. Double-clicking the row header, which shows the panel first. Panel visibility starts from the device-local File Explorer preferences on the page and defaults to shown. Inside the modal picker it always starts hidden and is never written back, so there the double-click is the only gesture that reaches a preview until the toolbar's editor-panel toggle is pressed — and in a save-mode picker, where the path field names the save target rather than a place to navigate to, submitting it never opens a preview at all. Four gestures close one: the bar's own close button, opening a text file in the same panel, a root switch, and the toolbar's editor-panel toggle. The first three leave the panel showing the text editor; the last settles the text buffer, hides the whole panel and drops the preview together. Layout STL Preview Pane Preview Bar Location Label — the root's display name and the root-relative path, ellipsized, with the full string as its hover title. Triangle Count Badge — an outlined badge rendered only once a load has reported a count, and cleared again at the start of every new load. The number is formatted for the app locale. Scene ▾ Menu — the shared display-options dropdown, carrying one checkbox here, Origin axes. View ▾ Menu — the shared RenderingCanvas Tool Bar, bound to this pane's canvas. Transform Button — shows and hides the Transform section; it reads primary-coloured while the section is open, and starts off on every mount. Close Button — a round close icon titled Close preview. Transform Section — rendered only while the Transform button is on. Header Row — a Transform caption and a Save button. Save stays disabled until a load has published a transform key, and shows a loading state while the write is in flight. General Transform Editor — the standard transformer editor, scrolling inside a capped height so the canvas keeps most of the pane: Scale numeric field. Rotation sub-transformer card — Rotation axis as three components with a normalize button, Angle in degrees, and Pivot in mm. Translation sub-transformer card — a Translation caption over three mm components. A caption naming the composed transform as T × R × scale × I. Every field here commits on blur or on Enter, one write per field. Failure Text — with no transform key held, the section reads “Failed to load STL preview.” in place of the editor. Canvas Body Rendering Canvas — fills the rest of the pane. Loading Overlay — a centred spinner over a dim, click-through wash. The previously loaded model stays visible beneath it rather than being cleared. Error Banner — pinned to the foot of the canvas, carrying the failed load's message. Loading a Preview One request path serves every trigger: the canvas reporting a connection id, and any change to the root or the relative path. Each request clears the banner and the triangle badge, raises the spinner, and posts the named root and the relative path to show. Server side, the controller resolves the root name, re-combines it with the relative path, refuses a result that is not a descendant of that root, and refuses a path that does not exist. The read itself runs on a thread-pool task rather than the request thread, and the format is sniffed from the file's first two lines rather than from its extension — ASCII and binary STL both load. The file is opened for shared read and write, so a load does not lock it against other readers. A successful read builds the native topology, commits it into the connection's slot, and only then touches the engine: the displayee is re-pointed at the new composition, the camera is reset to the engine's home view and the render cache cleared, and the geometry the commit replaced is disposed afterwards, so the render thread never spends a frame on a dead reference. The response carries the triangle count, the bounding box, the connection's origin-axes flag and the transform key. The pane reads all of those except the bounding box, which it ignores — the bounding-box readout a reader sees belongs to the STL File Control's info dialog, not to this pane. A rejected load — unknown or unavailable root, a path escaping the root, a missing file, an unreadable file — answers a non-2xx status carrying the server's message, and the shared response helper folds the status into the text; that composite is what the banner shows. The message itself is passed through as the server wrote it: unlike the File Explorer's own endpoints, this controller runs no root-prefix scrub over an exception message, so a read or write that fails down in the filesystem layer can surface a server path in the banner. Cancelling a Load Cancellation is the pane's defining behaviour: clicking down a folder of large STLs does not stack multi-second reads behind each other, and the tree stays fully interactive throughout. Three mechanisms compose: A monotonic show token in the pane. Every request takes the next number; a response arriving under a stale number is discarded, and the spinner is lowered only by the newest request. Without it the slower of two racing round-trips would win the badge. An abort controller in the pane. Each request aborts the previous one's controller before issuing its own, and swallows the resulting abort error. The same controller is aborted when the pane unmounts. Supersede in the preview service. Before reading anything the controller asks the service to supersede the connection, which cancels whatever load is still running and installs a fresh cancellation source. That source doubles as the commit ticket. The request then reads under a token linked from the ticket and from the request-aborted token, so a browser abort and a newer selection cancel the same read. The read is cooperatively cancellable rather than interruptible: the STL reader checks the token once every 4096 triangles, and once every 4096 lines of the pre-scan an ASCII file needs, which bounds the latency to a few thousand parses rather than a whole file. The commit is gated on the ticket. A load that finishes after a newer one superseded it is refused, disposes the geometry it has just built, and answers HTTP 200 with a canceled flag; the pane drops that response without touching the badge or the banner, and lowers the spinner only when no newer request has taken the pane over in the meantime. The Rendering Connection The pane embeds one rendering canvas, so it opens its own SignalR connection to /renderingHub and the server gives that connection its own display engine — a second live engine beside the host page's canvas whenever the preview is running inside the modal picker. See Rendering Canvas on Web Service Application for the transport itself. The connection id is the key for everything on the server side: the display engine, and the preview service's per-connection slot. The canvas re-emits it after every automatic reconnect, and the pane answers by re-issuing the show — which is what restores the preview after a connection drop. The reconnected slot starts empty, so the pane re-pushes its own Origin axes preference whenever the server's answer disagrees with it. The pose is not restored: every commit mints a fresh identity transform. Release runs off the connection's death rather than off an explicit teardown call. Closing the preview unmounts the pane, which aborts the in-flight fetch and disconnects the canvas; the hub's disconnect handler disposes the engine and raises its engine-removed event; the preview service's subscriber then cancels any load still running, disposes the STL topology and the origin-axes drawing, and withdraws the transform key. That subscriber exists because a display engine disposes only itself — never the displayee it was pointed at. The clear endpoint performs most of that detach on demand — it cancels the load in flight, empties the canvas, disposes the topology and withdraws the transform key — but it keeps the connection's slot registered, with its origin-axes drawing and flag intact for the next preview; only the connection's death frees those. It is also the one entry in this surface that ships without a caller in the SPA. Server-Side Composition The slot a connection owns holds a small display graph rather than a bare mesh: NativeTopoStl3d — the native topology built from the file's triangles, and one of the two objects here that have to be disposed by hand. TransformationWrapper — wraps that topology and carries the pose matrix. CoordinateDrawing — the origin axes, created on first enable and kept across file switches, because the flag is a per-connection viewing preference rather than a property of the file. It is the other hand-disposed object, and only the connection's death frees it. DispList — the composition assigned to Displayee: the axes drawing, when shown, followed by the wrapper. GeneralTransform — the pose the Transform section drives. Stl is not among them. The reader's output is a local of the show request, alive only long enough for the native topology to copy its triangles into its own buffer and for the response to report the triangle count and the bounding box; the save path then mints a second one out of the topology's own snapshot, and it is that second object the save transforms and writes. The committed topology always holds the file's as-loaded triangles. The editor's pose lives only in the wrapper, which is why it can be re-applied, reset or saved repeatedly without drift. Transform and Save Each committed load registers a fresh GeneralTransform — identity, and a new object rather than a reset one — in the server's keyed object store, and returns its key. The pane hands that key to the standard general-transform editor, the same component and the same REST surface the Transformer panels use; there is no preview-specific transform schema. After every committed edit the pane posts apply-transform, which re-reads the transform's matrix into the display wrapper and clears the render cache. That is display only — the file is untouched. Save asks for confirmation naming the root-relative path, then bakes. The service snapshots the native triangles under the topology's own dispose lock, multiplies them by the current matrix and writes the result over the previewed file as a binary STL, so an ASCII source is rewritten in binary form. Because the shown topology keeps the as-loaded triangles and the editor keeps its values, screen and disk agree afterwards — both are the original geometry times the current matrix — and saving twice with the same values rewrites the same file rather than compounding the pose. Resetting the editor's fields returns to the as-loaded pose. A save that finds the topology already disposed by a newer selection reports that it was superseded instead of writing. On success the pane raises a toast and the File Explorer re-lists the containing folder, so the row's size and modified columns catch up. Nothing else is refreshed: a StlFile geometry elsewhere in the project that references the same path keeps the triangles it already loaded. Switching files re-mints the transform — a new key, an identity pose, and an editor that re-reads cleanly because the key changed. The old key is withdrawn from the keyed store on replacement, on clear and on connection death; the two derived keys the editor mints beneath it for the rotation and translation sub-transformers are not withdrawn with it. Endpoints Every entry is a POST under /api/stl-preview, addressed by the rendering connection id. The four that touch the canvas resolve the display engine through the non-creating lookup, so a disconnected id cannot orphan a fresh engine; save needs no engine at all and writes straight from the slot. Path Body Purpose show/{renderingConnectionId} { rootName, relFile } Supersede, read, commit, re-point the engine. Answers the triangle count, the bounding box, the origin-axes flag and the transform key — or a canceled flag. set-coordinate/{renderingConnectionId} a bare boolean Show or hide the origin axes. With nothing on the canvas yet it stores the flag for the next commit. apply-transform/{renderingConnectionId} none Re-read the transform's matrix into the display wrapper. save/{renderingConnectionId} none Bake the matrix into the geometry and overwrite the file. clear/{renderingConnectionId} none Cancel the load in flight, empty the canvas, free the STL geometry; the slot and its origin-axes drawing survive. rootName is one of the three named roots — the admin directory, the loaded project directory and the shared resource directory — resolved server-side; the project root is unavailable until a project is loaded. Addressing is root-relative in both directions and the absolute path is formed and kept on the server; the unscrubbed error text noted above is the one place it can escape. The Text Buffer Underneath Opening a preview does not disturb the text editor beneath it. There is no flush, no discard prompt and no reload: the loaded path, the buffer, its saved snapshot and its dirty mark are all left as they were, and the bar's close button brings them straight back, dirty star included. Clicking a text file while a preview is open closes the preview first and then loads that file through the editor's normal open path, which settles the outgoing buffer the way any file switch does. Two consequences follow from the buffer staying live. The toolbar's editor-panel toggle remains reachable while the preview is up, and it settles the buffer before hiding the panel — so a dirty buffer in manual mode raises its discard confirm at that point, even though the visible pane is a 3D canvas. And an auto-save debounce armed just before the preview opened still fires underneath it. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/StlPreviewPane.vue — this pane: the bar, the Transform section, the canvas body with its overlay and banner, the show token and abort controller, and the optimistic origin-axes toggle. wwwroot-src/src/components/FileExplorer.vue — the sole host: the preview slot in the editor slave panel, the extension test and the three opening gestures, the pinned root, the close paths, and the folder refresh after a save. wwwroot-src/src/components/widgets/FileExplorerDialog.vue — the modal wrapper, whose picker props are what leave the editor panel hidden inside the picker. wwwroot-src/src/pages/FileExplorerPage.vue — the routed host at /util/file-explorer. wwwroot-src/src/api/stlPreview.ts — the typed wrapper over the five endpoints, the result shape, and the abort signal threaded into show. wwwroot-src/src/api/http.ts — the shared response helper that wrapper uses: a non-2xx throws an error whose text is the status followed by the server's message, while a 200 body carrying success: false reaches the caller as data, which is what lets the canceled answer be ignored silently. wwwroot-src/src/components/RenderingCanvas.vue — the connection the pane owns, its reconnect loop and the re-emitted connection id. wwwroot-src/src/components/RenderingCanvasToolBar.vue — the View ▾ menu in the bar. wwwroot-src/src/components/widgets/DisplayOptionsMenu.vue — the Scene ▾ dropdown; the pane passes one checkbox group and no label, so the button falls back to the localized “Scene”. wwwroot-src/src/components/topo/GeneralTransformEditor.vue, wwwroot-src/src/components/topo/StaticRotationEditor.vue and wwwroot-src/src/components/topo/StaticTranslationEditor.vue — the Transform section's editor and its two sub-transformer cards. wwwroot-src/src/components/widgets/NumericInput.vue and wwwroot-src/src/components/widgets/Vec3Input.vue — the fields inside them, committing on blur or Enter. wwwroot-src/src/api/transformer.ts, wwwroot-src/src/api/geometry.ts and wwwroot-src/src/api/index-service.ts — the standard transform surface those editors write through. wwwroot-src/src/i18n/en/explorer.ts — the explorer.preview.* strings: the close title, the failure text, Origin axes, Transform, and the save-confirm dialog. wwwroot-src/src/i18n/en/geom.ts — the pluralized triangle-count phrase in the badge. wwwroot-src/src/i18n/en/topo.ts and wwwroot-src/src/i18n/en/widgets.ts — the transform-editor captions, and the Scene and View menu labels. Disp/StlPreviewController.cs — the five endpoints, the root resolution and descendant check, the off-thread read, the commit-then-swap ordering, the canceled answer, and the failure replies that pass an exception message through unaltered. Common/FileExplorerController.cs — the root-prefix scrub over exception text that the File Explorer's own endpoints apply and this surface does not share. Disp/StlPreviewService.cs — the per-connection slot: supersede and the commit ticket, the display composition, the origin-axes flag that survives file switches, the bake-and-write save, and the engine-removed handler that frees everything. Disp/RenderingService.cs — the per-connection engine store, the non-creating lookup HTTP endpoints must use, and the engine-removed event. Disp/RenderingHub.cs — the hub whose disconnect disposes the engine and raises that event. Common/NamedRootResolver.cs — the three named roots and their availability rules. Common/IndexService.cs — the keyed object store the transform is published in. Mech/Topo/GeneralTransformController.cs — the standard transform endpoints, including the two that index the rotation and translation sub-transformers under derived keys. HiAPI Engine HiGeom/Geom/Stl.cs — the reader: content-sniffed ASCII / binary detection, the cancellation check every 4096 triangles or pre-scan lines, and the binary writer the save uses. HiDisp/Geom/Topo/NativeTopoStl3d.cs — the native topology, and the locked triangle snapshot the save takes, which answers nothing once the topology has been disposed. HiDisp/Disp/Treat/TransformationWrapper.cs — the display-time pose applied to that topology. HiDisp/Disp/Flag/CoordinateDrawing.cs — the origin-axes drawing. HiDisp/Disp/DispList.cs — the one- or two-element composition the engine is pointed at. HiDisp/Disp/DispEngine.cs — the engine: its displayee, its cache clear, its home view, and a dispose that frees the native engine alone. HiMech/Mech/Topo/GeneralTransform.cs — the pose model, its uniform scale and its two sub-transformers. See Also File Explorer — the one screen that mounts this pane, and the editor column it takes over STL File Control — the geometry editor whose file picker is where this preview is most often met, and the surface that owns the bounding-box readout this pane does not show RenderingCanvas Tool Bar — the View ▾ and Scene ▾ menus the preview bar embeds Rendering Canvas on Web Service Application — the hub connection the pane opens, and the engine-removed event that frees the preview's native geometry"
  },
  "anatomy/widget/index.html": {
    "href": "anatomy/widget/index.html",
    "title": "Widgets | HiAPI-C# 2025",
    "summary": "Widgets The reusable controls that pages embed rather than own. Each page here documents one control — most of them under the SPA's components/widgets/ directory — so a reader who meets the same control on four screens reads about it once. A control earns a page here when more than one screen embeds it. A control that only ever appears on one screen is documented on that screen's page instead. Ordered by how widely each control is embedded, most-embedded first. Pages Numeric Input — The single-value numeric field every editor embeds: blur-and-Enter commit, inclusive bounds, and the Infinity and NaN spellings; the most widely embedded control in the app Object Management Menu Button — Load / Save / Paste / XML for any object that can produce an XML source RenderingCanvas Tool Bar — The View ▾ camera-preset menu every 3D canvas docks Vec3dControl — The three-component vector editor: per-axis and single-field text modes, with local special-value handling Polar Resolution 2D Panel — The editor for PolarResolution2d, embedded by the two holder editors that tessellate a revolved profile; the one control here with no SPA widget of its own Mat4dControl — The sixteen-cell 4x4 matrix grid, with its Identity and Invert events See Also Numeric Input — the single-value numeric field the other editors on this shelf are built beside Conventions — the file-path and numeric-value contracts two of these controls implement App Shell — the frame these controls are embedded inside"
  },
  "anatomy/widget/mat4d-control.html": {
    "href": "anatomy/widget/mat4d-control.html",
    "title": "Mat4dControl Component | HiAPI-C# 2025",
    "summary": "Mat4dControl Component Mat4dControl edits and displays a 4x4 transform matrix. It is an embedded widget with no route and no Control-Tree node of its own, reached only through the editor that hosts it. Key Model The persisted model is Mat4d, exposed over /api/Mat4d by Widget/Mat4dController.cs. The widget's own model is a plain array of sixteen numbers, exported as type Mat4 from wwwroot-src/src/components/widgets/Mat4Input.vue. The layout is column-major, matching the backend Mat4d: cell (row, col) resolves to index col * 4 + row, so indices 0 to 3 are the first column and 12 to 15 the translation column. wwwroot-src/src/api/transformer.ts states the same column-major contract on the wire. A model shorter than sixteen numbers, or not an array at all, is padded out with zeros before display, and a longer one is truncated to sixteen. The widget carries no key and calls no endpoint. Its host, wwwroot-src/src/components/topo/StaticFreeformEditor.vue, binds it with v-model and persists each change through updateStaticFreeformMat from wwwroot-src/src/api/transformer.ts, which posts the whole sixteen-number array to /api/StaticFreeform/Update; Mech/Topo/StaticFreeformController.cs rejects a payload that is not exactly sixteen elements. The props are modelValue, disable, readonly, identity (on by default) and invert (off by default), and the emits are update:modelValue, identity and invert. disable both disables the cells and dims the whole block. Layout Mat4dControl Matrix Grid — four rows of four numeric cells, each cell right-aligned Identity Button — present when the identity flag is set, which is the default Invert Button — present only when the invert flag is set The cells and both buttons are inactive while the control is disabled or readonly. Feature Single input mode The grid of sixteen cells is the only editing surface, and each cell shows the full precision of its number with no rounding for display. Matrix operations Identity — the button raises an identity event and writes nothing itself; the host supplies the matrix. StaticFreeformEditor pushes its own identity constant through updateStaticFreeformMat. Invert — the button raises an invert event and computes nothing itself. StaticFreeformEditor calls invertStaticFreeformMat, which posts to /api/StaticFreeform/InvertMat and feeds the sixteen numbers that come back into the model. Commit and special values Each cell commits on blur or Enter, and the widget emits the entire sixteen-number array rather than a single index. An unparseable cell reverts to its previous value, an empty cell becomes 0, and a cell whose parsed value is unchanged emits nothing. Formatting and parsing are local to the component: Infinity and -Infinity are shown and parsed as literal text, while NaN and a missing cell both display as 0, so NaN is not round-tripped. Source Code Path See HiNC App Anatomy for git repository links. wwwroot-src/src/components/widgets/Mat4Input.vue — the widget itself: the column-major sixteen-cell grid, the Identity and Invert buttons, and the local format, parse and commit helpers wwwroot-src/src/components/topo/StaticFreeformEditor.vue — the host, and the full binding contract in one place: v-model, the two button flags, @update:model-value, @identity, @invert wwwroot-src/src/api/transformer.ts — updateStaticFreeformMat and invertStaticFreeformMat Mech/Topo/StaticFreeformController.cs — the backend behind those two endpoints: Update takes a sixteen-element array, InvertMat returns the inverted sixteen numbers Widget/Mat4dController.cs — the /api/Mat4d REST surface: New, NewWithValue, Get, Update, UpdateAt, ParseAndUpdate, SetIdentity, Transpose and Inverse. The SPA reaches none of them; the widget's host persists through the StaticFreeform endpoints instead. wwwroot-src/src/i18n/en/widgets.ts — the Invert label and both button tooltips under widgets.matInput See Also Vec3dControl Component — the sibling numeric-geometry editor, and the one a reader usually wants next Numeric Input/Output — why NaN and the infinities are text on the wire, and why NaN does not survive this grid"
  },
  "anatomy/widget/numeric-input.html": {
    "href": "anatomy/widget/numeric-input.html",
    "title": "Numeric Input | HiAPI-C# 2025",
    "summary": "Numeric Input NumericInput is the single-value numeric field the rest of the web application embeds. It has no route and no Control-Tree node of its own: it is reached only through the editors that host it, and those span the equipment and mission trees, the Tool House tool editors, the Legacy Controller tabs, the transformer and geometry editors and the Preference menu. The rule for carrying NaN and the infinities across the JSON boundary is stated once in Numeric Input/Output; this page is the widget that implements the client end of it. The Binding Contract The widget owns no value. It holds the raw text the user is typing and nothing else, and every committed number is handed straight back to the host, which decides what to persist and when. Prop Meaning modelValue number, null or undefined — the value to show label the field's label, inside the outline; floats to the top of it once the field has content hint text below the field unit a display-only suffix inside the field readonly / disable passed through to the underlying field min / max inclusive bounds, checked on commit allowEmpty whether a blank field commits null; defaults to on hideBottomSpace stop holding space below the field; a hint or message still renders when there is one rules extra validation functions over the raw text Two events leave the widget. update:modelValue carries a number or null. null is a real outcome rather than an error signal, so a host that must not receive one either turns allowEmpty off or filters what it gets: the cutter section panel returns early on null so that clearing a field cannot write a zero into the profile, and the graphic-cache menu rejects null and every non-finite value before it calls the server. parseError carries the raw text that failed to parse. No shipped host listens for it, so a parse failure is visible only as the message under the field. Commit Semantics Typing changes nothing but the text in the box. The commit runs on blur and on Enter, and on nothing else — there is no per-keystroke emit, no debounce and no timer. The underlying control is a plain text field rather than a browser number input, so there is no spinner, no step and no keystroke-level filtering: any text at all may sit in the box until the field is committed. A commit parses the text once and then takes one of three exits. On success the error strip is cleared, update:modelValue is emitted, and the box is rewritten from the parsed number. On text that does not parse, parseError is emitted and a message appears. On a number outside the bounds, a message appears. Neither failing exit emits update:modelValue, and neither rewrites the box. Enter commits without moving focus, so the value is committed again when the field is finally left. The widget carries no equality guard — it emits whenever the text parses and passes the bounds, whether or not the result differs from modelValue — so that second commit reaches the host as a second, identical write. Here the widget parts company with the vector and matrix editors, both of which compare against the model before emitting. Bounds and Special Values min and max are inclusive and are enforced inside the widget, before anything is emitted: a number below min or above max is refused and the host never sees it. The bounds apply to finite numbers only. Infinity, -Infinity, NaN and the null a blank field produces all skip the range check, so a field declared with a min of 0 still commits -Infinity and NaN. Where that matters, the host filters what it receives. Typed Committed Shown afterwards Infinity in any case, or ∞ Infinity Infinity -Infinity in any case, or -∞ -Infinity -Infinity NaN in any case NaN (empty) blank, allowEmpty on null (empty) blank, allowEmpty off nothing — parse error the blank stays anything JavaScript's Number() reads as a finite number that number its default string form anything else nothing — parse error the rejected text stays Number() is the whole numeric parser, so exponent notation and the 0x, 0b and 0o integer literals are accepted alongside ordinary decimals, while a thousands separator is not. Its result must also come back finite to be accepted, so a literal that overflows the double — 1e400 — is a parse error rather than a second route to Infinity. The two spellings at the head of the table are the only way to reach one. Two consequences follow from NaN and null sharing the empty box. A NaN arriving from the server is indistinguishable from a blank field; and because a blank field commits null under the default, merely focusing such a field and leaving it replaces the NaN with null. With allowEmpty turned off the same field instead fails to parse on every blur until something is typed into it. The infinity spellings the widget writes and reads are the same strings the API layer puts on the wire for a non-finite number — see Numeric Input/Output. The widget itself never touches the wire: it emits a JavaScript number, and converting a non-finite one into its string form belongs to the host's API module, as wwwroot-src/src/api/mission.ts does for the mission commands. That conversion is not symmetric for NaN: the mission module writes all three strings but recognises only the two infinity spellings when reading, so a NaN returned by the endpoint becomes the caller's supplied default instead. Unit Suffix and Precision unit is rendered as a suffix inside the field, to the right of the text. It is decoration only: it is not part of the editable text, it is not parsed, and no unit conversion happens anywhere in the widget — the number committed is in whatever unit the host's model already uses. Hosts pass plain unit text, mm and deg being the common ones, alongside mm/min, rpm, N, °C and MB. There is no precision, decimals or step prop. A value is displayed through JavaScript's default number-to-string conversion, so it shows at full precision and switches to exponent notation at the magnitudes where that conversion does. Rounding, where a host wants it, is the host's own: the graphic-cache current-size field rounds in its commit handler, after the widget has handed the number over, while the two limit fields in the same menu send what they were given. Validation Messages Three messages can appear under the field, and all three are built inside the component in English: Invalid number: \"…\" quoting the rejected text, Must be ≥ … and Must be ≤ … quoting the bound. They are not keys and appear in no i18n bundle, so they do not follow the application's language setting — unlike label and hint, which hosts pass in already translated. rules is a separate mechanism and differs in three ways: its functions receive the raw display text rather than the parsed number, they run on the underlying field's own validation pass — as the text changes, and again when focus leaves — rather than inside the commit, and they do not gate the commit: a value failing a caller rule is still parsed, still bounds-checked and still emitted. While the widget's own message is showing, it also masks the rule's. No shipped host passes rules, and none fills the append slot, so both are available rather than exercised. hideBottomSpace is the opposite — it is among the most-passed props on the widget, set on nearly every field the SoftNc controller panels, the spindle contour editor and the fluting span list drop into a table cell. When the Box and the Model Disagree A rejected commit leaves the typed text in the box. That text is replaced only when modelValue changes to something whose formatted form differs from what is showing; the widget does not revert on its own. That is the second thing the vector and matrix editors do that this one does not: both reinstate the last valid value the moment a cell fails to parse. Two situations follow, and both put a number on screen that was never stored: A number outside the bounds, or text that does not parse, stays in the box under its error message. Nothing restores it until the host pushes a different value. A commit the host accepts and the server then refuses leaves the box showing the refused number unless the host had already applied it locally, because assigning the unchanged value back to modelValue is not a change and moves nothing. The message is equally persistent: it is cleared only by the next successful commit, so it can outlive the value that caused it and sit under a field the host has since repopulated. Layout Numeric Input Field Label — the host's label, positioned inside the field's outline: on the input line while the field is empty and unfocused, floated to the top of the outline once it has a value or the focus; absent when none is given Text Box — one line, free text until committed Unit Suffix — the host's unit, inside the field at the right; display only Append Slot — an optional trailing slot for a host-supplied control Bottom Strip — the host's hint, replaced by the validation message while the field is in error. hideBottomSpace stops space being held below the field but does not suppress the strip: a hint or a validation message still renders, and with nothing reserved for it, it grows the field instead of filling a gap already left below. Source Code Path See HiNC App Anatomy for git repository links. Web Application HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/widgets/NumericInput.vue — the widget: the raw-text buffer, the local format and parse pair, the blur-and-Enter commit, the inclusive bounds check that skips non-finite values, and the three English validation strings. wwwroot-src/src/components/preference/GraphicCacheMenu.vue — a compact host of three instances, one of them bounded by the values of the other two; every handler rejects null and non-finite numbers, and the current-size handler is the one that rounds before sending. wwwroot-src/src/components/controlTree/toolhouse/CutterSectionPanel.vue — a host that returns early on the null a cleared field emits, so blanking a cutter dimension cannot write a zero. wwwroot-src/src/components/spindle/SpindleContourEditor.vue — a host that turns allowEmpty off and keeps its own draft copy of the contour points around the blur commit. wwwroot-src/src/api/mission.ts — the module that turns a committed non-finite number into the Infinity, -Infinity or NaN string the endpoint takes, and reads the two infinity spellings back; a NaN arriving from the endpoint falls through to the caller's default instead. See Also Numeric Input/Output — the cross-boundary rule this widget implements the client half of, and how the three numeric inputs differ from one another Widgets — the other controls that pages embed rather than own Editing Contract — the branch that embeds this field most heavily, and the commit rules its panels inherit from it"
  },
  "anatomy/widget/object-management-menu-button.html": {
    "href": "anatomy/widget/object-management-menu-button.html",
    "title": "Object Management Menu Button | HiAPI-C# 2025",
    "summary": "Object Management Menu Button The menu button represent the target object with getter function and setter function. The target object generally is IMakeXmlSource. the target object with getter function and setter function is such like: object TargetObject{get=>TargetObjectGetter?.Invoke();set=>TargetObjectSetter?.Invoke(value);} Func<TargetObject> TargetObjectGetter{get;set;} Action<TargetObject> TargetObjectSetter{get;set;} The target object has the following functions: File Save/Load See GUI File Path Assignment Object Copy/Paste Editor Panel Mode Selection GUI (user-friendly) XML Get XML by IMakeXmlSource with exhibitionOnly true. Set XML by XFactory. If the target object is not IMakeXmlSource, then the XML Editor Panel Mode should not appear. The other functions are still buildable. On XFactory functions, set enableRebase to true (which is the default). The rebase mode resolves relative file paths from the file's own directory, preventing silent inner exceptions. Layout Object Management Menu Button Load Button Load Resource Button Save As Button (splitter) Copy Button (with hotkey support if the Object Management Menu Button is focused) Paste Button (with hotkey support if the Object Management Menu Button is focused) (splitter) GUI Ratio Button XML Ratio Button Tip Since the Object Management Menu Button has special meaning, use icon instead of text label. Do not use icon on the other child buttons. The icons gains nothing but hard to keep style to the full application. If the model is selected, show a different style (may be color) on the menu button. The model should contain a ResourceDirectory property. Do not show Load Resource Button if Resource directory not explicitly gave. Copy & Paste Object Copy/Paste (i.e. Select/Set or Duplicated-Set) Copy (i.e. Select) Set the model to UserService.SelectedItem. Paste Set UserService.SelectedItem to the model. Set by reference is default. Apply Duplicated-Set if explicitly required. While a object is copied (selected) here, it can also be paste (drag) to: Text editor Use IMakeXmlSource.MakeXmlSource(string, string, bool) with exhibitionOnly false and the argument (baseDirectory and relFile) from object's host to paste the text, it should be the same text content by the host XML output. File browser Use IMakeXmlSource.MakeXmlSource(string, string, bool) with exhibitionOnly true, baseDirectory destination folder, relFile destination file name (maybe xxx.class-name) to paste the file. Show message when paste action success or failed. See Handle Message and Exception. If the data type is not matched, show the un-matched message. Editor Panel Mode Ratio Button The Editor Panel switched by the Editor Panel Mode Ratio Button. The BaseDirectory and RelFile properties should exist. Use the RelFile property if the object's host has the corresponding property like XXXFile. The Apply action should be well-set. Include SetFileDelegate from Gen function. The last argument should also be delivered by the host. So there must exist an property to pass the argument. XML Editor Panel Layout XML Editor Panel Cancel Button Apply Button XML TextArea Shows error message if the xml-parsing or object creation failed on XML Editor Panel Apply Button applied. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/widgets/ObjectManagementMenuButton.vue — Quasar dropdown + XML editor dialog. Emits update:modelKey, objectLoaded, objectPasted, xmlApplied, error. Supports Ctrl+C / Ctrl+V. wwwroot-src/src/api/objectManagement.ts — typed wrapper over /api/ObjectManagement/*. Widget/ObjectManagementController.cs — REST endpoints: Load, LoadResource, SaveAs, Copy, Paste, GetXml, ApplyXml, SupportsXml, GetSelectedItem. See Also File Explorer — reaches the same project / resource folders through a different endpoint family"
  },
  "anatomy/widget/polar-resolution-2d-panel.html": {
    "href": "anatomy/widget/polar-resolution-2d-panel.html",
    "title": "Polar Resolution 2D Panel | HiAPI-C# 2025",
    "summary": "Polar Resolution 2D Panel The model is PolarResolution2d: a linear step in millimetres plus an angular step, carried in radians and edited in degrees, that together tessellate a revolved shape into an STL mesh. It is edited on a tool holder and nowhere else, through the Cylindroid holder's Resolution section. Layout Holder Resolution Section Resolution Hint Caption — names the STL tessellation used for display and collision meshing Linear Resolution (mm) Input Field Angle Resolution (deg) Input Field There is no enable checkbox and no null state: both fields are always editable, and each commits on blur or Enter, and only when both values are greater than zero. Feature An edit republishes a whole new carrier instead of mutating the current one. A holder's PolarResolution2d setter swaps the holder's solid for one born with the new value and disposes the old one, and skips a value-equal reassignment; the same swap happens server-side inside SetPolarResolution, which then clears the holder's cache. A null host model means the resolution applied the default value: PolarResolution2d is a snapshot of the solid's identity, and a null carrier lets a parametric geometry apply its own default. Nothing on this surface can produce that state. The service reports a null resolution as 0 mm / 0 deg, the two fields display those zeros, and the commit guard then blocks any write until real numbers are typed. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): no standalone widget. The resolution is edited on the Cylindroid holder's Resolution section, at the Control-Tree id toolhouse/tool-{id}/holder/resolution and the route /tool-house/:toolId/holder/resolution. A Freeform holder grows no sections here; its Holder panel shows a hint saying the geometry is edited elsewhere. wwwroot-src/src/components/controlTree/toolhouse/HolderSectionPanel.vue — the section === 'resolution' branch: the two number fields, seeded from Get and committed on blur / Enter. wwwroot-src/src/components/controlTree/toolHouseItemTypes.ts — registers that panel as the HolderSection item type and grows the Resolution node only for a CylindroidHolder. wwwroot-src/src/components/controlTree/toolhouse/ToolHolderPanel.vue — the Holder stem above it, whose holder-type selector decides which sections appear. wwwroot-src/src/api/cylindroidHolder.ts — PolarResolutionDto (linear_mm / angle_deg) and setCylindroidHolderResolution. wwwroot-src/src/router/treeRoutes.ts — maps the holder's section ids onto the Tool House route params. wwwroot-src/src/i18n/en/toolhouse.ts — the two field labels and the tessellation hint caption. Mech/CylindroidHolderController.cs — POST /api/CylindroidHolder/SetPolarResolution, which rejects a non-positive value, assigns a fresh PolarResolution2d and calls ClearCache(); GET Get reports a null resolution as 0 / 0. See Also Cylindroid Holder Panel — the holder editor that embeds this panel to tessellate its profile Freeform Holder Panel — the other holder editor that embeds it"
  },
  "anatomy/widget/renderingcanvas-tool-bar.html": {
    "href": "anatomy/widget/renderingcanvas-tool-bar.html",
    "title": "RenderingCanvas Tool Bar | HiAPI-C# 2025",
    "summary": "RenderingCanvas Tool Bar The RenderingCanvas Tool Bar is the camera-preset menu that every 3D canvas in the app carries. It holds no engine of its own: it takes a canvas prop and calls that component's exposed setView(name), which invokes the SetView hub method, and the hub is what drives the per-connection DispEngine. View Menu The bar is a single View ▾ menu. Its seven entries, in shipped order, are Isometric, Front, Back, Right, Left, Top and Bottom. The engine also understands a home view and RenderingCanvas.vue exposes setViewToHomeView, but this menu does not offer it. Entry API Method Isometric SetViewToIsometricView() Front SetViewToFrontView() Back SetViewToFrontView() + TurnBackView() Right SetViewToRightView() Left SetViewToRightView() + TurnBackView() Top SetViewToTopView() Bottom SetViewToTopView() + TurnBackView() Back View Implementation Back / Left / Bottom views are composed by first calling the corresponding forward-view method (SetViewToFrontView / SetViewToRightView / SetViewToTopView) and then invoking TurnBackView() to flip the camera about the view plane, composed in the hub's SetView switch. Canvas Binding The tool bar declares exactly one prop, a nullable canvas, typed structurally as an object exposing setView(v: string): Promise<void> rather than as the RenderingCanvas component type. Every entry calls it optionally, so a tool bar with no canvas bound still opens and each entry is a no-op. The preset names travel to the hub untranslated; only the row labels are localized, from the widgets.canvas.* keys. Scene Menu Pages that sit next to a RenderingCanvas surface a per-page Scene ▾ menu button — the DisplayOptionsMenu component, labelled from widgets.canvas.scene because no caller overrides the label. It chooses what the 3D scene draws (solids, coordinates, display aids), as distinct from the camera-oriented View ▾ menu beside it. The layout (header + checkboxes + radio rows) is shared across four callers — the Execution page's extended tool bar, the General Setup equipment panel, the Tool House setup panel and the STL preview pane — so it is implemented once as a generic, schema-driven component. Schema Each dropdown consumes a DisplayGroup[] array. A group has an optional header and a flat list of items: { kind: 'check', label, modelValue, disable?, onUpdate } — a checkbox row. { kind: 'radio', label, groupValue, value, disable?, onUpdate } — a radio row; rows sharing a groupValue behave as one group, each row bound to its own value. The component is generic over the radio value type, so RenderingMode / HolderRenderingMode / etc. stay fully typed at the call site. Besides groups it accepts label, disable, title, minWidthPx (default 220), size (default sm), contentClass and compact. compact is a tighter-than-dense row mode, used by the General Setup and Tool House panels for their long option lists; the General Setup, Tool House and Execution callers pass content-class=\"bg-white\" to opt out of Quasar's transparent menu. HiNC-2025-webservice (Quasar CLI SPA) wwwroot-src/src/components/widgets/DisplayOptionsMenu.vue — the shared <q-btn-dropdown> + <q-list> implementation behind four of the app's five Scene menus. The Controller viewer is the exception: wwwroot-src/src/components/controller/ControllerExtendedToolBar.vue builds its Scene dropdown inline against the same /api/rendering-flags surface. Callers (each reads a DisplayGroup[] computed from its page-local state and forwards onUpdate to its existing handlers): wwwroot-src/src/components/execution/ExecutionExtendedToolBar.vue wwwroot-src/src/components/mech/EquipmentSetupPanel.vue wwwroot-src/src/components/toolhouse/ToolHouseSetupPanel.vue wwwroot-src/src/components/StlPreviewPane.vue Backends — one per caller, each a different surface: ExecutionExtendedToolBar.vue reaches /api/rendering-flags (Common/RenderingFlagsController.cs), which flips bits in ExecutionDisplayee.RenderingFlagBitArray; EquipmentSetupPanel.vue reaches /api/mech/equipment-setup-display/* (Mech/EquipmentSetupDisplayController.cs); ToolHouseSetupPanel.vue reaches /api/mech/tool-house-display/* (Mech/ToolHouseDisplayController.cs); StlPreviewPane.vue reaches /api/stl-preview/set-coordinate/* (Disp/StlPreviewController.cs). Those last three route each POST by the caller's renderingConnectionId, so the toggle lands on that canvas's own engine; the rendering-flags surface carries no connection id and acts on the project-wide ExecutionDisplayee instead. DisplayOptionsMenu.vue is UI-only; it does no REST work itself — the caller owns the onUpdate handlers, so optimistic update and error reversion stay page-local. Source Code Path See HiNC App Anatomy for git repository links. HiNC-2025-webservice (Quasar CLI SPA): wwwroot-src/src/components/RenderingCanvasToolBar.vue — the View ▾ menu. Eight callers embed it, one per canvas: wwwroot-src/src/pages/ExecutionPage.vue (teleported into the canvas panel's header, beside ExecutionExtendedToolBar), wwwroot-src/src/pages/ControllerPage.vue (beside ControllerExtendedToolBar), wwwroot-src/src/pages/MachineToolPage.vue, wwwroot-src/src/pages/MechBuilderPage.vue, wwwroot-src/src/components/mech/EquipmentSetupPanel.vue (the General Setup canvas column, mounted by wwwroot-src/src/pages/GeneralSetupPage.vue), wwwroot-src/src/components/toolhouse/ToolHouseSetupPanel.vue (mounted by wwwroot-src/src/pages/ToolHousePage.vue), wwwroot-src/src/components/StlPreviewPane.vue (the File Explorer preview pane, mounted by wwwroot-src/src/components/FileExplorer.vue) and wwwroot-src/src/components/execution/StepVolumePanel.vue (the CWE footprint canvas, teleported into its host expansion's header). Four of those sit beside a Scene ▾ menu — the Execution, General Setup, Tool House and STL preview canvases; the Machine Tool, Mechanism Builder and CWE canvases carry the View ▾ menu alone, and the Controller viewer pairs it with an inlined Scene dropdown. wwwroot-src/src/components/widgets/DisplayOptionsMenu.vue — schema-driven dropdown described above. wwwroot-src/src/components/RenderingCanvas.vue — SignalR-hosted WebSocket canvas whose exposed setView / setViewTo*View methods the tool bar calls (see Rendering Canvas on Web Service). wwwroot-src/src/i18n/en/widgets.ts — the widgets.canvas.* keys: view, the seven preset labels, and scene. Backends: Disp/RenderingHub.cs — the SetView(string) hub method that maps each preset name onto engine calls. Disp/RenderingService.cs — GetOrCreateEngine(connectionId), the per-connection DispEngine store the hub resolves against. Common/RenderingFlagsController.cs — the /api/rendering-flags surface (GET, POST update, POST batch) behind the Execution page's Scene menu and the Controller viewer's inlined one, wrapped by wwwroot-src/src/api/renderingFlags.ts. It reads and writes ExecutionDisplayee.RenderingFlagBitArray through ProjectDisplayeeService. wwwroot-src/src/api/equipmentSetup.ts, wwwroot-src/src/api/toolHouse.ts and wwwroot-src/src/api/stlPreview.ts — the typed wrappers the other three Scene menus post through. See Also Execution Page — the page whose canvas header adopts this tool bar Execution Extended RenderingCanvas Tool Bar — the run-specific controls that sit beside it Rendering Canvas on Web Service Application — the SignalR transport whose hub actually moves the camera this menu asks for STL Preview Pane — the one caller whose canvas is a single file rather than a project scene"
  },
  "anatomy/widget/vec3d-control.html": {
    "href": "anatomy/widget/vec3d-control.html",
    "title": "Vec3dControl Component | HiAPI-C# 2025",
    "summary": "Vec3dControl Component Vec3dControl edits and displays a three-component vector. It is an embedded widget with no route and no Control-Tree node of its own, reached only through the editors that host it. Key Model The persisted model is Vec3d, exposed over /api/Vec3d by Widget/Vec3dController.cs. The widget's own model is the plain { x, y, z } number triple exported as interface Vec3 from wwwroot-src/src/components/widgets/Vec3Input.vue. The widget carries no key and calls no endpoint: the host binds it with v-model plus an @update:model-value handler, and that handler does the persisting, each host on its own terms. The four transformer editors call updateVec3d from wwwroot-src/src/api/geometry.ts, which posts all three axes together to /api/Vec3d/Update, while wwwroot-src/src/components/geom/Box3dEditor.vue folds the edited triple back into a min and max pair and posts that to /api/Box3d/Update. The props are modelValue, disable, readonly, normalize, labels and textMode, and the emits are update:modelValue and normalize. labels is a three-tuple defaulting to ['X', 'Y', 'Z'], and carries units where the host has them, as in ['X (mm)', 'Y (mm)', 'Z (mm)']. textMode sets the initial mode only and defaults to false. Layout Vec3dControl Mode Toggle Button — always present; switches between the per-axis columns and the single-field text form, and is highlighted while the text form is showing X, Y and Z Input Fields — the per-axis form, three fields side by side Vector Text Field — the single-field form, standing in place of the three axis fields Normalize Button — present only when the normalize flag is set, and disabled while the control is disabled or readonly Feature Per-axis form X, Y and Z in three separate fields, each rendering every finite value at full precision. Single-field text form The form is (x, y, z). Its parser strips surrounding brackets and splits on comma, semicolon or whitespace, requiring at least three parts, and entering the text form re-syncs the field from the current value so a stale in-progress edit is discarded. Vector normalization The normalize button is opt-in and off by default, through the normalize prop. The button only raises a normalize event, and the embedding editor performs the normalization on its own owning object. wwwroot-src/src/components/topo/StaticRotationEditor.vue posts to /api/StaticRotation/NormalizeAxis, while wwwroot-src/src/components/topo/DynamicRotationEditor.vue and wwwroot-src/src/components/topo/DynamicTranslationEditor.vue call normalizeDynamicRotationAxis and normalizeDynamicTranslationAxis from wwwroot-src/src/api/transformer.ts. Commit and special values Edits commit on blur or Enter, never per keystroke, and a value is emitted only when it differs from the current model. An empty field parses to 0; any other unparseable text reverts the field to the last valid value. Formatting and parsing are local to the component: NaN renders as NaN and the infinities as Infinity and -Infinity, and the parser accepts those spellings case-insensitively as well as the ∞ and -∞ glyphs. Source Code Path See HiNC App Anatomy for git repository links. wwwroot-src/src/components/widgets/Vec3Input.vue — the widget itself: mode toggle, per-axis and single-field inputs, normalize button, and the local format and parse helpers wwwroot-src/src/api/geometry.ts — the /api/Vec3d client the transformer editors use, and the Vec3dDto shape Widget/Vec3dController.cs — the REST surface behind /api/Vec3d: New, NewWithValue, Get, Update, UpdateAt, ParseAndUpdate and Normalize. The SPA reaches Update. wwwroot-src/src/components/topo/StaticRotationEditor.vue — the full binding contract in one place: v-model, @update:model-value, the normalize opt-in and its @normalize handler wwwroot-src/src/components/topo/StaticTranslationEditor.vue — one instance, no normalize button wwwroot-src/src/components/topo/DynamicRotationEditor.vue — axis with normalize, plus pivot wwwroot-src/src/components/topo/DynamicTranslationEditor.vue — axis with normalize wwwroot-src/src/components/geom/Box3dEditor.vue — four instances (min, max, dimension, center) whose readonly state follows the current edit mode, persisted through the Box3d endpoint wwwroot-src/src/components/geom/StlFileEditor.vue — four display-only instances for the STL bounding-box pad wwwroot-src/src/i18n/en/widgets.ts — the tooltip strings under widgets.vecInput See Also Mat4dControl Component — the sibling numeric-geometry editor, and the one a reader usually wants next Numeric Input/Output — why NaN and the infinities are text on the wire, and how the three inputs differ"
  },
  "api/Hi.Cbtr.CachedTris.SweepingMode.html": {
    "href": "api/Hi.Cbtr.CachedTris.SweepingMode.html",
    "title": "Enum CachedTris.SweepingMode | HiAPI-C# 2025",
    "summary": "Enum CachedTris.SweepingMode Namespace Hi.Cbtr Assembly HiCbtr.dll Defines the mode for sweeping operations. public enum CachedTris.SweepingMode Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Auto = 0 Automatically choose the best sweeping mode. ForceLinear = 1 Force linear sweeping mode. ForceNonLinear = 2 Force non-linear sweeping mode."
  },
  "api/Hi.Cbtr.CachedTris.html": {
    "href": "api/Hi.Cbtr.CachedTris.html",
    "title": "Class CachedTris | HiAPI-C# 2025",
    "summary": "Class CachedTris Namespace Hi.Cbtr Assembly HiCbtr.dll Feature-cached triangle for CubeTree computation. public class CachedTris : IDisposable, IDisplayee, IExpandToBox3d Inheritance object CachedTris Implements IDisposable IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) DispUtil.Display(IDisplayee, Bind, Mat4d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CachedTris(NativeTopoStl3d, Mat4d, double) Ctor by the transformed stl. only available for geometry that does not contains near point or points on the same line on the same plane. public CachedTris(NativeTopoStl3d stl, Mat4d mat, double fractionTolerance) Parameters stl NativeTopoStl3d stl mat Mat4d transformation matrix fractionTolerance double fraction tolerance for the operation CachedTris(NativeTopoStl3d, NativeTopoStl3wfr, Mat4d, Mat4d, double, SweepingMode) Ctor by the swept stl. The sweeping is from the transformation of pre to cur. public CachedTris(NativeTopoStl3d tstl, NativeTopoStl3wfr tstlfr, Mat4d pre, Mat4d cur, double fractionTolerance, CachedTris.SweepingMode sweepingMode = SweepingMode.Auto) Parameters tstl NativeTopoStl3d Topo Stl tstlfr NativeTopoStl3wfr Topo Stl with fraction tolerance pre Mat4d previous transformation matrix cur Mat4d current transformation matrix fractionTolerance double fraction tolerance for the operation sweepingMode CachedTris.SweepingMode mode for the sweeping operation Properties CachedTrisPtr Native pointer of the object. public nint CachedTrisPtr { get; } Property Value nint Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box ~CachedTris() protected ~CachedTris()"
  },
  "api/Hi.Cbtr.CbtrPickable.html": {
    "href": "api/Hi.Cbtr.CbtrPickable.html",
    "title": "Class CbtrPickable | HiAPI-C# 2025",
    "summary": "Class CbtrPickable Namespace Hi.Cbtr Assembly HiCbtr.dll Pickable of CubeTree grids. public class CbtrPickable : Pickable, IGetPickable, IDisposable Inheritance object Pickable CbtrPickable Implements IGetPickable IDisposable Derived DiffAttachment UnhighlightablePickable ClStripPos Inherited Members Pickable.Pickables Pickable.mark Pickable.PickingID Pickable.GetPickable() Pickable.OnKeyDown(key_event_t, DispEngine) Pickable.OnKeyUp(key_event_t, DispEngine) Pickable.OnMouseDown(mouse_button_event_t, DispEngine) Pickable.OnMouseUp(mouse_button_event_t, DispEngine) Pickable.OnMouseMove(mouse_move_event_t, DispEngine) Pickable.OnMouseWheel(mouse_wheel_event_t, DispEngine) Pickable.Dispose() object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CbtrPickable() Initializes a new instance of the CbtrPickable class with default white color. public CbtrPickable() CbtrPickable(vec3f) Initializes a new instance of the CbtrPickable class with specified color. public CbtrPickable(vec3f rgb) Parameters rgb vec3f The RGB color for the pickable object. Properties AttachmentPriority The color and Pickable priority if several attachments occupied at the same pixel. NAN is the lowest priority. the smaller number is the lower priority. public virtual double AttachmentPriority { get; set; } Property Value double IsColorTableCovered True when this attachment's color is served by the native attachment color table, i.e. a Rgb change reaches the screen without cleaning the affected drawing caches. When false (no picking id, or the id exceeds the table ceiling) callers must keep the legacy CleanAttachedCbtrNodesDrawingCache() after a recolor. public bool IsColorTableCovered { get; } Property Value bool Rgb Color RGB. public virtual Vec3d Rgb { get; set; } Property Value Vec3d Methods CleanAttachedCbtrNodesDrawingCache() CleanAttachedNodesDrawingCache. Not thread safe with substraction process. public void CleanAttachedCbtrNodesDrawingCache() Dispose(bool) protected override void Dispose(bool disposing) Parameters disposing bool Highlight(bool) Highlight the CbtrPickable by triangles line. Only one CbtrPickable can be highlighted on a CubeTree. public void Highlight(bool b) Parameters b bool highligt or not OnMouseEnter(ui_event_type, DispEngine) Behavior on mouse enter public override void OnMouseEnter(ui_event_type e, DispEngine dispEngine) Parameters e ui_event_type event type dispEngine DispEngine display engine OnMouseLeave(ui_event_type, DispEngine) Behavior on mouse leave public override void OnMouseLeave(ui_event_type e, DispEngine dispEngine) Parameters e ui_event_type event type dispEngine DispEngine display engine ShrinkToFitNodeMap() ShrinkToFitNodeMap. Not thread safe with substraction process. public void ShrinkToFitNodeMap()"
  },
  "api/Hi.Cbtr.ConstructionDefectDisplayee.html": {
    "href": "api/Hi.Cbtr.ConstructionDefectDisplayee.html",
    "title": "Class ConstructionDefectDisplayee | HiAPI-C# 2025",
    "summary": "Class ConstructionDefectDisplayee Namespace Hi.Cbtr Assembly HiCbtr.dll Encapsulates cube tree construction defect results, including both defect data and visualization drawings. public class ConstructionDefectDisplayee : IDisplayee, IExpandToBox3d, IDisposable Inheritance object ConstructionDefectDisplayee Implements IDisplayee IExpandToBox3d IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) DispUtil.Display(IDisplayee, Bind, Mat4d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ConstructionDefectDisplayee(List<DefectNodeInfo>, IProgress<IMessage>) Ctor. public ConstructionDefectDisplayee(List<CubeTree.DefectNodeInfo> defectNodeInfos, IProgress<IMessage> messageProgress = null) Parameters defectNodeInfos List<CubeTree.DefectNodeInfo> Defect node infos from cube tree construction. messageProgress IProgress<IMessage> Progress reporter for user-facing messages. Properties DefectNodeInfos Defect node infos collected during cube tree construction. public List<CubeTree.DefectNodeInfo> DefectNodeInfos { get; } Property Value List<CubeTree.DefectNodeInfo> DefectNodesToShow Maximum number of defect nodes to show. public int DefectNodesToShow { get; set; } Property Value int HasDefects Whether any defects were found. public bool HasDefects { get; } Property Value bool Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetFittingView(Box3d, Mat4d) Gets a fitting view matrix for a defect box, preserving the current view rotation. public static Mat4d GetFittingView(Box3d defectBox, Mat4d sketchView) Parameters defectBox Box3d The defect box to fit. sketchView Mat4d The current sketch view matrix. Returns Mat4d A view matrix that fits the defect box, or the original sketch view if inputs are invalid. Events DefectBoxSelected Fired when a defect box flag is selected (clicked). The parameter is the Box3d of the selected defect box. public event Action<Box3d> DefectBoxSelected Event Type Action<Box3d>"
  },
  "api/Hi.Cbtr.CubeTree.DefectNodeInfo.TriWireInfo.html": {
    "href": "api/Hi.Cbtr.CubeTree.DefectNodeInfo.TriWireInfo.html",
    "title": "Class CubeTree.DefectNodeInfo.TriWireInfo | HiAPI-C# 2025",
    "summary": "Class CubeTree.DefectNodeInfo.TriWireInfo Namespace Hi.Cbtr Assembly HiCbtr.dll A single triangle-wire relation entry within a defect node. public class CubeTree.DefectNodeInfo.TriWireInfo Inheritance object CubeTree.DefectNodeInfo.TriWireInfo Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties EdgeIndex The wire edge index (0-11). public int EdgeIndex { get; set; } Property Value int Tri The triangle geometry. public Tri3d Tri { get; set; } Property Value Tri3d TriWireRelation Tri-wire relation data. public CubeTree.TriWireRelationInterop TriWireRelation { get; set; } Property Value CubeTree.TriWireRelationInterop"
  },
  "api/Hi.Cbtr.CubeTree.DefectNodeInfo.html": {
    "href": "api/Hi.Cbtr.CubeTree.DefectNodeInfo.html",
    "title": "Class CubeTree.DefectNodeInfo | HiAPI-C# 2025",
    "summary": "Class CubeTree.DefectNodeInfo Namespace Hi.Cbtr Assembly HiCbtr.dll Info for a single defect node detected during cube tree construction. public class CubeTree.DefectNodeInfo Inheritance object CubeTree.DefectNodeInfo Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Box Bounding box of the defect node. public Box3d Box { get; set; } Property Value Box3d Level Tree level of the defect node. public int Level { get; set; } Property Value int TriWireInfos Triangle-wire relation info for each triangle involved in this defect node. public List<CubeTree.DefectNodeInfo.TriWireInfo> TriWireInfos { get; } Property Value List<CubeTree.DefectNodeInfo.TriWireInfo>"
  },
  "api/Hi.Cbtr.CubeTree.DefectTriWireInfoInterop.html": {
    "href": "api/Hi.Cbtr.CubeTree.DefectTriWireInfoInterop.html",
    "title": "Struct CubeTree.DefectTriWireInfoInterop | HiAPI-C# 2025",
    "summary": "Struct CubeTree.DefectTriWireInfoInterop Namespace Hi.Cbtr Assembly HiCbtr.dll Interop struct matching C++ defect_tri_wire_info_interop_t. public struct CubeTree.DefectTriWireInfoInterop Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields EdgeIndex Wire edge index (0-11). public int EdgeIndex Field Value int Tri Triangle geometry. public tri3d Tri Field Value tri3d TriWireRelation Tri-wire relation data. public CubeTree.TriWireRelationInterop TriWireRelation Field Value CubeTree.TriWireRelationInterop"
  },
  "api/Hi.Cbtr.CubeTree.InfNodeInfo.html": {
    "href": "api/Hi.Cbtr.CubeTree.InfNodeInfo.html",
    "title": "Class CubeTree.InfNodeInfo | HiAPI-C# 2025",
    "summary": "Class CubeTree.InfNodeInfo Namespace Hi.Cbtr Assembly HiCbtr.dll Info for a single node with inf edge_cuts, containing box and edge indices. public class CubeTree.InfNodeInfo Inheritance object CubeTree.InfNodeInfo Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Box Bounding box of the node. public Box3d Box { get; set; } Property Value Box3d InfEdgeIndices Edge indices (0-11) of inf edge_cuts in this node. public List<int> InfEdgeIndices { get; } Property Value List<int>"
  },
  "api/Hi.Cbtr.CubeTree.TriWireRelationInterop.html": {
    "href": "api/Hi.Cbtr.CubeTree.TriWireRelationInterop.html",
    "title": "Struct CubeTree.TriWireRelationInterop | HiAPI-C# 2025",
    "summary": "Struct CubeTree.TriWireRelationInterop Namespace Hi.Cbtr Assembly HiCbtr.dll Interop struct matching C++ tri_wire_relation_interop_t. public struct CubeTree.TriWireRelationInterop Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields CachedPosCornerStateMask For unparallel: 2 corner_state_t at the pos (2 x 2 bits, {0th=min, 1th=max}). For parallel: 0. public int CachedPosCornerStateMask Field Value int Pos0 For parallel: min position. For unparallel: intersection position. public double Pos0 Field Value double Pos1 For parallel: max position. For unparallel: NaN. public double Pos1 Field Value double RelationMask Bitmask of tri_wire_relation_enum_t flags. public int RelationMask Field Value int Properties IsOutside Is outside relation. public bool IsOutside { get; } Property Value bool IsParallel Is parallel relation. public bool IsParallel { get; } Property Value bool IsUnparallel Is unparallel relation. public bool IsUnparallel { get; } Property Value bool"
  },
  "api/Hi.Cbtr.CubeTree.diff_response_func_t.html": {
    "href": "api/Hi.Cbtr.CubeTree.diff_response_func_t.html",
    "title": "Delegate CubeTree.diff_response_func_t | HiAPI-C# 2025",
    "summary": "Delegate CubeTree.diff_response_func_t Namespace Hi.Cbtr Assembly HiCbtr.dll Delegate for handling difference responses during geometry comparison. public delegate void CubeTree.diff_response_func_t(nint node_sp, double diff, nint plus_arg) Parameters node_sp nint Pointer to the node. diff double The difference value. plus_arg nint Additional argument pointer. Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Cbtr.CubeTree.html": {
    "href": "api/Hi.Cbtr.CubeTree.html",
    "title": "Class CubeTree | HiAPI-C# 2025",
    "summary": "Class CubeTree Namespace Hi.Cbtr Assembly HiCbtr.dll Cube-based data structure. CubeTree has high performance for free-form geometry manipulation include volume removal and addition. public class CubeTree : IDisposable, IDisplayee, ICollidee, ICollidable, IExpandToBox3d, IGetCollidable Inheritance object CubeTree Implements IDisposable IDisplayee ICollidee ICollidable IExpandToBox3d IGetCollidable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods CubeTreeExportExtensions.ToStl(CubeTree, double) CollisionUtil.Detect(CubeTree, TriTree, Mat4d, double, int) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) SweptableUtil.AddBySweepingVolume(CubeTree, IGetSweptable, Mat4d, Mat4d, double, double, bool, bool) SweptableUtil.RemoveBySweepingVolume(CubeTree, IGetSweptable, Mat4d, Mat4d, double, double, bool, bool) CollisionUtil.Detect(ICollidable, ICollidable, Mat4d, double, int) DispUtil.Display(IDisplayee, Bind, Mat4d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CubeTree(NativeStl, double, CancellationToken, IProgress<IProgressFraction>) Ctor. This ctor is faster than CubeTree(NativeStl, double, CancellationToken, IProgress<IProgressFraction>). public CubeTree(NativeStl stl, double preferredGridWidth, CancellationToken token, IProgress<IProgressFraction> progress) Parameters stl NativeStl Triangle Grid. The triangles must be manifold geometry. preferredGridWidth double The expected resolution. token CancellationToken Cancellation token for the operation progress IProgress<IProgressFraction> Progress reporter for the operation Remarks The applied resolution is equal or smaller than the expected resolution. The applied resolution is c*(2^i). Where c is a constant; i is a integer to make the closest value of the formula. Errors relative to the input geometry are distributed at sharp edges and curved surfaces. CubeTree(Stl, double, CancellationToken, IProgress<IProgressFraction>) Can be initialized with Stl or NativeStl objects; using NativeStl is faster. The input triangle mesh must be manifold geometry, i.e., triangle vertices are aligned with other triangles' vertices, and the geometry must be closed. public CubeTree(Stl stl, double expectedResolution, CancellationToken token, IProgress<IProgressFraction> progress) Parameters stl Stl expectedResolution double Sets the preferred resolution. The actual resolution will be equal to or smaller than the specified value, approximately spaced by powers of 2. Errors relative to the input geometry are distributed at sharp edges and curved surfaces. token CancellationToken Cancellation token for the operation progress IProgress<IProgressFraction> Progress reporter for the operation CubeTree(string) Initializes a new instance of the CubeTree class from a file. public CubeTree(string file) Parameters file string The path to the cube tree file. Fields KeyDll Key dll path. public const string KeyDll = \"hi-key.dll\" Field Value string defaultPreferredGridWidth The default grid_width for the constructor. public const double defaultPreferredGridWidth = 0.0625 Field Value double Properties CubetreePtr Private element. public nint CubetreePtr { get; } Property Value nint DispCacheMb Display cache size in Mb. The cahce cost from graphic card and RAM. public static long DispCacheMb { get; set; } Property Value long IsDisposed Gets a value indicating whether this tree has been disposed. All native-backed members become no-ops afterwards (value getters return neutral defaults). public bool IsDisposed { get; } Property Value bool Resolution Get initialized resolution. public double Resolution { get; } Property Value double TotalCacheMb Cache size used by CubeTree. Sum of TrisCacheMb and DispCacheMb. TotalCacheMb Setter distributes (2/5 of the setting value) for DispCacheMb. public static long TotalCacheMb { get; set; } Property Value long TrisCacheMb Triangles cache size in Mb. The cache costs from RAM. public static long TrisCacheMb { get; set; } Property Value long Methods Add(CachedTris, double, bool, bool) Boolean-union counterpart of Substract(CachedTris, double, bool, bool). Using BufferedTris is more efficient than NativeStl. If the resolution of the addition region differs from the body's resolution, the lower resolution is applied to that region. public UnmanagedAddition Add(CachedTris adderBufferedTris, double preferredCubeWidth, bool isBuildContactContours = false, bool isAggressiveAdd = false) Parameters adderBufferedTris CachedTris Addition geometry preferredCubeWidth double The preferred cube width for the operation. isBuildContactContours bool If true, the returned Addition contains contour groups of the newly created surface, which can be used for further analysis. isAggressiveAdd bool If true, uses aggressive adding mode. Returns UnmanagedAddition Add(GeomBoolCache, bool, bool) Adds (boolean union) a geometry to the cube tree using a geometry boolean cache. public UnmanagedAddition Add(GeomBoolCache geomBoolCache, bool isBuildContactContours = false, bool isAggressiveAdd = false) Parameters geomBoolCache GeomBoolCache The geometry boolean cache containing the geometry to add. isBuildContactContours bool If true, the returned Addition will contain the contours of the newly created surface. isAggressiveAdd bool If true, uses aggressive adding mode. Returns UnmanagedAddition The result of the addition operation. Add(NativeStl, double, bool, bool) Boolean-union counterpart of Substract(NativeStl, double, bool, bool). Same functionality as Add(CachedTris,...). Less efficient due to the additional step of converting to CachedTris. public UnmanagedAddition Add(NativeStl adderStl, double preferredCubeWidth = 0, bool isBuildContactContours = false, bool isAggressiveAdd = false) Parameters adderStl NativeStl preferredCubeWidth double isBuildContactContours bool isAggressiveAdd bool Returns UnmanagedAddition CleanCache() Call Hi.Cbtr.CubeTree.CleanTrisCache() and Hi.Cbtr.CubeTree.CleanDispCache_(). public static void CleanCache() CleanDispCachee() Clean display cache of this. public void CleanDispCachee() ContainsInfEdgeCuts() Checks if any existing node in the cube tree contains inf or -inf in its edge_cuts array. public bool ContainsInfEdgeCuts() Returns bool true if any node contains inf or -inf in edge_cuts, false otherwise. DetachAttachments() Detach-ALL: nulls every node's attachment WITHOUT erasing nodes from those attachments' node maps — a fast reset of all colouring for when the attached attachments are about to be disposed (their own disposal clears their maps). Runs under the write gate so it also acts as a render barrier (in-flight renders drain, new renders read null), letting the detached attachments be freed in the background with no render holding a stale pointer. The caller MUST dispose the detached attachments. Must NOT be called while holding this tree's read gate. public void DetachAttachments() DetachUnderWriteGate(IReadOnlyCollection<CbtrPickable>) Targeted detach: under the write gate (render barrier), nulls node->attachment for ONLY the given attachments' nodes (idempotent ==this guard; never touches other attachments). After this returns, dispose them in the background — the barrier guarantees no render still holds a stale pointer. Must NOT be called while holding this tree's read gate. public void DetachUnderWriteGate(IReadOnlyCollection<CbtrPickable> attachments) Parameters attachments IReadOnlyCollection<CbtrPickable> Diff(NativeStl, double, RangeColorRule, IProgress<IMessage>) Compares the cube tree with an ideal geometry and returns difference attachments. public ConcurrentBag<DiffAttachment> Diff(NativeStl idealGeom, double diffRadius, RangeColorRule diffRangeColorRule, IProgress<IMessage> messageProgress = null) Parameters idealGeom NativeStl The ideal geometry to compare with. diffRadius double The radius for difference detection. diffRangeColorRule RangeColorRule The color rule for visualizing differences. messageProgress IProgress<IMessage> Progress reporter for the operation. Returns ConcurrentBag<DiffAttachment> A collection of difference attachments. Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool DisposeBackground() Frees the native cube tree on a background task. Disposals are serialized: if a previous background disposal has not finished, this one waits for it. Returns the task representing this disposal (see WaitForPendingDisposals() to drain). public Task DisposeBackground() Returns Task DisposeBackground(IReadOnlyCollection<IDisposable>) Enqueues disposal of objects retired alongside a tree (typically its attachments) on the SAME serialized chain as DisposeBackground(), so there is a single drain point (WaitForPendingDisposals()). Disposing a CbtrPickable now clears its (possibly huge) attached node map — O(nodes) — which must not run on the hot path. Enqueue the owning tree's DisposeBackground() first so the gated tree teardown (which waits out in-flight renders) runs before its attachments are freed. public static Task DisposeBackground(IReadOnlyCollection<IDisposable> disposables) Parameters disposables IReadOnlyCollection<IDisposable> Returns Task ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box ~CubeTree() dtor protected ~CubeTree() GetCollidable() Gets the collidable object. public ICollidable GetCollidable() Returns ICollidable The collidable object (this instance). GetCollidee() Get ICollidee. public ICollidee GetCollidee() Returns ICollidee ICollidee GetInfEdgeCutsInfo() Gets info for all nodes that contain inf or -inf in their edge_cuts array. Each node's box is grouped with its corresponding inf edge indices. This is useful for identifying and visualizing non-manifold geometry issues in the cube tree. public List<CubeTree.InfNodeInfo> GetInfEdgeCutsInfo() Returns List<CubeTree.InfNodeInfo> A list of node info, each containing a box and its inf edge indices. GetRgbTrisNativeArray(double) Get triangles in type of double array. The returned triangles is non-manifold. It may not be closed model and the apexes of triangle grid may not be overlapped. public double[] GetRgbTrisNativeArray(double resolution = 0) Parameters resolution double The preferred resolution. The real resolution may be smaller or equal the prefered resolution. The real resolution is discrete. The resolution value is at 2^i. The geometric error mainly locate at corner. Returns double[] rgb traingle grid. In sequence of r,g,b,n.x,n.y,n.z,p0.x,p0.y,p0.z,p1.x,p1.y,p1.z,p2.x,p2.y,p2.z, repetitively. A triangle take 15 double. GetTris(double) Get triangles. The returned triangles is non-manifold. It may not be closed model and the apexes of triangle grid may not be overlapped. public List<Tri3d> GetTris(double resolution = 0) Parameters resolution double Sets the preferred resolution. The actual resolution will be equal to or smaller than the specified value, approximately spaced by powers of 2. Errors relative to the input geometry are distributed at sharp edges and curved surfaces. A larger resolution results in fewer triangles and faster computation. Returns List<Tri3d> Triangle mesh NewWithDefectInfos(NativeStl, double, CancellationToken, IProgress<IMessage>) Creates a new CubeTree and collects defect node infos during construction. public static (CubeTree cubeTree, List<CubeTree.DefectNodeInfo> defectInfos) NewWithDefectInfos(NativeStl stl, double preferredGridWidth, CancellationToken token, IProgress<IMessage> messageProgress) Parameters stl NativeStl preferredGridWidth double token CancellationToken messageProgress IProgress<IMessage> Returns (CubeTree cubeTree, List<CubeTree.DefectNodeInfo> defectInfos) NewWithDefectInfos(Stl, double, CancellationToken, IProgress<IMessage>) Creates a new CubeTree and collects defect node infos during construction. public static (CubeTree cubeTree, List<CubeTree.DefectNodeInfo> defectInfos) NewWithDefectInfos(Stl stl, double preferredGridWidth, CancellationToken token, IProgress<IMessage> messageProgress) Parameters stl Stl preferredGridWidth double token CancellationToken messageProgress IProgress<IMessage> Returns (CubeTree cubeTree, List<CubeTree.DefectNodeInfo> defectInfos) RebuildAttach(CbtrPickable) Every node in CubeTree can contain one CbtrPickable object. This function put or replace the contained data of all nodes to src. Using UpdateAttach(CbtrPickable) will place nodes that have not yet stored data (CbtrPickable is null) into src. public void RebuildAttach(CbtrPickable src) Parameters src CbtrPickable RemoveFlyPiece() Removes disconnected pieces (fly pieces) from the cube tree. public void RemoveFlyPiece() Substract(CachedTris, double, bool, bool) Using BufferedTris is more efficient than NativeStl. If the resolution of the subtraction region differs from the body's resolution, the lower resolution is applied to that region. public UnmanagedSubstraction Substract(CachedTris cutterBufferedTris, double preferredCubeWidth, bool isBuildContactContours = false, bool isAggressiveCut = false) Parameters cutterBufferedTris CachedTris Subtraction geometry preferredCubeWidth double The preferred cube width for the operation. isBuildContactContours bool If true, the returned Substraction contains contour groups at the intersection of the subtraction geometry and the workpiece geometry, which can be used for further analysis. isAggressiveCut bool If true, uses aggressive cutting mode. Returns UnmanagedSubstraction Substract(GeomBoolCache, bool, bool) Subtracts a geometry from the cube tree using a geometry boolean cache. public UnmanagedSubstraction Substract(GeomBoolCache geomBoolCache, bool isBuildContactContours = false, bool isAggressiveCut = false) Parameters geomBoolCache GeomBoolCache The geometry boolean cache containing the geometry to subtract. isBuildContactContours bool If true, the returned Substraction will contain contact contours. isAggressiveCut bool If true, uses aggressive cutting mode. Returns UnmanagedSubstraction The result of the subtraction operation. Substract(InitStickConvex, Mat4d, double, bool, bool) Subtracts a stick convex geometry from the cube tree. public UnmanagedSubstraction Substract(InitStickConvex initStickConvex, Mat4d mat, double preferredCubeWidth, bool isBuildContactContours = false, bool isAggressiveCut = false) Parameters initStickConvex InitStickConvex The stick convex geometry to subtract. mat Mat4d The transformation matrix to apply to the stick convex. preferredCubeWidth double The preferred cube width for the operation. isBuildContactContours bool If true, the returned Substraction will contain contact contours. isAggressiveCut bool If true, uses aggressive cutting mode. Returns UnmanagedSubstraction The result of the subtraction operation. Substract(NativeStl, double, bool, bool) Same functionality as Substract(BufferedTris,...). Less efficient due to the additional step of converting to CachedTris. public UnmanagedSubstraction Substract(NativeStl cutterStl, double preferredCubeWidth = 0, bool isBuildContactContours = false, bool isAggressiveCut = false) Parameters cutterStl NativeStl preferredCubeWidth double isBuildContactContours bool isAggressiveCut bool Returns UnmanagedSubstraction TestDiff(out CubeTree, out NativeStl) Tests the difference calculation between a cube tree and an ideal geometry. public static void TestDiff(out CubeTree cubeTree_, out NativeStl idealGeom_) Parameters cubeTree_ CubeTree The resulting cube tree. idealGeom_ NativeStl The ideal geometry used for comparison. TestIO() Tests the input/output operations for a cube tree. public static CubeTree TestIO() Returns CubeTree The cube tree created or loaded during the test. TestSimpleRemove(out CubeTree) Tests the simple removal operation on a cube tree. public static void TestSimpleRemove(out CubeTree cubeTree_) Parameters cubeTree_ CubeTree The resulting cube tree after the removal operation. UpdateAttach(CbtrPickable) Every node in CubeTree can contain one CbtrPickable object. This function put src to the nodes that contain null. public void UpdateAttach(CbtrPickable src) Parameters src CbtrPickable WaitForPendingDisposals() A task that completes when all queued background disposals have finished. Await this at application shutdown before the native dll is unloaded. public static Task WaitForPendingDisposals() Returns Task WriteFile(string) Writes the cube tree to a file. public void WriteFile(string file) Parameters file string The path where the cube tree will be written."
  },
  "api/Hi.Cbtr.CubeTreeExportExtensions.html": {
    "href": "api/Hi.Cbtr.CubeTreeExportExtensions.html",
    "title": "Class CubeTreeExportExtensions | HiAPI-C# 2025",
    "summary": "Class CubeTreeExportExtensions Namespace Hi.Cbtr Assembly HiCbtr.dll Mesh export helpers for CubeTree. public static class CubeTreeExportExtensions Inheritance object CubeTreeExportExtensions Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods ToStl(CubeTree, double) Builds an Stl from the cube tree's surface triangles. Per-triangle face normals are rebuilt before returning. public static Stl ToStl(this CubeTree cubeTree, double resolution = 0) Parameters cubeTree CubeTree Source cube tree. resolution double Preferred resolution; 0 keeps the cube tree's default. Returns Stl STL containing triangles with rebuilt face normals."
  },
  "api/Hi.Cbtr.CubeTreeFile.html": {
    "href": "api/Hi.Cbtr.CubeTreeFile.html",
    "title": "Class CubeTreeFile | HiAPI-C# 2025",
    "summary": "Class CubeTreeFile Namespace Hi.Cbtr Assembly HiCbtr.dll Represents a file containing cube tree data. public class CubeTreeFile : IMakeXmlSource, ISourceFile, IToPresentDto Inheritance object CubeTreeFile Implements IMakeXmlSource ISourceFile IToPresentDto Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CubeTreeFile() Ctor. public CubeTreeFile() CubeTreeFile(string, string) Ctor. public CubeTreeFile(string relFile, string baseDirectory) Parameters relFile string baseDirectory string CubeTreeFile(XElement, string) Ctor. public CubeTreeFile(XElement src, string baseDirectory) Parameters src XElement XML baseDirectory string Base directory for relative paths. Properties BaseDirectory Gets or sets the base directory for file operations. public string BaseDirectory { get; set; } Property Value string SourceFile file path. public string SourceFile { get; set; } Property Value string XName Name for XML IO. public static string XName { get; } Property Value string Methods LoadByFile() Loads a cube tree from the specified file. public CubeTree LoadByFile() Returns CubeTree The loaded cube tree, or null if the file path is empty/null or the file does not exist. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToPresentDto() Convert CubeTreeFile to presentation DTO (Data Transfer Object) for JSON serialization. The returned object includes type metadata for web API presentation. public object ToPresentDto() Returns object DTO dictionary with Type and SourceFile keys"
  },
  "api/Hi.Cbtr.DiffAttachment.html": {
    "href": "api/Hi.Cbtr.DiffAttachment.html",
    "title": "Class DiffAttachment | HiAPI-C# 2025",
    "summary": "Class DiffAttachment Namespace Hi.Cbtr Assembly HiCbtr.dll Represents an attachment with a difference value for cube tree. public class DiffAttachment : CbtrPickable, IGetPickable, IDisposable Inheritance object Pickable CbtrPickable DiffAttachment Implements IGetPickable IDisposable Inherited Members CbtrPickable.Rgb CbtrPickable.IsColorTableCovered CbtrPickable.AttachmentPriority CbtrPickable.Highlight(bool) CbtrPickable.CleanAttachedCbtrNodesDrawingCache() CbtrPickable.ShrinkToFitNodeMap() CbtrPickable.OnMouseEnter(ui_event_type, DispEngine) CbtrPickable.OnMouseLeave(ui_event_type, DispEngine) Pickable.Pickables Pickable.mark Pickable.PickingID Pickable.GetPickable() Pickable.OnKeyDown(key_event_t, DispEngine) Pickable.OnKeyUp(key_event_t, DispEngine) Pickable.OnMouseDown(mouse_button_event_t, DispEngine) Pickable.OnMouseUp(mouse_button_event_t, DispEngine) Pickable.OnMouseMove(mouse_move_event_t, DispEngine) Pickable.OnMouseWheel(mouse_wheel_event_t, DispEngine) Pickable.Dispose() object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors DiffAttachment(double) Initializes a new instance of the DiffAttachment class. public DiffAttachment(double diff) Parameters diff double The difference value. Properties Diff Gets or sets the difference value. public double Diff { get; set; } Property Value double Methods Dispose(bool) protected override void Dispose(bool disposing) Parameters disposing bool"
  },
  "api/Hi.Cbtr.GeomBoolCache.html": {
    "href": "api/Hi.Cbtr.GeomBoolCache.html",
    "title": "Class GeomBoolCache | HiAPI-C# 2025",
    "summary": "Class GeomBoolCache Namespace Hi.Cbtr Assembly HiCbtr.dll Cache for geometry boolean operations. public class GeomBoolCache : IDisposable Inheritance object GeomBoolCache Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors GeomBoolCache(GeomBoolCacheEnum) Initializes a new instance of the GeomBoolCache class. public GeomBoolCache(GeomBoolCacheEnum boolGeomCacheEnum) Parameters boolGeomCacheEnum GeomBoolCacheEnum The type of geometry boolean cache. Properties CachedTris Gets or sets the cached triangles. public CachedTris CachedTris { get; set; } Property Value CachedTris ConvexTransformation Gets or sets the convex transformation matrix. public Mat4d ConvexTransformation { get; set; } Property Value Mat4d GeomBoolCacheEnum Gets or sets the type of geometry boolean cache. public GeomBoolCacheEnum GeomBoolCacheEnum { get; set; } Property Value GeomBoolCacheEnum InitStickConvex Gets or sets the initialization stick convex. public InitStickConvex InitStickConvex { get; set; } Property Value InitStickConvex PreferredCubeWidth Gets or sets the preferred cube width. public double PreferredCubeWidth { get; set; } Property Value double Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Cbtr.GeomBoolCacheEnum.html": {
    "href": "api/Hi.Cbtr.GeomBoolCacheEnum.html",
    "title": "Enum GeomBoolCacheEnum | HiAPI-C# 2025",
    "summary": "Enum GeomBoolCacheEnum Namespace Hi.Cbtr Assembly HiCbtr.dll Enumeration of geometry boolean cache types. public enum GeomBoolCacheEnum Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields CachedTris = 1 Cached triangles mode. StickConvex = 2 Stick convex mode."
  },
  "api/Hi.Cbtr.IGetInitStickConvex.html": {
    "href": "api/Hi.Cbtr.IGetInitStickConvex.html",
    "title": "Interface IGetInitStickConvex | HiAPI-C# 2025",
    "summary": "Interface IGetInitStickConvex Namespace Hi.Cbtr Assembly HiCbtr.dll Interface of GetInitStickConvex(). public interface IGetInitStickConvex : IVolumeRemover Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetInitStickConvex() Get InitStickConvex. InitStickConvex GetInitStickConvex() Returns InitStickConvex InitStickConvex"
  },
  "api/Hi.Cbtr.InfDefectDisplayee.html": {
    "href": "api/Hi.Cbtr.InfDefectDisplayee.html",
    "title": "Class InfDefectDisplayee | HiAPI-C# 2025",
    "summary": "Class InfDefectDisplayee Namespace Hi.Cbtr Assembly HiCbtr.dll Encapsulates inf edge cuts defect visualization for a cube tree, including defect boxes, edge segments, and flag drawings. public class InfDefectDisplayee : IDisplayee, IExpandToBox3d, IDisposable Inheritance object InfDefectDisplayee Implements IDisplayee IExpandToBox3d IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) DispUtil.Display(IDisplayee, Bind, Mat4d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors InfDefectDisplayee(List<InfNodeInfo>) Ctor. Builds drawings from the given inf node info list. public InfDefectDisplayee(List<CubeTree.InfNodeInfo> nodeInfoList) Parameters nodeInfoList List<CubeTree.InfNodeInfo> Properties DefectBoxes Defect boxes for display (capped to Hi.Cbtr.InfDefectDisplayee.defectBoxesToShow). public List<Box3d> DefectBoxes { get; } Property Value List<Box3d> HasDefects Whether any inf defects were found. public bool HasDefects { get; } Property Value bool NodeInfoList Inf node info list from cube tree. public List<CubeTree.InfNodeInfo> NodeInfoList { get; } Property Value List<CubeTree.InfNodeInfo> Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box ReportTo(IProgress<IMessage>) Reports defect information to a message host. public void ReportTo(IProgress<IMessage> messageProgress) Parameters messageProgress IProgress<IMessage>"
  },
  "api/Hi.Cbtr.InitStickConvex.html": {
    "href": "api/Hi.Cbtr.InitStickConvex.html",
    "title": "Class InitStickConvex | HiAPI-C# 2025",
    "summary": "Class InitStickConvex Namespace Hi.Cbtr Assembly HiCbtr.dll Represents a stick convex initialization object. public class InitStickConvex : IDisposable Inheritance object InitStickConvex Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors InitStickConvex(IGetGeneralApt) Initializes a new instance of the InitStickConvex class. public InitStickConvex(IGetGeneralApt src) Parameters src IGetGeneralApt The source object that provides general APT information. Properties InitStickConvexPtr Gets the native pointer to the stick convex object. public nint InitStickConvexPtr { get; } Property Value nint Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ~InitStickConvex() protected ~InitStickConvex()"
  },
  "api/Hi.Cbtr.Substraction.html": {
    "href": "api/Hi.Cbtr.Substraction.html",
    "title": "Class Substraction | HiAPI-C# 2025",
    "summary": "Class Substraction Namespace Hi.Cbtr Assembly HiCbtr.dll Represents the result of a volume subtraction operation. public class Substraction : IWriteBin, IDisplayee, IExpandToBox3d Inheritance object Substraction Implements IWriteBin IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MillingRemovalUtil.GetContoursOnToolRunningCoordinate(Substraction, MachineMotionStep) DispUtil.Display(IDisplayee, Bind, Mat4d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Substraction() Ctor. for Entity Framework. public Substraction() Substraction(UnmanagedSubstraction) Initializes a new instance of the Substraction class from an unmanaged substraction. public Substraction(UnmanagedSubstraction unmanagedSubstraction) Parameters unmanagedSubstraction UnmanagedSubstraction The unmanaged substraction to copy data from. Substraction(BinaryReader) Initializes a new instance of the Substraction class from a binary reader. public Substraction(BinaryReader reader) Parameters reader BinaryReader The binary reader to read data from. Properties ContactContours Gets or sets the contact contours on workpiece coordinate. public List<List<Vec3d>> ContactContours { get; } Property Value List<List<Vec3d>> ContactContoursArea Gets the area of the contact contours. public double ContactContoursArea { get; init; } Property Value double ContactContoursByteArray Gets or sets the byte array representation of the contact contours. public byte[] ContactContoursByteArray { get; set; } Property Value byte[] IsTouched Gets a value indicating whether the cutter and workpiece touched. public bool IsTouched { get; init; } Property Value bool StepIndex Step index. For database saving. [Key] [DatabaseGenerated(DatabaseGeneratedOption.None)] public int StepIndex { get; set; } Property Value int Methods ContactContoursReadBin(BinaryReader) Reads contact contours from a binary reader. public static List<List<Vec3d>> ContactContoursReadBin(BinaryReader reader) Parameters reader BinaryReader The binary reader to read from. Returns List<List<Vec3d>> A list of contact contour lists. ContactContoursWriteBin(List<List<Vec3d>>, BinaryWriter) Writes contact contours to a binary writer. public static void ContactContoursWriteBin(List<List<Vec3d>> contactContours, BinaryWriter writer) Parameters contactContours List<List<Vec3d>> The contact contours to write. writer BinaryWriter The binary writer to write to. Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box WriteBin(BinaryWriter) Writes the object's data to a binary stream. public void WriteBin(BinaryWriter writer) Parameters writer BinaryWriter The binary writer to write to"
  },
  "api/Hi.Cbtr.UnhighlightablePickable.html": {
    "href": "api/Hi.Cbtr.UnhighlightablePickable.html",
    "title": "Class UnhighlightablePickable | HiAPI-C# 2025",
    "summary": "Class UnhighlightablePickable Namespace Hi.Cbtr Assembly HiCbtr.dll Cbtr un-highlightable pickable. For initailizing purpose by RebuildAttach(CbtrPickable). public class UnhighlightablePickable : CbtrPickable, IGetPickable, IDisposable Inheritance object Pickable CbtrPickable UnhighlightablePickable Implements IGetPickable IDisposable Inherited Members CbtrPickable.Rgb CbtrPickable.IsColorTableCovered CbtrPickable.AttachmentPriority CbtrPickable.Highlight(bool) CbtrPickable.CleanAttachedCbtrNodesDrawingCache() CbtrPickable.ShrinkToFitNodeMap() CbtrPickable.Dispose(bool) Pickable.Pickables Pickable.mark Pickable.PickingID Pickable.GetPickable() Pickable.OnKeyDown(key_event_t, DispEngine) Pickable.OnKeyUp(key_event_t, DispEngine) Pickable.OnMouseDown(mouse_button_event_t, DispEngine) Pickable.OnMouseUp(mouse_button_event_t, DispEngine) Pickable.OnMouseMove(mouse_move_event_t, DispEngine) Pickable.OnMouseWheel(mouse_wheel_event_t, DispEngine) Pickable.Dispose() object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors UnhighlightablePickable() Ctor. public UnhighlightablePickable() Methods OnMouseEnter(ui_event_type, DispEngine) Behavior on mouse enter public override void OnMouseEnter(ui_event_type e, DispEngine dispEngine) Parameters e ui_event_type event type dispEngine DispEngine display engine OnMouseLeave(ui_event_type, DispEngine) Behavior on mouse leave public override void OnMouseLeave(ui_event_type e, DispEngine dispEngine) Parameters e ui_event_type event type dispEngine DispEngine display engine"
  },
  "api/Hi.Cbtr.UnmanagedAddition.html": {
    "href": "api/Hi.Cbtr.UnmanagedAddition.html",
    "title": "Class UnmanagedAddition | HiAPI-C# 2025",
    "summary": "Class UnmanagedAddition Namespace Hi.Cbtr Assembly HiCbtr.dll Data about the adding behavior of CubeTree. The dual of UnmanagedSubstraction. public class UnmanagedAddition : IDisplayee, IExpandToBox3d, IDisposable Inheritance object UnmanagedAddition Implements IDisplayee IExpandToBox3d IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) DispUtil.Display(IDisplayee, Bind, Mat4d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields preserveCount The count of preservations to prevent disposal. public int preserveCount Field Value int Properties ContactContours Contours of the newly created surface (the dual of the substraction's newly exposed surface). Each contour is composed by 3~12 points. public List<List<Vec3d>> ContactContours { get; } Property Value List<List<Vec3d>> ContactContoursArea Gets the area of the contact contours. public double ContactContoursArea { get; } Property Value double IsTouched Is the adder and workpiece touched (any material actually added). public bool IsTouched { get; } Property Value bool Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. DisplayContours(Bind) Display ContactContours by lines. public void DisplayContours(Bind bind) Parameters bind Bind bind Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box ~UnmanagedAddition() protected ~UnmanagedAddition() PreserveBegin() Preserve the object from arising Dispose(). Add preserve count for 1. public void PreserveBegin() See Also PreserveEnd() PreserveEnd() Minus preserve count for 1. If preserve count is eqaul or lower than 0, call Dispose(). public void PreserveEnd() See Also PreserveBegin()"
  },
  "api/Hi.Cbtr.UnmanagedSubstraction.html": {
    "href": "api/Hi.Cbtr.UnmanagedSubstraction.html",
    "title": "Class UnmanagedSubstraction | HiAPI-C# 2025",
    "summary": "Class UnmanagedSubstraction Namespace Hi.Cbtr Assembly HiCbtr.dll Data about the removing behavior of CubeTree. public class UnmanagedSubstraction : IDisplayee, IExpandToBox3d, IDisposable Inheritance object UnmanagedSubstraction Implements IDisplayee IExpandToBox3d IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) DispUtil.Display(IDisplayee, Bind, Mat4d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields preserveCount The count of preservations to prevent disposal. public int preserveCount Field Value int Properties ContactContours Contact contours. Each contour is composed by 3~12 points. public List<List<Vec3d>> ContactContours { get; } Property Value List<List<Vec3d>> ContactContoursArea Gets the area of the contact contours. public double ContactContoursArea { get; } Property Value double IsTouched Is the cutter and workpiece touched. public bool IsTouched { get; } Property Value bool SubstractionPtr Internal Use Only. The native pointer to the substraction object. HiMech reads it to build the milling engagement natively at the substraction completion point, without copying contours through the managed heap. public nint SubstractionPtr { get; } Property Value nint Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. DisplayContours(Bind) Display ContactContours by lines. public void DisplayContours(Bind bind) Parameters bind Bind bind Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box ~UnmanagedSubstraction() protected ~UnmanagedSubstraction() PreserveBegin() Preserve the object from arising Dispose(). Add preserve count for 1. public void PreserveBegin() See Also PreserveEnd() PreserveEnd() Minus preserve count for 1. If preserve count is eqaul or lower than 0, call Dispose(). public void PreserveEnd() See Also PreserveBegin()"
  },
  "api/Hi.Cbtr.WireCube.html": {
    "href": "api/Hi.Cbtr.WireCube.html",
    "title": "Class WireCube | HiAPI-C# 2025",
    "summary": "Class WireCube Namespace Hi.Cbtr Assembly HiCbtr.dll For Internal Use Only. Represents a wire cube for display purposes. The edge index follows the C++ cube_node_t pattern: edgeIndex = (dir << 2) | (th1 << 1) | th0 where dir is the edge direction (0=X, 1=Y, 2=Z), th0 is the position flag in (dir+1)%3 direction, th1 is the position flag in (dir+2)%3 direction. public class WireCube : IDisplayee, IExpandToBox3d Inheritance object WireCube Implements IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) DispUtil.Display(IDisplayee, Bind, Mat4d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods Display(Bind) Displays the wire cube. public void Display(Bind bind) Parameters bind Bind The binding context for display. ExpandToBox3d(Box3d) Expands the destination box to include the unit cube. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d The destination box to expand. GetCorner(int, bool) Gets the corner index (0-7) from an edge index and whether it's the tail endpoint. This follows the C++ WireCube::getCorner(int edgeIndex, bool is_tail) pattern. public static int GetCorner(int edgeIndex, bool isTail) Parameters edgeIndex int The edge index (0-11). isTail bool True for the tail endpoint (max in edge direction), false for head (min in edge direction). Returns int The corner index (0-7) where bit 0=X, bit 1=Y, bit 2=Z indicate min(0) or max(1) position. GetCornerVertex(Box3d, int) Gets the vertex position of a corner from a box. public static Vec3d GetCornerVertex(Box3d box, int corner) Parameters box Box3d The bounding box. corner int The corner index (0-7) where bit 0=X, bit 1=Y, bit 2=Z indicate min(0) or max(1) position. Returns Vec3d The vertex position. GetDir(int) Gets the direction (axis) of an edge. public static int GetDir(int edgeIndex) Parameters edgeIndex int The edge index (0-11). Returns int The direction: 0=X, 1=Y, 2=Z. GetEdgeIndex(int, int, int) Gets the edge index from direction and position flags. public static int GetEdgeIndex(int dir, int th0, int th1) Parameters dir int The edge direction (0=X, 1=Y, 2=Z). th0 int Position flag in (dir+1)%3 direction (0 or 1). th1 int Position flag in (dir+2)%3 direction (0 or 1). Returns int The edge index (0-11). GetEdgeSegment3d(Box3d, int) Gets the two endpoint vertices of an edge for a given box and edge index. public static Segment3d GetEdgeSegment3d(Box3d box, int edgeIndex) Parameters box Box3d The bounding box. edgeIndex int The edge index (0-11). Returns Segment3d A tuple containing the head (min in edge direction) and tail (max in edge direction) vertices of the edge."
  },
  "api/Hi.Cbtr.html": {
    "href": "api/Hi.Cbtr.html",
    "title": "Namespace Hi.Cbtr | HiAPI-C# 2025",
    "summary": "Namespace Hi.Cbtr Classes CachedTris Feature-cached triangle for CubeTree computation. CbtrPickable Pickable of CubeTree grids. ConstructionDefectDisplayee Encapsulates cube tree construction defect results, including both defect data and visualization drawings. CubeTree Cube-based data structure. CubeTree has high performance for free-form geometry manipulation include volume removal and addition. CubeTree.DefectNodeInfo Info for a single defect node detected during cube tree construction. CubeTree.DefectNodeInfo.TriWireInfo A single triangle-wire relation entry within a defect node. CubeTree.InfNodeInfo Info for a single node with inf edge_cuts, containing box and edge indices. CubeTreeExportExtensions Mesh export helpers for CubeTree. CubeTreeFile Represents a file containing cube tree data. DiffAttachment Represents an attachment with a difference value for cube tree. GeomBoolCache Cache for geometry boolean operations. InfDefectDisplayee Encapsulates inf edge cuts defect visualization for a cube tree, including defect boxes, edge segments, and flag drawings. InitStickConvex Represents a stick convex initialization object. Substraction Represents the result of a volume subtraction operation. UnhighlightablePickable Cbtr un-highlightable pickable. For initailizing purpose by RebuildAttach(CbtrPickable). UnmanagedAddition Data about the adding behavior of CubeTree. The dual of UnmanagedSubstraction. UnmanagedSubstraction Data about the removing behavior of CubeTree. WireCube For Internal Use Only. Represents a wire cube for display purposes. The edge index follows the C++ cube_node_t pattern: edgeIndex = (dir << 2) | (th1 << 1) | th0 where dir is the edge direction (0=X, 1=Y, 2=Z), th0 is the position flag in (dir+1)%3 direction, th1 is the position flag in (dir+2)%3 direction. Structs CubeTree.DefectTriWireInfoInterop Interop struct matching C++ defect_tri_wire_info_interop_t. CubeTree.TriWireRelationInterop Interop struct matching C++ tri_wire_relation_interop_t. node_diff_t Structure representing a node with a difference value. Interfaces IGetInitStickConvex Interface of GetInitStickConvex(). Enums CachedTris.SweepingMode Defines the mode for sweeping operations. GeomBoolCacheEnum Enumeration of geometry boolean cache types. Delegates CubeTree.diff_response_func_t Delegate for handling difference responses during geometry comparison."
  },
  "api/Hi.Cbtr.node_diff_t.html": {
    "href": "api/Hi.Cbtr.node_diff_t.html",
    "title": "Struct node_diff_t | HiAPI-C# 2025",
    "summary": "Struct node_diff_t Namespace Hi.Cbtr Assembly HiCbtr.dll Structure representing a node with a difference value. public struct node_diff_t Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields diff Difference value. public double diff Field Value double node Pointer to the node. public nint node Field Value nint"
  },
  "api/Hi.Collision.AnchoredCollidableLeaf.html": {
    "href": "api/Hi.Collision.AnchoredCollidableLeaf.html",
    "title": "Class AnchoredCollidableLeaf | HiAPI-C# 2025",
    "summary": "Class AnchoredCollidableLeaf Namespace Hi.Collision Assembly HiMech.dll Represents a leaf node in the anchored collidable hierarchy. public class AnchoredCollidableLeaf : IAnchoredCollidableLeaf, IAnchoredCollidableNode, IAnchoredCollidableBased, ICollidable, IGetCollidable Inheritance object AnchoredCollidableLeaf Implements IAnchoredCollidableLeaf IAnchoredCollidableNode IAnchoredCollidableBased ICollidable IGetCollidable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) CollisionUtil.Detect(ICollidable, ICollidable, Mat4d, double, int) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors AnchoredCollidableLeaf() Initializes a new instance of the AnchoredCollidableLeaf class. public AnchoredCollidableLeaf() AnchoredCollidableLeaf(string, Anchor, ICollidable) Initializes a new instance of the AnchoredCollidableLeaf class with a name, anchor, and collidable object. public AnchoredCollidableLeaf(string collidableName, Anchor anchor, ICollidable collidable) Parameters collidableName string The name of the collidable object. anchor Anchor The anchor for the collidable object. collidable ICollidable The collidable object. Properties Anchor Gets or sets the anchor for this collidable leaf. public Anchor Anchor { get; set; } Property Value Anchor Collidable Gets or sets the collidable object. public ICollidable Collidable { get; set; } Property Value ICollidable CollidableName Gets or sets the name of the collidable object. public string CollidableName { get; set; } Property Value string Methods GetAnchoredCollidableNode() Gets the anchored collidable node associated with this object. public IAnchoredCollidableNode GetAnchoredCollidableNode() Returns IAnchoredCollidableNode The anchored collidable node. GetCollidable() Get ICollidable. public ICollidable GetCollidable() Returns ICollidable The collidable object. GetCollidableAnchor() Gets the anchor associated with this collidable leaf. public Anchor GetCollidableAnchor() Returns Anchor The anchor for this collidable leaf. GetCollidee() Get ICollidee. public ICollidee GetCollidee() Returns ICollidee ICollidee GetRootAnchor() public Anchor GetRootAnchor() Returns Anchor"
  },
  "api/Hi.Collision.AnchoredCollidablePair.html": {
    "href": "api/Hi.Collision.AnchoredCollidablePair.html",
    "title": "Class AnchoredCollidablePair | HiAPI-C# 2025",
    "summary": "Class AnchoredCollidablePair Namespace Hi.Collision Assembly HiMech.dll Represents a pair of anchored collidable objects for collision detection. public class AnchoredCollidablePair : IMakeXmlSource Inheritance object AnchoredCollidablePair Implements IMakeXmlSource Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors AnchoredCollidablePair(IAnchoredCollidableBased, IAnchoredCollidableBased) Initializes a new instance of the AnchoredCollidablePair class with two collidable objects. public AnchoredCollidablePair(IAnchoredCollidableBased indexA, IAnchoredCollidableBased indexB) Parameters indexA IAnchoredCollidableBased The first collidable object. indexB IAnchoredCollidableBased The second collidable object. AnchoredCollidablePair(string, IAnchoredCollidableBased, IAnchoredCollidableBased) Initializes a new instance of the AnchoredCollidablePair class with a name and two collidable objects. public AnchoredCollidablePair(string name, IAnchoredCollidableBased indexA, IAnchoredCollidableBased indexB) Parameters name string The name of the pair. indexA IAnchoredCollidableBased The first collidable object. indexB IAnchoredCollidableBased The second collidable object. AnchoredCollidablePair(XElement, string, IProgress<IMessage>, object[]) Initializes a new instance of the AnchoredCollidablePair class from XML. public AnchoredCollidablePair(XElement src, string baseDirectory, IProgress<IMessage> progress, object[] res) Parameters src XElement The XML element containing the pair data. baseDirectory string The base directory for resolving relative paths. progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. res object[] Additional resources for initialization. Fields XName The XML element name for serialization. public static string XName Field Value string Properties CollisionFlag Gets or sets the collision flag indicating the collision status between the two objects. public CollisionFlag CollisionFlag { get; } Property Value CollisionFlag IndexA Gets the first collidable object in the pair. public IAnchoredCollidableBased IndexA { get; } Property Value IAnchoredCollidableBased IndexB Gets the second collidable object in the pair. public IAnchoredCollidableBased IndexB { get; } Property Value IAnchoredCollidableBased MatAB Gets or sets the transformation matrix from object A to object B. public Mat4d MatAB { get; set; } Property Value Mat4d Name Gets or sets the pair name for UI manipulation. public string Name { get; set; } Property Value string SafeDistance Gets or sets the safe distance between the two collidable objects. public double SafeDistance { get; set; } Property Value double Methods Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Collision.CollidableStl.html": {
    "href": "api/Hi.Collision.CollidableStl.html",
    "title": "Class CollidableStl | HiAPI-C# 2025",
    "summary": "Class CollidableStl Namespace Hi.Collision Assembly HiCbtr.dll Collidable Stl. public class CollidableStl : IDisposable, IGetTriTree, ICollidable, IGetCollidable Inheritance object CollidableStl Implements IDisposable IGetTriTree ICollidable IGetCollidable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) CollisionUtil.Detect(ICollidable, ICollidable, Mat4d, double, int) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CollidableStl(IGetStl) Ctor. public CollidableStl(IGetStl iGetStl) Parameters iGetStl IGetStl Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool GetCollidable() Get ICollidable. public ICollidable GetCollidable() Returns ICollidable The collidable object. GetCollidee() Get ICollidee. public ICollidee GetCollidee() Returns ICollidee ICollidee GetTriTree() Get TriTree. public TriTree GetTriTree() Returns TriTree TriTree"
  },
  "api/Hi.Collision.CollisionFlag.html": {
    "href": "api/Hi.Collision.CollisionFlag.html",
    "title": "Enum CollisionFlag | HiAPI-C# 2025",
    "summary": "Enum CollisionFlag Namespace Hi.Collision Assembly HiCbtr.dll Collision flag. The definition is the same as native collision_flag. public enum CollisionFlag Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Collision = 0 Collision. MAY_INSIDE_SAFE_DISTANCE = 1 May or may not be inside the safe distance. OUTSIDE_SAFE_DISTANCE = 2 Outside the safe distance. UNDEFINED = 3 Not defined behavior. _IGNORED = 4 Internal Use Only Remarks The int value is according to severity. The larger is severer."
  },
  "api/Hi.Collision.CollisionIndexPair.html": {
    "href": "api/Hi.Collision.CollisionIndexPair.html",
    "title": "Class CollisionIndexPair | HiAPI-C# 2025",
    "summary": "Class CollisionIndexPair Namespace Hi.Collision Assembly HiMech.dll Represents a pair of collision indices for collision detection. public class CollisionIndexPair : IMakeXmlSource Inheritance object CollisionIndexPair Implements IMakeXmlSource Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CollisionIndexPair(ICollisionIndex, ICollisionIndex) Initializes a new instance of the CollisionIndexPair class with two collision indices. public CollisionIndexPair(ICollisionIndex indexA, ICollisionIndex indexB) Parameters indexA ICollisionIndex The first collision index. indexB ICollisionIndex The second collision index. CollisionIndexPair(XElement, string, IProgress<IMessage>, object[]) Initializes a new instance of the CollisionIndexPair class from XML. public CollisionIndexPair(XElement src, string baseDirectory, IProgress<IMessage> progress, object[] res) Parameters src XElement The XML element containing the pair data. baseDirectory string The base directory for resolving relative paths. progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. res object[] Additional resources for initialization. Fields XName The XML element name for serialization. public static string XName Field Value string Properties CollisionFlag Gets or sets the collision flag indicating the collision status between the two objects. public CollisionFlag CollisionFlag { get; } Property Value CollisionFlag IndexA Gets the first collision index in the pair. public ICollisionIndex IndexA { get; } Property Value ICollisionIndex IndexB Gets the second collision index in the pair. public ICollisionIndex IndexB { get; } Property Value ICollisionIndex MatAB Gets or sets the transformation matrix from object A to object B. public Mat4d MatAB { get; set; } Property Value Mat4d SafeDistance Gets or sets the safe distance between the two collision indices. public double SafeDistance { get; set; } Property Value double Methods Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Collision.CollisionUtil.html": {
    "href": "api/Hi.Collision.CollisionUtil.html",
    "title": "Class CollisionUtil | HiAPI-C# 2025",
    "summary": "Class CollisionUtil Namespace Hi.Collision Assembly HiCbtr.dll Utility of tree grid related structure. public static class CollisionUtil Inheritance object CollisionUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods Detect(CubeTree, TriTree, Mat4d, double, int) Get CollisionFlag between treeA and treeB*matAB. public static CollisionFlag Detect(this CubeTree treeA, TriTree treeB, Mat4d matAB, double safeDistance, int cap = 1024) Parameters treeA CubeTree treeA treeB TriTree treeB matAB Mat4d relative transform matrix to take B to the position relative to A. The mat is Inv(matA)*matB. safeDistance double safe distance for the flag judgement cap int Returns CollisionFlag CollisionFlag Detect(ICollidable, ICollidable, Mat4d, double, int) Get CollisionFlag between collidableA and collidableB*matAB. public static CollisionFlag Detect(this ICollidable collidableA, ICollidable collidableB, Mat4d matAB, double safeDistance = 0, int cap = 1024) Parameters collidableA ICollidable collidable A collidableB ICollidable collidable B matAB Mat4d relative transform matrix to take B to the position relative to A. The mat is Inv(matA)*matB. If one of collidableA and collidableB is null, return OUTSIDE_SAFE_DISTANCE. safeDistance double safe distance for the flag judgement cap int Returns CollisionFlag CollisionFlag Detect(TriTree, TriTree, Mat4d, double, int) Get CollisionFlag between treeA and treeB*matAB. public static CollisionFlag Detect(this TriTree treeA, TriTree treeB, Mat4d matAB, double safeDistance, int cap = 1024) Parameters treeA TriTree treeA treeB TriTree treeB matAB Mat4d relative transform matrix to take B to the position relative to A. The mat is Inv(matA)*matB. safeDistance double safe distance for the flag judgement cap int Returns CollisionFlag CollisionFlag"
  },
  "api/Hi.Collision.FuncAnchoredCollidable.html": {
    "href": "api/Hi.Collision.FuncAnchoredCollidable.html",
    "title": "Class FuncAnchoredCollidable | HiAPI-C# 2025",
    "summary": "Class FuncAnchoredCollidable Namespace Hi.Collision Assembly HiMech.dll Represents a function-based implementation of an anchored collidable object. public class FuncAnchoredCollidable : IAnchoredCollidableBased Inheritance object FuncAnchoredCollidable Implements IAnchoredCollidableBased Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FuncAnchoredCollidable(string, Func<IAnchoredCollidableNode>) Initializes a new instance of the FuncAnchoredCollidable class with a name and a function to get the anchored collidable node. public FuncAnchoredCollidable(string collidableName, Func<IAnchoredCollidableNode> getAnchoredCollidableNodeFunc) Parameters collidableName string The name of the collidable object. getAnchoredCollidableNodeFunc Func<IAnchoredCollidableNode> The function to get the anchored collidable node. Properties CollidableName Gets the name of the collidable object. public string CollidableName { get; set; } Property Value string GetAnchoredCollidableNodeFunc Gets or sets the function to get the anchored collidable node. public Func<IAnchoredCollidableNode> GetAnchoredCollidableNodeFunc { get; set; } Property Value Func<IAnchoredCollidableNode> Methods GetAnchoredCollidableNode() Gets the anchored collidable node associated with this object. public IAnchoredCollidableNode GetAnchoredCollidableNode() Returns IAnchoredCollidableNode The anchored collidable node."
  },
  "api/Hi.Collision.IAnchoredCollidableBased.html": {
    "href": "api/Hi.Collision.IAnchoredCollidableBased.html",
    "title": "Interface IAnchoredCollidableBased | HiAPI-C# 2025",
    "summary": "Interface IAnchoredCollidableBased Namespace Hi.Collision Assembly HiMech.dll Interface for objects that are based on anchored collidable nodes. public interface IAnchoredCollidableBased Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties CollidableName Gets the name of the collidable object. string CollidableName { get; } Property Value string Methods GetAnchoredCollidableNode() Gets the anchored collidable node associated with this object. IAnchoredCollidableNode GetAnchoredCollidableNode() Returns IAnchoredCollidableNode The anchored collidable node."
  },
  "api/Hi.Collision.IAnchoredCollidableLeaf.html": {
    "href": "api/Hi.Collision.IAnchoredCollidableLeaf.html",
    "title": "Interface IAnchoredCollidableLeaf | HiAPI-C# 2025",
    "summary": "Interface IAnchoredCollidableLeaf Namespace Hi.Collision Assembly HiMech.dll Interface for leaf nodes in the anchored collidable hierarchy. A leaf node represents a collidable object that doesn't contain other collidable objects. public interface IAnchoredCollidableLeaf : IAnchoredCollidableNode, IAnchoredCollidableBased, ICollidable Inherited Members IAnchoredCollidableBased.CollidableName IAnchoredCollidableBased.GetAnchoredCollidableNode() ICollidable.GetCollidee() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) CollisionUtil.Detect(ICollidable, ICollidable, Mat4d, double, int) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetCollidableAnchor() Gets the anchor associated with this collidable leaf. Anchor GetCollidableAnchor() Returns Anchor The anchor for this collidable leaf."
  },
  "api/Hi.Collision.IAnchoredCollidableNode.html": {
    "href": "api/Hi.Collision.IAnchoredCollidableNode.html",
    "title": "Interface IAnchoredCollidableNode | HiAPI-C# 2025",
    "summary": "Interface IAnchoredCollidableNode Namespace Hi.Collision Assembly HiMech.dll Base interface for anchored collidable nodes in the collision hierarchy. Do not inherit this interface directly. Only inherit directly from IAnchoredCollidableLeaf and IAnchoredCollidableStem. It is acceptable to inherit from IAnchoredCollidableLeaf and IAnchoredCollidableStem. public interface IAnchoredCollidableNode : IAnchoredCollidableBased Inherited Members IAnchoredCollidableBased.CollidableName IAnchoredCollidableBased.GetAnchoredCollidableNode() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Collision.IAnchoredCollidableStem.html": {
    "href": "api/Hi.Collision.IAnchoredCollidableStem.html",
    "title": "Interface IAnchoredCollidableStem | HiAPI-C# 2025",
    "summary": "Interface IAnchoredCollidableStem Namespace Hi.Collision Assembly HiMech.dll Interface for stem nodes in the anchored collidable hierarchy. A stem node represents a collidable object that contains other collidable objects. public interface IAnchoredCollidableStem : IAnchoredCollidableNode, IAnchoredCollidableBased, IExpandToBox3d Inherited Members IAnchoredCollidableBased.CollidableName IAnchoredCollidableBased.GetAnchoredCollidableNode() IExpandToBox3d.ExpandToBox3d(Box3d) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetAnchoredCollidables() Gets the list of anchored collidable nodes contained by this stem. List<IAnchoredCollidableNode> GetAnchoredCollidables() Returns List<IAnchoredCollidableNode> A list of anchored collidable nodes."
  },
  "api/Hi.Collision.ICollidable.html": {
    "href": "api/Hi.Collision.ICollidable.html",
    "title": "Interface ICollidable | HiAPI-C# 2025",
    "summary": "Interface ICollidable Namespace Hi.Collision Assembly HiCbtr.dll Collidable geometry. public interface ICollidable Extension Methods CollisionUtil.Detect(ICollidable, ICollidable, Mat4d, double, int) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetCollidee() Get ICollidee. ICollidee GetCollidee() Returns ICollidee ICollidee"
  },
  "api/Hi.Collision.ICollidee.html": {
    "href": "api/Hi.Collision.ICollidee.html",
    "title": "Interface ICollidee | HiAPI-C# 2025",
    "summary": "Interface ICollidee Namespace Hi.Collision Assembly HiCbtr.dll Dont inherit the interface. Only TriTree and CubeTree inherit the interface. public interface ICollidee : ICollidable, IExpandToBox3d Inherited Members ICollidable.GetCollidee() IExpandToBox3d.ExpandToBox3d(Box3d) Extension Methods CollisionUtil.Detect(ICollidable, ICollidable, Mat4d, double, int) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Collision.ICollisionArena.html": {
    "href": "api/Hi.Collision.ICollisionArena.html",
    "title": "Interface ICollisionArena | HiAPI-C# 2025",
    "summary": "Interface ICollisionArena Namespace Hi.Collision Assembly HiMech.dll Interface for a topological collision arena that manages collision detection between objects. public interface ICollisionArena : IGetCollisionIndexPairs, IGetAsmb, IGetAnchor, IGetTopoIndex Inherited Members IGetCollisionIndexPairs.GetCollisionIndexPairs() IGetAsmb.GetAsmb() IGetAnchor.GetAnchor() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Collision.ICollisionIndex.html": {
    "href": "api/Hi.Collision.ICollisionIndex.html",
    "title": "Interface ICollisionIndex | HiAPI-C# 2025",
    "summary": "Interface ICollisionIndex Namespace Hi.Collision Assembly HiMech.dll Interface for collision index objects that provide identification and anchoring for collidable objects. public interface ICollisionIndex : IGetCollidable, IMakeXmlSource Inherited Members IGetCollidable.GetCollidable() IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Anchor Gets the anchor point for this collision index. Anchor Anchor { get; } Property Value Anchor Key Gets the unique identifier for this collision index. string Key { get; } Property Value string"
  },
  "api/Hi.Collision.IGetAnchoredCollidablePairs.html": {
    "href": "api/Hi.Collision.IGetAnchoredCollidablePairs.html",
    "title": "Interface IGetAnchoredCollidablePairs | HiAPI-C# 2025",
    "summary": "Interface IGetAnchoredCollidablePairs Namespace Hi.Collision Assembly HiMech.dll Interface for objects that can provide pairs of anchored collidable objects for collision detection. public interface IGetAnchoredCollidablePairs Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetAnchoredCollidablePairs() Gets a list of anchored collidable pairs for collision detection. List<AnchoredCollidablePair> GetAnchoredCollidablePairs() Returns List<AnchoredCollidablePair> A list of anchored collidable pairs."
  },
  "api/Hi.Collision.IGetCollidable.html": {
    "href": "api/Hi.Collision.IGetCollidable.html",
    "title": "Interface IGetCollidable | HiAPI-C# 2025",
    "summary": "Interface IGetCollidable Namespace Hi.Collision Assembly HiCbtr.dll Interface for objects that can provide a collidable object. public interface IGetCollidable Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetCollidable() Get ICollidable. ICollidable GetCollidable() Returns ICollidable The collidable object."
  },
  "api/Hi.Collision.IGetCollisionIndexPairs.html": {
    "href": "api/Hi.Collision.IGetCollisionIndexPairs.html",
    "title": "Interface IGetCollisionIndexPairs | HiAPI-C# 2025",
    "summary": "Interface IGetCollisionIndexPairs Namespace Hi.Collision Assembly HiMech.dll Interface for objects that can provide pairs of collision indices for collision detection. public interface IGetCollisionIndexPairs Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetCollisionIndexPairs() Gets a collection of collision index pairs for collision detection. IEnumerable<CollisionIndexPair> GetCollisionIndexPairs() Returns IEnumerable<CollisionIndexPair> A collection of CollisionIndexPair objects."
  },
  "api/Hi.Collision.IGetDefaultCollidablePairs.html": {
    "href": "api/Hi.Collision.IGetDefaultCollidablePairs.html",
    "title": "Interface IGetDefaultCollidablePairs | HiAPI-C# 2025",
    "summary": "Interface IGetDefaultCollidablePairs Namespace Hi.Collision Assembly HiMech.dll Interface for objects that can provide default pairs of anchored collidable objects. public interface IGetDefaultCollidablePairs Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetDefaultCollidablePairs() Gets a list of default anchored collidable pairs. List<AnchoredCollidablePair> GetDefaultCollidablePairs() Returns List<AnchoredCollidablePair> A list of default anchored collidable pairs."
  },
  "api/Hi.Collision.IGetTriTree.html": {
    "href": "api/Hi.Collision.IGetTriTree.html",
    "title": "Interface IGetTriTree | HiAPI-C# 2025",
    "summary": "Interface IGetTriTree Namespace Hi.Collision Assembly HiCbtr.dll Interface of TriTree Getter. public interface IGetTriTree : ICollidable, IGetCollidable Inherited Members ICollidable.GetCollidee() IGetCollidable.GetCollidable() Extension Methods CollisionUtil.Detect(ICollidable, ICollidable, Mat4d, double, int) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetTriTree() Get TriTree. TriTree GetTriTree() Returns TriTree TriTree"
  },
  "api/Hi.Collision.MechCollisionResult.html": {
    "href": "api/Hi.Collision.MechCollisionResult.html",
    "title": "Class MechCollisionResult | HiAPI-C# 2025",
    "summary": "Class MechCollisionResult Namespace Hi.Collision Assembly HiMech.dll Represents the result of a mechanical collision detection operation. public record MechCollisionResult : IEquatable<MechCollisionResult> Inheritance object MechCollisionResult Implements IEquatable<MechCollisionResult> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MechCollisionResult(Dictionary<ICollidable, CollisionFlag>, List<CollisionIndexPair>, CollisionFlag) Represents the result of a mechanical collision detection operation. public MechCollisionResult(Dictionary<ICollidable, CollisionFlag> CollidableToFlagDictionary, List<CollisionIndexPair> CollisionIndexPairList, CollisionFlag PrimaryCollisionFlag) Parameters CollidableToFlagDictionary Dictionary<ICollidable, CollisionFlag> Dictionary mapping collidable objects to their collision flags. CollisionIndexPairList List<CollisionIndexPair> List of collision index pairs involved in the detection. PrimaryCollisionFlag CollisionFlag The primary collision flag representing the overall collision status. Properties CollidableToFlagDictionary Dictionary mapping collidable objects to their collision flags. public Dictionary<ICollidable, CollisionFlag> CollidableToFlagDictionary { get; init; } Property Value Dictionary<ICollidable, CollisionFlag> CollisionIndexPairList List of collision index pairs involved in the detection. public List<CollisionIndexPair> CollisionIndexPairList { get; init; } Property Value List<CollisionIndexPair> PrimaryCollisionFlag The primary collision flag representing the overall collision status. public CollisionFlag PrimaryCollisionFlag { get; init; } Property Value CollisionFlag"
  },
  "api/Hi.Collision.MechCollisionUtil.html": {
    "href": "api/Hi.Collision.MechCollisionUtil.html",
    "title": "Class MechCollisionUtil | HiAPI-C# 2025",
    "summary": "Class MechCollisionUtil Namespace Hi.Collision Assembly HiMech.dll Utility class providing methods for mechanical collision detection and management. public static class MechCollisionUtil Inheritance object MechCollisionUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods Detect(IEnumerable<CollisionIndexPair>, Dictionary<Anchor, Mat4d>, out Dictionary<ICollidable, CollisionFlag>) Performs collision detection on a collection of collision index pairs. public static CollisionFlag Detect(this IEnumerable<CollisionIndexPair> CollisionIndexPairs, Dictionary<Anchor, Mat4d> matMap, out Dictionary<ICollidable, CollisionFlag> itemToFlag) Parameters CollisionIndexPairs IEnumerable<CollisionIndexPair> The collection of collision index pairs to check. matMap Dictionary<Anchor, Mat4d> Dictionary mapping anchors to transformation matrices. itemToFlag Dictionary<ICollidable, CollisionFlag> Output dictionary mapping collidable objects to their collision flags. Returns CollisionFlag The primary collision flag representing the overall collision status. PrepareCollidableItems(IEnumerable<CollisionIndexPair>) Prepares collidable items for collision detection by ensuring their triangle trees are initialized. public static void PrepareCollidableItems(this IEnumerable<CollisionIndexPair> collisionIndexPairs) Parameters collisionIndexPairs IEnumerable<CollisionIndexPair> The collection of collision index pairs to prepare. ResetCollisionFlags(IEnumerable<CollisionIndexPair>) Resets the collision flags for all collision index pairs to undefined. public static void ResetCollisionFlags(this IEnumerable<CollisionIndexPair> collisionIndexPairs) Parameters collisionIndexPairs IEnumerable<CollisionIndexPair> The collection of collision index pairs to reset."
  },
  "api/Hi.Collision.TriTree.html": {
    "href": "api/Hi.Collision.TriTree.html",
    "title": "Class TriTree | HiAPI-C# 2025",
    "summary": "Class TriTree Namespace Hi.Collision Assembly HiCbtr.dll A wrapper provides native tree-grid-based structure. It wraps NativeStl. public class TriTree : IDisposable, IGetTriTree, ICollidee, ICollidable, IExpandToBox3d, IGetCollidable Inheritance object TriTree Implements IDisposable IGetTriTree ICollidee ICollidable IExpandToBox3d IGetCollidable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods CollisionUtil.Detect(ICollidable, ICollidable, Mat4d, double, int) CollisionUtil.Detect(TriTree, TriTree, Mat4d, double, int) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors TriTree(NativeStl) Ctor. public TriTree(NativeStl nativeStl) Parameters nativeStl NativeStl Native Stl Properties NativeStl For internal. public NativeStl NativeStl { get; set; } Property Value NativeStl TriTreePtr For internal. public nint TriTreePtr { get; set; } Property Value nint Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Remarks If NativeStl is disposed, this object will also be disposed. Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box ~TriTree() protected ~TriTree() GetCollidable() Get ICollidable. public ICollidable GetCollidable() Returns ICollidable The collidable object. GetCollidee() Get ICollidee. public ICollidee GetCollidee() Returns ICollidee ICollidee GetTriTree() Get TriTree. public TriTree GetTriTree() Returns TriTree TriTree"
  },
  "api/Hi.Collision.html": {
    "href": "api/Hi.Collision.html",
    "title": "Namespace Hi.Collision | HiAPI-C# 2025",
    "summary": "Namespace Hi.Collision Classes AnchoredCollidableLeaf Represents a leaf node in the anchored collidable hierarchy. AnchoredCollidablePair Represents a pair of anchored collidable objects for collision detection. CollidableStl Collidable Stl. CollisionIndexPair Represents a pair of collision indices for collision detection. CollisionUtil Utility of tree grid related structure. FuncAnchoredCollidable Represents a function-based implementation of an anchored collidable object. MechCollisionResult Represents the result of a mechanical collision detection operation. MechCollisionUtil Utility class providing methods for mechanical collision detection and management. TriTree A wrapper provides native tree-grid-based structure. It wraps NativeStl. Interfaces IAnchoredCollidableBased Interface for objects that are based on anchored collidable nodes. IAnchoredCollidableLeaf Interface for leaf nodes in the anchored collidable hierarchy. A leaf node represents a collidable object that doesn't contain other collidable objects. IAnchoredCollidableNode Base interface for anchored collidable nodes in the collision hierarchy. Do not inherit this interface directly. Only inherit directly from IAnchoredCollidableLeaf and IAnchoredCollidableStem. It is acceptable to inherit from IAnchoredCollidableLeaf and IAnchoredCollidableStem. IAnchoredCollidableStem Interface for stem nodes in the anchored collidable hierarchy. A stem node represents a collidable object that contains other collidable objects. ICollidable Collidable geometry. ICollidee Dont inherit the interface. Only TriTree and CubeTree inherit the interface. ICollisionArena Interface for a topological collision arena that manages collision detection between objects. ICollisionIndex Interface for collision index objects that provide identification and anchoring for collidable objects. IGetAnchoredCollidablePairs Interface for objects that can provide pairs of anchored collidable objects for collision detection. IGetCollidable Interface for objects that can provide a collidable object. IGetCollisionIndexPairs Interface for objects that can provide pairs of collision indices for collision detection. IGetDefaultCollidablePairs Interface for objects that can provide default pairs of anchored collidable objects. IGetTriTree Interface of TriTree Getter. Enums CollisionFlag Collision flag. The definition is the same as native collision_flag."
  },
  "api/Hi.Collisions.AnchoredCollidabled.html": {
    "href": "api/Hi.Collisions.AnchoredCollidabled.html",
    "title": "Class AnchoredCollidabled | HiAPI-C# 2025",
    "summary": "Class AnchoredCollidabled Namespace Hi.Collisions Assembly HiMech.dll Represents a collidable object that is associated with an Anchor. public class AnchoredCollidabled : IAnchoredCollidabled, IGetCollidable, IGetAnchor, IGetTopoIndex Inheritance object AnchoredCollidabled Implements IAnchoredCollidabled IGetCollidable IGetAnchor IGetTopoIndex Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors AnchoredCollidabled() Initializes a new instance of the AnchoredCollidabled class. public AnchoredCollidabled() AnchoredCollidabled(Anchor, ICollidable) Initializes a new instance of the AnchoredCollidabled class with the specified anchor and collidable. public AnchoredCollidabled(Anchor anchor, ICollidable collidable) Parameters anchor Anchor The anchor bound to the collidable. collidable ICollidable The collidable instance. Properties Anchor Gets or sets the anchor associated with the collidable object. public Anchor Anchor { get; set; } Property Value Anchor Collidable Gets or sets the collidable instance. public ICollidable Collidable { get; set; } Property Value ICollidable Methods GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor GetCollidable() Get ICollidable. public ICollidable GetCollidable() Returns ICollidable The collidable object. GetCollidableAnchor() Gets the anchor associated with the collidable object. public Anchor GetCollidableAnchor() Returns Anchor The Anchor instance."
  },
  "api/Hi.Collisions.IAnchoredCollidabled.html": {
    "href": "api/Hi.Collisions.IAnchoredCollidabled.html",
    "title": "Interface IAnchoredCollidabled | HiAPI-C# 2025",
    "summary": "Interface IAnchoredCollidabled Namespace Hi.Collisions Assembly HiMech.dll Defines a collidable object that has an associated Anchor. public interface IAnchoredCollidabled : IGetCollidable, IGetAnchor, IGetTopoIndex Inherited Members IGetCollidable.GetCollidable() IGetAnchor.GetAnchor() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetCollidableAnchor() Gets the anchor associated with the collidable object. Anchor GetCollidableAnchor() Returns Anchor The Anchor instance."
  },
  "api/Hi.Collisions.html": {
    "href": "api/Hi.Collisions.html",
    "title": "Namespace Hi.Collisions | HiAPI-C# 2025",
    "summary": "Namespace Hi.Collisions Classes AnchoredCollidabled Represents a collidable object that is associated with an Anchor. Interfaces IAnchoredCollidabled Defines a collidable object that has an associated Anchor."
  },
  "api/Hi.Coloring.ColorUtil.html": {
    "href": "api/Hi.Coloring.ColorUtil.html",
    "title": "Class ColorUtil | HiAPI-C# 2025",
    "summary": "Class ColorUtil Namespace Hi.Coloring Assembly HiGeom.dll Utility for handling color. Includes handle of RGB and HSL. public static class ColorUtil Inheritance object ColorUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Properties EnvDiscreteRgbSeed public static int EnvDiscreteRgbSeed { get; set; } Property Value int The seed is applied to GetDiscreteRGB_Env(double, double). ExceptionRed Exception RGB. Also for nan value. public static Vec3d ExceptionRed { get; } Property Value Vec3d Gray Generate gray color. RGB=(0.2, 0.2, 0.2). public static Vec3d Gray { get; } Property Value Vec3d NoValueGreen No value RGB. public static Vec3d NoValueGreen { get; } Property Value Vec3d NullDark Generate dark RGB for null value. RGB=(0,0,0). public static Vec3d NullDark { get; } Property Value Vec3d UndeterminedPurple Undetermined RGB. public static Vec3d UndeterminedPurple { get; } Property Value Vec3d Methods FromDualHexString(string) Parses an RRGGBB hexadecimal string (optionally prefixed with #) back to an RGB color vector with channels in 0~1. Inverse of ToDualHexString(Vec3d) up to 8-bit rounding. public static Vec3d FromDualHexString(string hex) Parameters hex string The hexadecimal color string, e.g. #3fa0c8. Returns Vec3d RGB color vector. GetDiscreteRGBWithoutPurpleAndRed(int, double, double) Get discrete RGB without purple and red color ranges. public static Vec3d GetDiscreteRGBWithoutPurpleAndRed(int seed, double saturation = 1, double light = 0.5) Parameters seed int Color seed. Determines the hue value. saturation double Saturation value of the color. light double Light value of the color. Returns Vec3d RGB color vector without purple and red ranges. GetDiscreteRGB_Env(double, double) Get discrete color using EnvDiscreteRgbSeed. The functionality is the same as GetDiscreteRgb(int, double, double). The function call makes EnvDiscreteRgbSeed plus 1. public static Vec3d GetDiscreteRGB_Env(double saturation = 1, double light = 0.5) Parameters saturation double saturation light double light Returns Vec3d RGB GetDiscreteRgb(int, double, double) Get discrete color(RGB). The term ‘discrete’ means there is big color difference between nearby seed. This function is good to auto set color for lot of components. public static Vec3d GetDiscreteRgb(int seed, double saturation = 1, double light = 0.5) Parameters seed int color seed. Determine the hue value by BinaryDividentSequence(int). saturation double saturation light double light Returns Vec3d RGB GetDiscreteRgbByBoundary(int, double, double, double, double) Get discrete RGB by boundary. public static Vec3d GetDiscreteRgbByBoundary(int seed, double hueBegin = 0, double hueEnd = 1, double saturation = 1, double light = 0.5) Parameters seed int Color seed. Determines the hue value. hueBegin double The beginning of the hue range. hueEnd double The end of the hue range. saturation double Saturation value of the color. light double Light value of the color. Returns Vec3d RGB color vector with boundary. GetGloomyColor(Guid, double, double) Gloomy color (blue tune by default) seeded by a persisted identity. The same Guid always yields the same color — across loads, threads, processes and platforms — unlike GetGloomyColor(object, double, double), whose identity-hash seed is stable only within one thread's allocation order. public static Vec3d GetGloomyColor(this Guid seed, double hueMin = 0.5, double hueMax = 0.7) Parameters seed Guid Persisted identity, e.g. an anchor's Guid. hueMin double The beginning of the hue range. hueMax double The end of the hue range. Returns Vec3d RGB color vector. Remarks Uses an FNV-1a hash over ToByteArray() rather than GetHashCode() or GetHashCode(): the latter are not guaranteed stable across runtimes, and string hashing is randomized per process on .NET Core. GetGloomyColor(object, double, double) The default value is blue tune. public static Vec3d GetGloomyColor(this object seed, double hueMin = 0.5, double hueMax = 0.7) Parameters seed object hueMin double hueMax double Returns Vec3d Remarks The hue is seeded by GetHashCode(). For a type that does not override it, that is the CLR identity hash — drawn per thread on the first call — so the color depends on which thread asks first and in what order, and two loads of the same data get different colors. When a persisted identity is available, prefer GetGloomyColor(Guid, double, double). GetRgb(double, RatioRgbFuncEnum) Get RGB by funcEnum. public static Vec3d GetRgb(double v, RatioRgbFuncEnum funcEnum) Parameters v double value funcEnum RatioRgbFuncEnum function enum Returns Vec3d RGB GetRgbByErf(double) Get RGB interpolated from blue to green to red by erf function. The range suits for -2 to 0 to 2. public static Vec3d GetRgbByErf(double v) Parameters v double input of the erf Returns Vec3d RGB GetRgbByHslOffset(Vec3d, Vec3d) Convert RGB by HSL offset. This is a three step process: RGB convert to HSL, HSL+=hslOffset, HSL convert to RGB. public static Vec3d GetRgbByHslOffset(Vec3d rgb, Vec3d hslOffset) Parameters rgb Vec3d RGB hslOffset Vec3d HSL offset Returns Vec3d RGB GetRgbByLinearRatio(double) 0 ~ 0.5 ~ 1 is linearly interpolated to blue to green to red. The below range data is pure blue. The exceeding range data is pure red. public static Vec3d GetRgbByLinearRatio(double ratio) Parameters ratio double the interpolation range is 0~1 Returns Vec3d RGB GetRgbByNormalizedErf(double) 0 ~ 0.5 ~ 1 is interpolated to blue to green to red. The below range data is pure blue. The exceeding range data is pure red. return GetRgbByLinearRatio(MathUtil.Erf(ratio*2) / MathUtil.Erf(2)); public static Vec3d GetRgbByNormalizedErf(double ratio) Parameters ratio double the interpolation range is 0~1 Returns Vec3d RGB GetRgbByNormalizedPositiveErf(double) 0 ~ 0.5 ~ 1 is interpolated to blue to green to red. The below range data is pure blue. The exceeding range data is pure red. Only the positive half form is used. return GetRgbByLinearRatio(MathUtil.Erf(ratio*2) / MathUtil.Erf(2)); public static Vec3d GetRgbByNormalizedPositiveErf(double ratio) Parameters ratio double the interpolation range is 0~1 Returns Vec3d RGB GetRgbByPositiveErf(double) Get RGB interpolated from blue to green to red by modified erf function. public static Vec3d GetRgbByPositiveErf(double v) Parameters v double input of the modified erf Returns Vec3d color Remarks If v is equal or lower than 0, the color is blue; if v is equal or larger than 1, the color is red; otherwise, the color varied from blue to green to red by modified erf function. GetRgbByPositiveErf(double, double, double) Get RGB interpolated from blue to green to red by modified erf function. public static Vec3d GetRgbByPositiveErf(double v, double floor, double ceil) Parameters v double input of the modified erf floor double floor value of v ceil double ceil value of v Returns Vec3d color Remarks If v is equal or lower than floor, the color is blue; if v is equal or larger than ceil, the color is red; otherwise, the color varied from blue to green to red by modified erf function. HslToRgb(Vec3d) Convert color convention from HSL to RGB. public static Vec3d HslToRgb(Vec3d hsl) Parameters hsl Vec3d HSL Returns Vec3d RGB HslToRgb(double, double, double) Convert color convention from HSL to RGB. public static Vec3d HslToRgb(double hue, double saturation, double light) Parameters hue double hue saturation double saturation light double light Returns Vec3d RGB RgbToHsl(Vec3d) Convert color convention from RGB to HSL. public static Vec3d RgbToHsl(Vec3d rgb) Parameters rgb Vec3d RGB Returns Vec3d HSL RgbToHsl(double, double, double) Convert color convention from RGB to HSL. public static Vec3d RgbToHsl(double r, double g, double b) Parameters r double red g double green b double blue Returns Vec3d HSL ToDualHexString(Vec3d) Converts an RGB color vector to a hexadecimal string representation. public static string ToDualHexString(Vec3d rgb) Parameters rgb Vec3d The RGB color vector to convert. Returns string A hexadecimal string representation of the RGB color."
  },
  "api/Hi.Coloring.DictionaryColorGuide.html": {
    "href": "api/Hi.Coloring.DictionaryColorGuide.html",
    "title": "Class DictionaryColorGuide | HiAPI-C# 2025",
    "summary": "Class DictionaryColorGuide Namespace Hi.Coloring Assembly HiMech.dll A color guide that manages a dictionary of color guides and allows selection of one active guide. public class DictionaryColorGuide : IColorGuide, IMakeXmlSource, IGetColorGuide Inheritance object DictionaryColorGuide Implements IColorGuide IMakeXmlSource IGetColorGuide Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors DictionaryColorGuide() Initializes a new instance of the DictionaryColorGuide class. public DictionaryColorGuide() DictionaryColorGuide(DictionaryColorGuide) Initializes a new instance of the DictionaryColorGuide class by copying from another instance. public DictionaryColorGuide(DictionaryColorGuide src) Parameters src DictionaryColorGuide The source color guide to copy from. DictionaryColorGuide(XElement, string, IProgress<IMessage>, Dictionary<string, object>) Initializes a new instance of the DictionaryColorGuide class from XML. public DictionaryColorGuide(XElement src, string baseDirectory, IProgress<IMessage> progress, Dictionary<string, object> colorGuideCtorArgDictionary) Parameters src XElement The XML element containing the color guide data. baseDirectory string The base directory for resolving relative paths. progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. colorGuideCtorArgDictionary Dictionary<string, object> Dictionary containing constructor arguments for color guides. Properties KeyToColorGuide Gets or sets the dictionary mapping keys to color guides. public Dictionary<string, IColorGuide> KeyToColorGuide { get; set; } Property Value Dictionary<string, IColorGuide> SelectedColorGuide Gets the currently selected color guide. public IColorGuide SelectedColorGuide { get; } Property Value IColorGuide SelectedKey Gets or sets the key of the currently selected color guide. public string SelectedKey { get; set; } Property Value string XName Name for XML IO. public static string XName { get; } Property Value string Methods GetColorGuide() Get IColorGuide. public IColorGuide GetColorGuide() Returns IColorGuide IColorGuide GetRgb(object) Get rgb bystep. public Vec3d GetRgb(object step) Parameters step object step Returns Vec3d rgb GetRgbWithPriority(object, out Vec3d, out double) Get color with the showing priority if the showing area overlapped by shrinking. Only effect on CubeTree. public void GetRgbWithPriority(object step, out Vec3d rgb, out double attachmentPriority) Parameters step object step rgb Vec3d rgb attachmentPriority double priority. Larger one takes priority. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. RefreshSelectedColorGuide() Refreshes the selected color guide based on the current SelectedKey. public void RefreshSelectedColorGuide() Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Coloring.DiscreteQuantityColorGuide.html": {
    "href": "api/Hi.Coloring.DiscreteQuantityColorGuide.html",
    "title": "Class DiscreteQuantityColorGuide | HiAPI-C# 2025",
    "summary": "Class DiscreteQuantityColorGuide Namespace Hi.Coloring Assembly HiMech.dll A color guide that assigns colors based on discrete quantity values. public class DiscreteQuantityColorGuide : IColorGuide, IMakeXmlSource, IGetColorGuide Inheritance object DiscreteQuantityColorGuide Implements IColorGuide IMakeXmlSource IGetColorGuide Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors DiscreteQuantityColorGuide() Initializes a new instance of the DiscreteQuantityColorGuide class. public DiscreteQuantityColorGuide() DiscreteQuantityColorGuide(string) Initializes a new instance of the DiscreteQuantityColorGuide class with a specified quantity key. public DiscreteQuantityColorGuide(string quantityKey) Parameters quantityKey string The key used to retrieve quantity values. DiscreteQuantityColorGuide(XElement) Initializes a new instance of the DiscreteQuantityColorGuide class from XML. public DiscreteQuantityColorGuide(XElement src) Parameters src XElement The XML element containing the color guide data. Properties QuantityKey Gets or sets the key used to retrieve the quantity value. public string QuantityKey { get; set; } Property Value string XName Name for XML IO. public static string XName { get; } Property Value string Methods GetColorGuide() Get IColorGuide. public IColorGuide GetColorGuide() Returns IColorGuide IColorGuide GetRgb(object) Get rgb bystep. public Vec3d GetRgb(object step) Parameters step object step Returns Vec3d rgb GetRgbWithPriority(object, out Vec3d, out double) Get color with the showing priority if the showing area overlapped by shrinking. Only effect on CubeTree. public void GetRgbWithPriority(object step, out Vec3d rgb, out double attachmentPriority) Parameters step object step rgb Vec3d rgb attachmentPriority double priority. Larger one takes priority. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Coloring.FilteredColorGuide.html": {
    "href": "api/Hi.Coloring.FilteredColorGuide.html",
    "title": "Class FilteredColorGuide | HiAPI-C# 2025",
    "summary": "Class FilteredColorGuide Namespace Hi.Coloring Assembly HiMech.dll A color guide that combines a filter color guide with a dictionary color guide. public class FilteredColorGuide : IColorGuide, IMakeXmlSource, IGetColorGuide Inheritance object FilteredColorGuide Implements IColorGuide IMakeXmlSource IGetColorGuide Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FilteredColorGuide() Initializes a new instance of the FilteredColorGuide class. public FilteredColorGuide() FilteredColorGuide(XElement, string, IProgress<IMessage>, Dictionary<string, object>) Initializes a new instance of the FilteredColorGuide class from XML. public FilteredColorGuide(XElement src, string baseDirectory, IProgress<IMessage> progress, Dictionary<string, object> colorGuideCtorArgDictionary) Parameters src XElement The XML element containing the color guide data. baseDirectory string The base directory for resolving relative paths. progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. colorGuideCtorArgDictionary Dictionary<string, object> Dictionary containing constructor arguments for color guides. Properties DictionaryColorGuide Gets or sets the dictionary color guide that is used when the filter color guide returns null. public DictionaryColorGuide DictionaryColorGuide { get; set; } Property Value DictionaryColorGuide FilterColorGuide Gets or sets the filter color guide that is applied first. public IColorGuide FilterColorGuide { get; set; } Property Value IColorGuide XName Name for XML IO. public static string XName { get; } Property Value string Methods GetColorGuide() Get IColorGuide. public IColorGuide GetColorGuide() Returns IColorGuide IColorGuide GetRgb(object) Get rgb bystep. public Vec3d GetRgb(object step) Parameters step object step Returns Vec3d rgb GetRgbWithPriority(object, out Vec3d, out double) Get color with the showing priority if the showing area overlapped by shrinking. Only effect on CubeTree. public void GetRgbWithPriority(object step, out Vec3d rgb, out double attachmentPriority) Parameters step object step rgb Vec3d rgb attachmentPriority double priority. Larger one takes priority. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Coloring.FuncRangeColorGuide.html": {
    "href": "api/Hi.Coloring.FuncRangeColorGuide.html",
    "title": "Class FuncRangeColorGuide | HiAPI-C# 2025",
    "summary": "Class FuncRangeColorGuide Namespace Hi.Coloring Assembly HiMech.dll A color guide that uses a function to get a numeric value and maps it to a color using a range color rule. public class FuncRangeColorGuide : IColorGuide, IMakeXmlSource, IGetColorGuide, IGetRangeColorRule Inheritance object FuncRangeColorGuide Implements IColorGuide IMakeXmlSource IGetColorGuide IGetRangeColorRule Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FuncRangeColorGuide(Func<object, double?>, RangeColorRule) Initializes a new instance of the FuncRangeColorGuide class. public FuncRangeColorGuide(Func<object, double?> colorIndexFunc, RangeColorRule rangeColorRule) Parameters colorIndexFunc Func<object, double?> The function to get the numeric value for coloring. rangeColorRule RangeColorRule The rule that maps numeric values to colors. FuncRangeColorGuide(XElement, Func<object, double?>) Initializes a new instance of the FuncRangeColorGuide class from XML. public FuncRangeColorGuide(XElement src, Func<object, double?> colorIndexFunc) Parameters src XElement The XML element containing the color guide data. colorIndexFunc Func<object, double?> The function to get the numeric value for coloring. Properties ColorIndexFunc Gets or sets the function that extracts a numeric value from the input object for coloring. public Func<object, double?> ColorIndexFunc { get; set; } Property Value Func<object, double?> RangeColorRule Gets or sets the rule that maps numeric values to colors. public RangeColorRule RangeColorRule { get; set; } Property Value RangeColorRule XName Name for XML IO. public static string XName { get; } Property Value string Methods GetColorGuide() Get IColorGuide. public IColorGuide GetColorGuide() Returns IColorGuide IColorGuide GetRangeColorRule() Gets the range color rule. public RangeColorRule GetRangeColorRule() Returns RangeColorRule The range color rule. GetRgb(object) Get rgb bystep. public Vec3d GetRgb(object step) Parameters step object step Returns Vec3d rgb GetRgbWithPriority(object, out Vec3d, out double) Get color with the showing priority if the showing area overlapped by shrinking. Only effect on CubeTree. public void GetRgbWithPriority(object step, out Vec3d rgb, out double attachmentPriority) Parameters step object step rgb Vec3d rgb attachmentPriority double priority. Larger one takes priority. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Coloring.IColorGuide.html": {
    "href": "api/Hi.Coloring.IColorGuide.html",
    "title": "Interface IColorGuide | HiAPI-C# 2025",
    "summary": "Interface IColorGuide Namespace Hi.Coloring Assembly HiMech.dll Interface of setting color and the rendering priority. public interface IColorGuide : IMakeXmlSource, IGetColorGuide Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) IGetColorGuide.GetColorGuide() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetRgb(object) Get rgb bystep. Vec3d GetRgb(object step) Parameters step object step Returns Vec3d rgb GetRgbWithPriority(object, out Vec3d, out double) Get color with the showing priority if the showing area overlapped by shrinking. Only effect on CubeTree. void GetRgbWithPriority(object step, out Vec3d rgb, out double attachmentPriority) Parameters step object step rgb Vec3d rgb attachmentPriority double priority. Larger one takes priority."
  },
  "api/Hi.Coloring.IColorGuideProperty.html": {
    "href": "api/Hi.Coloring.IColorGuideProperty.html",
    "title": "Interface IColorGuideProperty | HiAPI-C# 2025",
    "summary": "Interface IColorGuideProperty Namespace Hi.Coloring Assembly HiMech.dll Interface for objects that have a color guide property. public interface IColorGuideProperty Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties ColorGuide Gets or sets the color guide associated with this object. IColorGuide ColorGuide { get; set; } Property Value IColorGuide"
  },
  "api/Hi.Coloring.IGetColorGuide.html": {
    "href": "api/Hi.Coloring.IGetColorGuide.html",
    "title": "Interface IGetColorGuide | HiAPI-C# 2025",
    "summary": "Interface IGetColorGuide Namespace Hi.Coloring Assembly HiMech.dll Interface of GetColorGuide(). public interface IGetColorGuide Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetColorGuide() Get IColorGuide. IColorGuide GetColorGuide() Returns IColorGuide IColorGuide"
  },
  "api/Hi.Coloring.IGetRangeColorRule.html": {
    "href": "api/Hi.Coloring.IGetRangeColorRule.html",
    "title": "Interface IGetRangeColorRule | HiAPI-C# 2025",
    "summary": "Interface IGetRangeColorRule Namespace Hi.Coloring Assembly HiGeom.dll Interface for retrieving a range color rule. public interface IGetRangeColorRule Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetRangeColorRule() Gets the range color rule. RangeColorRule GetRangeColorRule() Returns RangeColorRule The range color rule."
  },
  "api/Hi.Coloring.IGetRgb.html": {
    "href": "api/Hi.Coloring.IGetRgb.html",
    "title": "Interface IGetRgb | HiAPI-C# 2025",
    "summary": "Interface IGetRgb Namespace Hi.Coloring Assembly HiGeom.dll Rgb getter interface public interface IGetRgb Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetRgb() Get RGB. Vec3d GetRgb() Returns Vec3d RGB"
  },
  "api/Hi.Coloring.IGetRgbWithPriority.html": {
    "href": "api/Hi.Coloring.IGetRgbWithPriority.html",
    "title": "Interface IGetRgbWithPriority | HiAPI-C# 2025",
    "summary": "Interface IGetRgbWithPriority Namespace Hi.Coloring Assembly HiMech.dll Interface ofGetRgbWithPriority(out Vec3d, out double). public interface IGetRgbWithPriority Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetRgbWithPriority(out Vec3d, out double) Get color with the showing priority if the showing area overlapped by shrinking. Only effect on CubeTree. void GetRgbWithPriority(out Vec3d rgb, out double priority) Parameters rgb Vec3d rgb priority double priority"
  },
  "api/Hi.Coloring.PlainColorGuide.html": {
    "href": "api/Hi.Coloring.PlainColorGuide.html",
    "title": "Class PlainColorGuide | HiAPI-C# 2025",
    "summary": "Class PlainColorGuide Namespace Hi.Coloring Assembly HiMech.dll A color guide that provides a constant color value. public class PlainColorGuide : IColorGuide, IMakeXmlSource, IGetColorGuide Inheritance object PlainColorGuide Implements IColorGuide IMakeXmlSource IGetColorGuide Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors PlainColorGuide() Initializes a new instance of the PlainColorGuide class. public PlainColorGuide() PlainColorGuide(XElement) Initializes a new instance of the PlainColorGuide class from XML. public PlainColorGuide(XElement src) Parameters src XElement The XML element containing the color guide data. Properties Rgb Gets or sets the RGB color value. public Vec3d Rgb { get; set; } Property Value Vec3d XName Name for XML IO. public static string XName { get; } Property Value string Methods GetColorGuide() Get IColorGuide. public IColorGuide GetColorGuide() Returns IColorGuide IColorGuide GetRgb(object) Get rgb bystep. public Vec3d GetRgb(object step) Parameters step object step Returns Vec3d rgb GetRgbWithPriority(object, out Vec3d, out double) Get color with the showing priority if the showing area overlapped by shrinking. Only effect on CubeTree. public void GetRgbWithPriority(object step, out Vec3d rgb, out double attachmentPriority) Parameters step object step rgb Vec3d rgb attachmentPriority double priority. Larger one takes priority. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Coloring.QuantityColorGuide.html": {
    "href": "api/Hi.Coloring.QuantityColorGuide.html",
    "title": "Class QuantityColorGuide | HiAPI-C# 2025",
    "summary": "Class QuantityColorGuide Namespace Hi.Coloring Assembly HiMech.dll A color guide that maps numeric quantities to colors using a range color rule. public class QuantityColorGuide : IColorGuide, IMakeXmlSource, IGetColorGuide, IGetRangeColorRule Inheritance object QuantityColorGuide Implements IColorGuide IMakeXmlSource IGetColorGuide IGetRangeColorRule Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors QuantityColorGuide() Initializes a new instance of the QuantityColorGuide class. public QuantityColorGuide() QuantityColorGuide(string, RangeColorRule) Initializes a new instance of the QuantityColorGuide class with specified quantity key and range color rule. public QuantityColorGuide(string quantityKey, RangeColorRule rangeColorRule) Parameters quantityKey string The key used to retrieve quantity values. rangeColorRule RangeColorRule The rule that maps numeric values to colors. QuantityColorGuide(XElement) Initializes a new instance of the QuantityColorGuide class from XML. public QuantityColorGuide(XElement src) Parameters src XElement The XML element containing the color guide data. Properties QuantityKey Gets or sets the key used to retrieve the quantity value. public string QuantityKey { get; set; } Property Value string RangeColorRule Gets or sets the rule that maps numeric values to colors. public RangeColorRule RangeColorRule { get; set; } Property Value RangeColorRule XName Name for XML IO. public static string XName { get; } Property Value string Methods GetColorGuide() Get IColorGuide. public IColorGuide GetColorGuide() Returns IColorGuide IColorGuide GetRangeColorRule() Gets the range color rule. public RangeColorRule GetRangeColorRule() Returns RangeColorRule The range color rule. GetRgb(object) Get rgb bystep. public Vec3d GetRgb(object step) Parameters step object step Returns Vec3d rgb GetRgbWithPriority(object, out Vec3d, out double) Get color with the showing priority if the showing area overlapped by shrinking. Only effect on CubeTree. public void GetRgbWithPriority(object step, out Vec3d rgb, out double attachmentPriority) Parameters step object step rgb Vec3d rgb attachmentPriority double priority. Larger one takes priority. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Coloring.RangeColorRule.html": {
    "href": "api/Hi.Coloring.RangeColorRule.html",
    "title": "Class RangeColorRule | HiAPI-C# 2025",
    "summary": "Class RangeColorRule Namespace Hi.Coloring Assembly HiGeom.dll Defines a rule for mapping numeric values to colors based on a range. public class RangeColorRule : IMakeXmlSource, IGetRangeColorRule Inheritance object RangeColorRule Implements IMakeXmlSource IGetRangeColorRule Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) XmlUtil.MakeXmlSourceToFile(IMakeXmlSource, string, bool) XmlUtil.MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) XmlUtil.SaveToByteArrayAsync(IMakeXmlSource, string) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors RangeColorRule() Ctor. public RangeColorRule() RangeColorRule(double, double, RatioRgbFuncEnum) Constructor with range and color function specification. public RangeColorRule(double floor, double ceiling, RatioRgbFuncEnum ratioRgbFuncEnum = RatioRgbFuncEnum.NormalizedPositiveErf) Parameters floor double The lower bound of the range. ceiling double The upper bound of the range. ratioRgbFuncEnum RatioRgbFuncEnum The function to map ratio values to RGB colors. RangeColorRule(XElement) Ctor. public RangeColorRule(XElement src) Parameters src XElement XML Fields RatioRgbFuncEnum The function used to map ratio values to RGB colors. public RatioRgbFuncEnum RatioRgbFuncEnum Field Value RatioRgbFuncEnum Properties Ceiling Gets or sets the upper bound of the range. public double Ceiling { get; set; } Property Value double Floor Gets or sets the lower bound of the range. public double Floor { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods GetRangeColorRule() Gets the range color rule. public RangeColorRule GetRangeColorRule() Returns RangeColorRule The range color rule. GetRgb(double) Gets the RGB color for a given value based on the range and color function. public Vec3d GetRgb(double v) Parameters v double The value to convert to a color. Returns Vec3d RGB color vector. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Coloring.RatioRgbFuncEnum.html": {
    "href": "api/Hi.Coloring.RatioRgbFuncEnum.html",
    "title": "Enum RatioRgbFuncEnum | HiAPI-C# 2025",
    "summary": "Enum RatioRgbFuncEnum Namespace Hi.Coloring Assembly HiGeom.dll Ratio-based RGB function enum. public enum RatioRgbFuncEnum Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Linear = 2 Represent GetRgbByLinearRatio(double). NormalizedErf = 1 Represent GetRgbByErf(double). NormalizedPositiveErf = 0 Represent GetRgbByPositiveErf(double)."
  },
  "api/Hi.Coloring.RgbSeed.html": {
    "href": "api/Hi.Coloring.RgbSeed.html",
    "title": "Class RgbSeed | HiAPI-C# 2025",
    "summary": "Class RgbSeed Namespace Hi.Coloring Assembly HiGeom.dll A simple object contains RGB value. public class RgbSeed : IGetRgb, IMakeXmlSource Inheritance object RgbSeed Implements IGetRgb IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) XmlUtil.MakeXmlSourceToFile(IMakeXmlSource, string, bool) XmlUtil.MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) XmlUtil.SaveToByteArrayAsync(IMakeXmlSource, string) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors RgbSeed() Ctor. public RgbSeed() RgbSeed(Vec3d) Ctor. public RgbSeed(Vec3d rgb) Parameters rgb Vec3d RGB RgbSeed(XElement) Ctor. public RgbSeed(XElement src) Parameters src XElement XML Properties Rgb RGB. public Vec3d Rgb { get; set; } Property Value Vec3d XName Name for XML IO. public static string XName { get; } Property Value string Methods GetRgb() Get RGB. public Vec3d GetRgb() Returns Vec3d RGB MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Coloring.html": {
    "href": "api/Hi.Coloring.html",
    "title": "Namespace Hi.Coloring | HiAPI-C# 2025",
    "summary": "Namespace Hi.Coloring Classes ColorUtil Utility for handling color. Includes handle of RGB and HSL. DictionaryColorGuide A color guide that manages a dictionary of color guides and allows selection of one active guide. DiscreteQuantityColorGuide A color guide that assigns colors based on discrete quantity values. FilteredColorGuide A color guide that combines a filter color guide with a dictionary color guide. FuncRangeColorGuide A color guide that uses a function to get a numeric value and maps it to a color using a range color rule. PlainColorGuide A color guide that provides a constant color value. QuantityColorGuide A color guide that maps numeric quantities to colors using a range color rule. RangeColorRule Defines a rule for mapping numeric values to colors based on a range. RgbSeed A simple object contains RGB value. Interfaces IColorGuide Interface of setting color and the rendering priority. IColorGuideProperty Interface for objects that have a color guide property. IGetColorGuide Interface of GetColorGuide(). IGetRangeColorRule Interface for retrieving a range color rule. IGetRgb Rgb getter interface IGetRgbWithPriority Interface ofGetRgbWithPriority(out Vec3d, out double). Enums RatioRgbFuncEnum Ratio-based RGB function enum."
  },
  "api/Hi.Common.BinIoUtil.html": {
    "href": "api/Hi.Common.BinIoUtil.html",
    "title": "Class BinIoUtil | HiAPI-C# 2025",
    "summary": "Class BinIoUtil Namespace Hi.Common Assembly HiGeom.dll Utility class for binary I/O operations. public static class BinIoUtil Inheritance object BinIoUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetBytesWithWriter(Action<BinaryWriter>) Gets a byte array by executing an action with a BinaryWriter. public static byte[] GetBytesWithWriter(Action<BinaryWriter> action) Parameters action Action<BinaryWriter> The action to execute with the BinaryWriter. Returns byte[] The resulting byte array. GetWithReader<T>(Func<BinaryReader, T>, byte[]) Gets a result by executing a function with a BinaryReader created from the provided byte array. public static T GetWithReader<T>(Func<BinaryReader, T> Func, byte[] bytes) Parameters Func Func<BinaryReader, T> The function to execute with the BinaryReader. bytes byte[] The byte array to read from. Returns T The result of the function execution. Type Parameters T The type of the result. RunWithReader(Action<BinaryReader>, byte[]) Executes an action with a BinaryReader created from the provided byte array. public static void RunWithReader(Action<BinaryReader> action, byte[] bytes) Parameters action Action<BinaryReader> The action to execute with the BinaryReader. bytes byte[] The byte array to read from. ToBytes(IWriteBin) Converts an object implementing IWriteBin interface to a byte array. public static byte[] ToBytes(this IWriteBin src) Parameters src IWriteBin The source object that implements IWriteBin. Returns byte[] The byte array representation of the object."
  },
  "api/Hi.Common.BitUtil.html": {
    "href": "api/Hi.Common.BitUtil.html",
    "title": "Class BitUtil | HiAPI-C# 2025",
    "summary": "Class BitUtil Namespace Hi.Common Assembly HiGeom.dll Utility for bit control for integer. public static class BitUtil Inheritance object BitUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetBit(int, int) Get bit from the given position of the target integer. public static bool GetBit(this int src, int pos) Parameters src int target integer pos int the bit position Returns bool the bit at the given position GetSetBit(int, int, bool) Sets a bit at the specified position and returns the modified value without changing the original. public static int GetSetBit(this int src, int pos, bool v) Parameters src int Source integer value pos int Bit position to set v bool Value to set (true for 1, false for 0) Returns int The modified integer with the bit set at the specified position SetBit(ref int, int, bool) set bit value at given position of an integer public static int SetBit(this ref int src, int pos, bool v) Parameters src int target integer pos int the bit position v bool given value Returns int the target integer SwitchBit(BitArray, int) Switches (toggles) the bit at the specified position in a BitArray. public static BitArray SwitchBit(this BitArray hdl, int pos) Parameters hdl BitArray The BitArray to modify pos int The position of the bit to toggle Returns BitArray The modified BitArray"
  },
  "api/Hi.Common.BlockingTimer.html": {
    "href": "api/Hi.Common.BlockingTimer.html",
    "title": "Class BlockingTimer | HiAPI-C# 2025",
    "summary": "Class BlockingTimer Namespace Hi.Common Assembly HiGeom.dll Timer use one task and delay each event call. The delay time is Period, counted from the previous trigger to the nest trigger. The first function call does no intending delay. If the execution time is over the Period, no delay between the triggers. public class BlockingTimer : IMakeXmlSource, IDisposable Inheritance object BlockingTimer Implements IMakeXmlSource IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) XmlUtil.MakeXmlSourceToFile(IMakeXmlSource, string, bool) XmlUtil.MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) XmlUtil.SaveToByteArrayAsync(IMakeXmlSource, string) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors BlockingTimer() Ctor. public BlockingTimer() BlockingTimer(TimeSpan) Initializes a new instance of the BlockingTimer class with the specified period. public BlockingTimer(TimeSpan period) Parameters period TimeSpan The time interval between timer events BlockingTimer(XElement) Constructor that initializes the timer from XML data. public BlockingTimer(XElement src) Parameters src XElement XML element containing timer configuration Fields XName XML element name for serialization. public static string XName Field Value string Properties Period The time period between timer events. public TimeSpan Period { get; set; } Property Value TimeSpan WorkingTask Gets the task that represents the timer's working process. public Task WorkingTask { get; } Property Value Task Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool EnsureRunOnce() Ensures the timer runs at least once. public Task EnsureRunOnce() Returns Task The task representing the timer's working process MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Start() Starts the timer in long-term mode. public Task Start() Returns Task The task representing the timer's working process Stop() Stops the timer and cancels any ongoing operations. public Task Stop() Returns Task The task representing the timer's working process Events Elapsed Event that is triggered when the timer elapses. public event Action<CancellationToken> Elapsed Event Type Action<CancellationToken>"
  },
  "api/Hi.Common.BytesUtil.html": {
    "href": "api/Hi.Common.BytesUtil.html",
    "title": "Class BytesUtil | HiAPI-C# 2025",
    "summary": "Class BytesUtil Namespace Hi.Common Assembly HiGeom.dll Utility class for byte array operations and memory size conversions. public static class BytesUtil Inheritance object BytesUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods ConcatByteArray(IEnumerable<byte[]>) Concatenates multiple byte arrays into a single byte array. public static byte[] ConcatByteArray(this IEnumerable<byte[]> src_) Parameters src_ IEnumerable<byte[]> The source byte arrays to concatenate. Returns byte[] A single byte array containing all the bytes from the source arrays. FromBytes<T>(byte[]) Converts a byte array to a structure. public static T FromBytes<T>(byte[] arr) where T : new() Parameters arr byte[] The byte array containing the structure data. Returns T The structure created from the byte array. Type Parameters T The type of the structure to create. GetMemorySizeValueUnit(long) Gets the value and unit for a memory size in bytes. public static (double val, string unit) GetMemorySizeValueUnit(long num) Parameters num long The size in bytes. Returns (double val, string unit) A tuple containing the converted value and the appropriate unit. SplitByteArray(IEnumerable<byte>, int, bool) Splits a byte array into multiple arrays of a specified size. public static byte[][] SplitByteArray(this IEnumerable<byte> src_, int sliceSize, bool allowReferenceBySource = false) Parameters src_ IEnumerable<byte> The source byte enumerable to split. sliceSize int The size of each slice. allowReferenceBySource bool If true and the source array is smaller than or equal to the slice size, returns the source array directly. Returns byte[][] An array of byte arrays, each containing a slice of the original array. ToBytes(BitArray) Converts a BitArray to a byte array. public static byte[] ToBytes(this BitArray bitArray) Parameters bitArray BitArray The BitArray to convert. Returns byte[] A byte array representing the BitArray. ToBytes<T>(T) Converts a structure to a byte array. public static byte[] ToBytes<T>(T str) Parameters str T The structure to convert. Returns byte[] A byte array containing the structure data. Type Parameters T The type of the structure to convert. ToLongByMemorySizeString(string) Parses a memory size string (e.g., “10MB”, “2.5GB”) into a long value representing bytes. public static long ToLongByMemorySizeString(this string memorySizeString) Parameters memorySizeString string The memory size string to parse. Returns long The parsed value in bytes. Exceptions FormatException Thrown when the parsing fails. ToMemorySizeString(int, string) Converts an integer value representing bytes to a formatted memory size string. public static string ToMemorySizeString(this int num, string format = \"{0,6:###.00} {1,-2:##}\") Parameters num int The size in bytes. format string The format string to use for formatting the output. Returns string A formatted string representing the memory size. ToMemorySizeString(long, string) Converts a long value representing bytes to a formatted memory size string. public static string ToMemorySizeString(this long num, string format = \"{0,6:###.00} {1,-2:##}\") Parameters num long The size in bytes. format string The format string to use for formatting the output. Returns string A formatted string representing the memory size. TryParseLongByMemorySizeString(string, out long) Tries to parse a memory size string (e.g., “10MB”, “2.5GB”) into a long value representing bytes. public static bool TryParseLongByMemorySizeString(this string memorySizeString, out long dst) Parameters memorySizeString string The memory size string to parse. dst long When this method returns, contains the parsed value if the parsing succeeded, or long.MaxValue if the parsing failed. Returns bool true if the parsing succeeded; otherwise, false."
  },
  "api/Hi.Common.Collections.DictionaryUtil.html": {
    "href": "api/Hi.Common.Collections.DictionaryUtil.html",
    "title": "Class DictionaryUtil | HiAPI-C# 2025",
    "summary": "Class DictionaryUtil Namespace Hi.Common.Collections Assembly HiGeom.dll Utility class providing extension methods for dictionary operations. public static class DictionaryUtil Inheritance object DictionaryUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetOrCreate<TKey, TValue>(IDictionary<TKey, TValue>, TKey) Gets the value for key, or creates a new TValue via its parameterless constructor, stores it in the dictionary, and returns it. public static TValue GetOrCreate<TKey, TValue>(this IDictionary<TKey, TValue> src, TKey key) where TValue : new() Parameters src IDictionary<TKey, TValue> key TKey Returns TValue Type Parameters TKey TValue GetOrCreate<TKey, TValue>(IDictionary<TKey, TValue>, TKey, Func<TValue>) Gets the value for key, or invokes factory to create, store, and return a new value if the key is absent. public static TValue GetOrCreate<TKey, TValue>(this IDictionary<TKey, TValue> src, TKey key, Func<TValue> factory) Parameters src IDictionary<TKey, TValue> key TKey factory Func<TValue> Returns TValue Type Parameters TKey TValue GetOrCreate<TKey, TValue>(IDictionary<TKey, TValue>, TKey, TValue) Gets the value for key, or stores and returns defaultValue if the key is absent. public static TValue GetOrCreate<TKey, TValue>(this IDictionary<TKey, TValue> src, TKey key, TValue defaultValue) Parameters src IDictionary<TKey, TValue> key TKey defaultValue TValue Returns TValue Type Parameters TKey TValue Retrieve<K, V>(Dictionary<K, V>, K, out V, bool) Retrieves a value from a dictionary by key, with an option to remove it from the source. public static bool Retrieve<K, V>(this Dictionary<K, V> src, K key, out V v, bool removeFromSource) Parameters src Dictionary<K, V> The source dictionary. key K The key to look for. v V When this method returns, contains the value associated with the specified key, if the key is found; otherwise, the default value for the type of the value parameter. removeFromSource bool If true, removes the key-value pair from the dictionary if found. Returns bool true if the key was found; otherwise, false. Type Parameters K The type of the keys in the dictionary. V The type of the values in the dictionary. TryGetValueByKeys<TKey, TValue>(IDictionary<TKey, TValue>, IEnumerable<TKey>, out TValue) Tries to get a value from a dictionary by checking multiple keys in sequence. public static bool TryGetValueByKeys<TKey, TValue>(this IDictionary<TKey, TValue> src, IEnumerable<TKey> keys, out TValue v) Parameters src IDictionary<TKey, TValue> The source dictionary. keys IEnumerable<TKey> The collection of keys to check. v TValue When this method returns, contains the value associated with the first matching key, if a key is found; otherwise, the default value for the type of the value parameter. Returns bool true if any of the keys was found; otherwise, false. Type Parameters TKey The type of the keys in the dictionary. TValue The type of the values in the dictionary."
  },
  "api/Hi.Common.Collections.EnumerableUtil.html": {
    "href": "api/Hi.Common.Collections.EnumerableUtil.html",
    "title": "Class EnumerableUtil | HiAPI-C# 2025",
    "summary": "Class EnumerableUtil Namespace Hi.Common.Collections Assembly HiGeom.dll Utility class providing extension methods for enumerable collections. public static class EnumerableUtil Inheritance object EnumerableUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetIntensiveItems<TItem>(IEnumerable<TItem>, double, Func<TItem, double>) Gets a collection of items with additional interpolated items inserted where the distance between consecutive items exceeds a specified resolution. public static IEnumerable<TItem> GetIntensiveItems<TItem>(this IEnumerable<TItem> src, double resolution, Func<TItem, double> keyFunc) where TItem : IAdditionOperators<TItem, TItem, TItem>, ISubtractionOperators<TItem, TItem, TItem>, IMultiplyOperators<TItem, double, TItem>, IDivisionOperators<TItem, double, TItem> Parameters src IEnumerable<TItem> The source collection. resolution double The maximum allowed distance between consecutive items. keyFunc Func<TItem, double> A function that extracts a double value from an item, used to measure the distance between items. Returns IEnumerable<TItem> A collection containing the original items and additional interpolated items where needed. Type Parameters TItem The type of items in the collection, which must support arithmetic operations. Remarks This method ensures that the distance between consecutive items in the resulting collection does not exceed the specified resolution. When the distance between two consecutive items in the source collection exceeds the resolution, additional items are interpolated between them."
  },
  "api/Hi.Common.Collections.FixedSizeConcurrentLinkedListUtil.html": {
    "href": "api/Hi.Common.Collections.FixedSizeConcurrentLinkedListUtil.html",
    "title": "Class FixedSizeConcurrentLinkedListUtil | HiAPI-C# 2025",
    "summary": "Class FixedSizeConcurrentLinkedListUtil Namespace Hi.Common.Collections Assembly HiGeom.dll Utility of Fixed Size Concurrent LinkedList. public static class FixedSizeConcurrentLinkedListUtil Inheritance object FixedSizeConcurrentLinkedListUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetThreadSafeEnumerable<T>(LinkedList<T>, object) Gets a thread-safe enumerable from the linked list by creating a copy of the list under a lock. public static IEnumerable<T> GetThreadSafeEnumerable<T>(this LinkedList<T> delegatorLinkedList, object locker = null) Parameters delegatorLinkedList LinkedList<T> The source linked list. locker object The object to use as a lock for synchronization. If null, the linked list itself will be used as the lock object. Returns IEnumerable<T> A thread-safe enumerable of the elements in the linked list. Type Parameters T The type of elements in the linked list. ThreadSafeEnqueue<T>(LinkedList<T>, T, int, object) Enqueue data to delegatorLinkedList synchronizely. public static void ThreadSafeEnqueue<T>(this LinkedList<T> delegatorLinkedList, T data, int bufferCapacity, object locker = null) Parameters delegatorLinkedList LinkedList<T> data T bufferCapacity int if capacity smaller or equal to zero. The capacity is assume infinity. locker object locker is locker for delegatorLinkedList synchronization. if null, apply delegatorLinkedList as locker. Type Parameters T"
  },
  "api/Hi.Common.Collections.LazyLinkedList-1.html": {
    "href": "api/Hi.Common.Collections.LazyLinkedList-1.html",
    "title": "Class LazyLinkedList<T> | HiAPI-C# 2025",
    "summary": "Class LazyLinkedList<T> Namespace Hi.Common.Collections Assembly HiGeom.dll A singly-growable linked list that can lazily materialize nodes from an IEnumerable<T> source. Without a source it behaves like a regular append-only linked list. With a source, nodes are pulled on demand when Next is accessed on the tail, or when First is accessed on an empty list. public class LazyLinkedList<T> : IEnumerable<T>, IEnumerable, IDisposable Type Parameters T Inheritance object LazyLinkedList<T> Implements IEnumerable<T> IEnumerable IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) StringUtil.ToDotSplitedString<T>(IEnumerable<T>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples // Lazy: nodes materialize as you walk .Next using var list = new LazyLinkedList<string>(File.ReadLines(path)); var node = list.First; // materializes line 0 var next = node.Next; // materializes line 1 // Manual: just like a regular linked list var list2 = new LazyLinkedList<int>(); list2.AddLast(1); list2.AddLast(2); Constructors LazyLinkedList() Creates an empty list (no lazy source). public LazyLinkedList() LazyLinkedList(IEnumerable<T>) Creates a list backed by a lazy source. Nodes are materialized on demand via Next or First. public LazyLinkedList(IEnumerable<T> source) Parameters source IEnumerable<T> Properties Count Number of nodes currently materialized in the list. public int Count { get; } Property Value int ExhaustedLast Forces full materialization of the lazy source and returns the last node. Walks the source to completion (no-op if already exhausted), then returns Last. Use when callers need the definitive tail at this point in time (e.g. as a stable predecessor before AppendSource(IEnumerable<T>)). public LazyLinkedListNode<T> ExhaustedLast { get; } Property Value LazyLinkedListNode<T> First Gets the first node, materializing from source if the list is empty. public LazyLinkedListNode<T> First { get; } Property Value LazyLinkedListNode<T> IsExhausted Whether all items from the source have been materialized (or no source was provided). public bool IsExhausted { get; } Property Value bool Last Gets the last materialized node in the list. public LazyLinkedListNode<T> Last { get; } Property Value LazyLinkedListNode<T> Methods AddLast(T) Appends a new node with the specified value to the end of the list. public LazyLinkedListNode<T> AddLast(T value) Parameters value T The value to add. Returns LazyLinkedListNode<T> The newly created node. AppendSource(IEnumerable<T>) Appends a new lazy source after the current source. The existing source's remaining items (if any) are drained first, then the new source is yielded. Re-opens the list for further on-demand materialization, so calling Next on the prior tail materializes the next item and links Previous across the boundary. public void AppendSource(IEnumerable<T> src) Parameters src IEnumerable<T> The new source to append. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() GetEnumerator() Returns an enumerator that iterates through the collection. public IEnumerator<T> GetEnumerator() Returns IEnumerator<T> An enumerator that can be used to iterate through the collection. PrependSource(IEnumerable<T>) Prepends a new source ahead of the current source's remaining items. On the next on-demand materialization (triggered by Next on the present tail or First on an empty list), src is yielded first; once exhausted, the previous source's untouched tail resumes. The materialized prefix of the list — including the present tail — is unaffected, so this is the natural way to splice extra items in immediately after the current tail (for example, inlining an M98 subprogram's blocks after the host node so the rest of the pipeline picks them up via ordinary walkNode.Next traversal). public void PrependSource(IEnumerable<T> src) Parameters src IEnumerable<T> The source to insert ahead of the remaining items. Remarks Constraint: the caller must treat the present tail as the splice point. There is no way to prepend “after some interior node” — the prepended items are queued ahead of whatever the current source would have produced next. Use this when the splice point coincides with the tail at the moment of the call (which is how SoftNcRunner's pipeline drives node-by-node lazy materialization in lock-step with syntax/semantic processing). ReplaceSource(IEnumerable<T>) Replaces the current source's remaining items with src. Discards anything the old source had queued (it is disposed); the next on-demand materialization (triggered by Next on the present tail or First on an empty list) yields from src only. Already-materialized nodes — including the present tail — are unaffected, so this is the natural way to redirect future execution from the current tail onwards (for example, a GOTO that re-segments the file from the target N{seq} line: the GOTO host block stays materialized as the predecessor, and the post-target re-segmentation becomes the new source while the original between-here- and-EOF source is dropped). public void ReplaceSource(IEnumerable<T> src) Parameters src IEnumerable<T> The new source. Yielded from on the next materialization. Remarks Constraint: same as PrependSource(IEnumerable<T>) — the present tail is the splice point. Differs from PrependSource(IEnumerable<T>) in that the old source's untouched tail is NOT preserved after src runs out; ReplaceSource(IEnumerable<T>) drops it. Use PrependSource(IEnumerable<T>) for inline expansion (M98 / G65) where the caller's tail must resume after the inlined body; use ReplaceSource(IEnumerable<T>) for control-flow redirection (GOTO, M99 P{seq}) where the original tail is no longer reachable."
  },
  "api/Hi.Common.Collections.LazyLinkedListNode-1.html": {
    "href": "api/Hi.Common.Collections.LazyLinkedListNode-1.html",
    "title": "Class LazyLinkedListNode<T> | HiAPI-C# 2025",
    "summary": "Class LazyLinkedListNode<T> Namespace Hi.Common.Collections Assembly HiGeom.dll Node for LazyLinkedList<T>. Accessing Next on the tail node automatically materializes the next item from the list's source (if any). public class LazyLinkedListNode<T> Type Parameters T Inheritance object LazyLinkedListNode<T> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors LazyLinkedListNode(T) Initializes a new instance with the specified value. public LazyLinkedListNode(T value) Parameters value T The value. Properties List Gets the list that this node belongs to. public LazyLinkedList<T> List { get; } Property Value LazyLinkedList<T> Next Gets the next node. When this is the last materialized node and the list has a pending source, accessing this property triggers on-demand materialization. Thread-safe: concurrent accesses from multiple threads are serialized via an internal lock. public LazyLinkedListNode<T> Next { get; } Property Value LazyLinkedListNode<T> Previous Gets the previous node in the list. public LazyLinkedListNode<T> Previous { get; } Property Value LazyLinkedListNode<T> Value Gets or sets the value of this node. public T Value { get; set; } Property Value T Methods Enumerate() Enumerates from this node forward to the end. public IEnumerable<LazyLinkedListNode<T>> Enumerate() Returns IEnumerable<LazyLinkedListNode<T>> EnumerateBack() Enumerates backwards from this node to the head. public IEnumerable<LazyLinkedListNode<T>> EnumerateBack() Returns IEnumerable<LazyLinkedListNode<T>> ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Common.Collections.LinkedListUtil.html": {
    "href": "api/Hi.Common.Collections.LinkedListUtil.html",
    "title": "Class LinkedListUtil | HiAPI-C# 2025",
    "summary": "Class LinkedListUtil Namespace Hi.Common.Collections Assembly HiGeom.dll Utility methods for working with linked lists. public static class LinkedListUtil Inheritance object LinkedListUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods EnumerateBack<T>(LinkedListNode<T>) Enumerates linked list nodes backwards from this node to the head. public static IEnumerable<LinkedListNode<T>> EnumerateBack<T>(this LinkedListNode<T> beginNode) Parameters beginNode LinkedListNode<T> The node to start tracing backwards from (inclusive). Returns IEnumerable<LinkedListNode<T>> An backward enumerable sequence. Type Parameters T The type of elements in the linked list. Enumerate<T>(LinkedListNode<T>) Enumerates linked list nodes from the beginning node to the end node (exclusive). public static IEnumerable<LinkedListNode<T>> Enumerate<T>(this LinkedListNode<T> beginNode) Parameters beginNode LinkedListNode<T> The starting node (inclusive). Returns IEnumerable<LinkedListNode<T>> An enumerable sequence of linked list nodes. Type Parameters T The type of elements in the linked list."
  },
  "api/Hi.Common.Collections.ListIndexBasedEnumerable-1.html": {
    "href": "api/Hi.Common.Collections.ListIndexBasedEnumerable-1.html",
    "title": "Class ListIndexBasedEnumerable<T> | HiAPI-C# 2025",
    "summary": "Class ListIndexBasedEnumerable<T> Namespace Hi.Common.Collections Assembly HiGeom.dll Provides an enumerable wrapper for a list that iterates over a specified range of indices. public class ListIndexBasedEnumerable<T> : IEnumerable<T>, IEnumerable Type Parameters T The type of elements in the list. Inheritance object ListIndexBasedEnumerable<T> Implements IEnumerable<T> IEnumerable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) StringUtil.ToDotSplitedString<T>(IEnumerable<T>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ListIndexBasedEnumerable(IList<T>, int, int) Initializes a new instance of the ListIndexBasedEnumerable<T> class. public ListIndexBasedEnumerable(IList<T> source, int begin, int end) Parameters source IList<T> The source list to enumerate. begin int The starting index (inclusive). end int The ending index (inclusive). Properties Begin Gets or sets the beginning index (inclusive) for enumeration. public int Begin { get; set; } Property Value int End Gets or sets the ending index (inclusive) for enumeration. public int End { get; set; } Property Value int Source Gets or sets the source list. public IList<T> Source { get; set; } Property Value IList<T> Methods GetEnumerator() Returns an enumerator that iterates through the collection. public IEnumerator<T> GetEnumerator() Returns IEnumerator<T> An enumerator that can be used to iterate through the collection."
  },
  "api/Hi.Common.Collections.ListIndexBasedIEnumerator-1.html": {
    "href": "api/Hi.Common.Collections.ListIndexBasedIEnumerator-1.html",
    "title": "Class ListIndexBasedIEnumerator<T> | HiAPI-C# 2025",
    "summary": "Class ListIndexBasedIEnumerator<T> Namespace Hi.Common.Collections Assembly HiGeom.dll Provides an enumerator that iterates over a specified range of indices in a list. public class ListIndexBasedIEnumerator<T> : IEnumerator<T>, IEnumerator, IDisposable Type Parameters T The type of elements in the list. Inheritance object ListIndexBasedIEnumerator<T> Implements IEnumerator<T> IEnumerator IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ListIndexBasedIEnumerator(IList<T>, int, int, int) Initializes a new instance of the ListIndexBasedIEnumerator<T> class. public ListIndexBasedIEnumerator(IList<T> source, int index, int begin, int end) Parameters source IList<T> The source list to enumerate. index int The current index. begin int The starting index (inclusive). end int The ending index (exclusive). Properties Begin Gets or sets the beginning index of the enumeration range. public int Begin { get; set; } Property Value int Current Gets the element in the collection at the current position of the enumerator. public T Current { get; } Property Value T The element in the collection at the current position of the enumerator. End Gets or sets the ending index of the enumeration range. public int End { get; set; } Property Value int Index Gets or sets the current index in the enumeration. public int Index { get; set; } Property Value int Source Gets or sets the source list being enumerated. public IList<T> Source { get; set; } Property Value IList<T> Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() MoveNext() Advances the enumerator to the next element of the collection. public bool MoveNext() Returns bool true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection. Exceptions InvalidOperationException The collection was modified after the enumerator was created. Reset() Sets the enumerator to its initial position, which is before the first element in the collection. public void Reset() Exceptions InvalidOperationException The collection was modified after the enumerator was created. NotSupportedException The enumerator does not support being reset."
  },
  "api/Hi.Common.Collections.ListUtil.OuterPolationMode.html": {
    "href": "api/Hi.Common.Collections.ListUtil.OuterPolationMode.html",
    "title": "Enum ListUtil.OuterPolationMode | HiAPI-C# 2025",
    "summary": "Enum ListUtil.OuterPolationMode Namespace Hi.Common.Collections Assembly HiGeom.dll Defines the mode for handling values outside the range of a collection during interpolation. public enum ListUtil.OuterPolationMode Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Extrapolation = 1 Extrapolates a value based on the trend of the collection when the key is outside the range. Nearest = 0 Uses the nearest value in the collection when the key is outside the range. TypeDefault = 2 Uses the default value for the type when the key is outside the range."
  },
  "api/Hi.Common.Collections.ListUtil.html": {
    "href": "api/Hi.Common.Collections.ListUtil.html",
    "title": "Class ListUtil | HiAPI-C# 2025",
    "summary": "Class ListUtil Namespace Hi.Common.Collections Assembly HiGeom.dll Provides utility methods for working with lists and collections. public static class ListUtil Inheritance object ListUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetCeilBySeek<TItem, TKey>(IList<TItem>, TKey, Func<TItem, TKey>, out TItem, out int, int, SeekDirection) Gets the ceil item by seeking with the specified direction. public static SearchResult GetCeilBySeek<TItem, TKey>(this IList<TItem> src, TKey key, Func<TItem, TKey> getKeyFunc, out TItem ceilValue, out int ceilIndex, int seekingStartIndex, SeekDirection seekDirection = SeekDirection.Free) where TKey : IComparable<TKey> Parameters src IList<TItem> The source list. key TKey The key to search for. getKeyFunc Func<TItem, TKey> A function that extracts the key from an item. ceilValue TItem The output ceil value. ceilIndex int The output ceil index. seekingStartIndex int The start index for seeking. seekDirection SeekDirection The seek direction. Returns SearchResult The search result. Type Parameters TItem The type of items in the list. TKey The type of the key. GetCeilIndexBySeek<TItem, TKey>(IList<TItem>, TKey, Func<TItem, TKey>, out int, int, SeekDirection) Gets the ceil index by seeking with the specified direction. public static SearchResult GetCeilIndexBySeek<TItem, TKey>(this IList<TItem> src, TKey key, Func<TItem, TKey> getKeyFunc, out int ceilIndex, int seekingStartIndex, SeekDirection seekDirection = SeekDirection.Free) where TKey : IComparable<TKey> Parameters src IList<TItem> The source list. key TKey The key to search for. getKeyFunc Func<TItem, TKey> A function that extracts the key from an item. ceilIndex int The output ceil index. seekingStartIndex int The start index for seeking. seekDirection SeekDirection The seek direction. Returns SearchResult The search result. Type Parameters TItem The type of items in the list. TKey The type of the key. Remarks The Free seek direction does not loss additional performance. The seek direction only effect the resulting value by the seekingStartIndex bound. GetCeilIndex<Item, ItemKey>(IList<Item>, ItemKey, Func<Item, ItemKey, int>, out int) Gets the ceiling index of an item in a sorted list based on a key comparison. public static SearchResult GetCeilIndex<Item, ItemKey>(this IList<Item> sortedItems, ItemKey key, Func<Item, ItemKey, int> comparingFunc, out int index) Parameters sortedItems IList<Item> The sorted list to search in. key ItemKey The key to search for. comparingFunc Func<Item, ItemKey, int> A function that compares an item to the key. index int When this method returns, contains the index of the ceiling item if found; otherwise, -1. Returns SearchResult A SearchResult indicating the result of the search. Type Parameters Item The type of items in the list. ItemKey The type of the key to search for. GetCeilIndex<TKey, Item>(IList<Item>, TKey, Func<Item, TKey>, out int) Gets the ceiling index of an item in a sorted list based on a key selector function. public static SearchResult GetCeilIndex<TKey, Item>(this IList<Item> sortedItems, TKey keyQuantity, Func<Item, TKey> getKeyQuantityFunc, out int index) where TKey : IComparable<TKey> Parameters sortedItems IList<Item> The sorted list to search in. keyQuantity TKey The key to search for. getKeyQuantityFunc Func<Item, TKey> A function that extracts the key from an item. index int When this method returns, contains the index of the ceiling item if found; otherwise, -1. Returns SearchResult A SearchResult indicating the result of the search. Type Parameters TKey The type of the key. Item The type of items in the list. GetCeil<TKey, Item>(IList<Item>, TKey, Func<Item, TKey>, out Item) Gets the ceiling item in a sorted list based on a key selector function. public static SearchResult GetCeil<TKey, Item>(this IList<Item> sortedItems, TKey keyQuantity, Func<Item, TKey> getKeyQuantityFunc, out Item dst) where TKey : IComparable<TKey> Parameters sortedItems IList<Item> The sorted list to search in. keyQuantity TKey The key to search for. getKeyQuantityFunc Func<Item, TKey> A function that extracts the key from an item. dst Item When this method returns, contains the ceiling item if found; otherwise, the default value for the type. Returns SearchResult A SearchResult indicating the result of the search. Type Parameters TKey The type of the key. Item The type of items in the list. GetFloorBySeek<TItem, TKey>(IList<TItem>, TKey, Func<TItem, TKey>, out TItem, out int, int, SeekDirection) Gets the floor item by seeking with the specified direction. public static SearchResult GetFloorBySeek<TItem, TKey>(this IList<TItem> src, TKey key, Func<TItem, TKey> getKeyFunc, out TItem floorValue, out int floorIndex, int seekingStartIndex, SeekDirection seekDirection = SeekDirection.Free) where TKey : IComparable<TKey> Parameters src IList<TItem> The source list. key TKey The key to search for. getKeyFunc Func<TItem, TKey> A function that extracts the key from an item. floorValue TItem The output floor value. floorIndex int The output floor index. seekingStartIndex int The start index for seeking. seekDirection SeekDirection The seek direction. Returns SearchResult The search result. Type Parameters TItem The type of items in the list. TKey The type of the key. GetFloorIndexBySeek<TItem, TKey>(IList<TItem>, TKey, Func<TItem, TKey>, out int, int, SeekDirection) Gets the floor index by seeking with the specified direction. public static SearchResult GetFloorIndexBySeek<TItem, TKey>(this IList<TItem> src, TKey key, Func<TItem, TKey> getKeyFunc, out int floorIndex, int seekingStartIndex, SeekDirection seekDirection = SeekDirection.Free) where TKey : IComparable<TKey> Parameters src IList<TItem> The source list. key TKey The key to search for. getKeyFunc Func<TItem, TKey> A function that extracts the key from an item. floorIndex int The output floor index. seekingStartIndex int The start index for seeking. seekDirection SeekDirection The seek direction. Returns SearchResult The search result. Type Parameters TItem The type of items in the list. TKey The type of the key. Remarks The Free seek direction does not loss additional performance. The seek direction only effect the resulting value by the seekingStartIndex bound. GetFloorIndex<Item, ItemKey>(IList<Item>, ItemKey, Func<Item, ItemKey, int>, out int) Gets the floor index of an item in a sorted list based on a key comparison. public static SearchResult GetFloorIndex<Item, ItemKey>(this IList<Item> sortedItems, ItemKey key, Func<Item, ItemKey, int> comparingFunc, out int index) Parameters sortedItems IList<Item> The sorted list to search in. key ItemKey The key to search for. comparingFunc Func<Item, ItemKey, int> A function that compares an item to the key. index int When this method returns, contains the index of the floor item if found; otherwise, -1. Returns SearchResult A SearchResult indicating the result of the search. Type Parameters Item The type of items in the list. ItemKey The type of the key to search for. GetFloorIndex<TKey, Item>(IList<Item>, TKey, Func<Item, TKey>, out int) Gets the floor index of an item in a sorted list based on a key selector function. public static SearchResult GetFloorIndex<TKey, Item>(this IList<Item> sortedItems, TKey key, Func<Item, TKey> getKeyFunc, out int index) where TKey : IComparable<TKey> Parameters sortedItems IList<Item> The sorted list to search in. key TKey The key to search for. getKeyFunc Func<Item, TKey> A function that extracts the key from an item. index int When this method returns, contains the index of the floor item if found; otherwise, -1. Returns SearchResult A SearchResult indicating the result of the search. Type Parameters TKey The type of the key. Item The type of items in the list. GetFloor<TKey, Item>(IList<Item>, TKey, Func<Item, TKey>, out Item) Gets the floor item in a sorted list based on a key selector function. public static SearchResult GetFloor<TKey, Item>(this IList<Item> sortedItems, TKey keyQuantity, Func<Item, TKey> getKeyQuantityFunc, out Item dst) where TKey : IComparable<TKey> Parameters sortedItems IList<Item> The sorted list to search in. keyQuantity TKey The key to search for. getKeyQuantityFunc Func<Item, TKey> A function that extracts the key from an item. dst Item When this method returns, contains the floor item if found; otherwise, the default value for the type. Returns SearchResult A SearchResult indicating the result of the search. Type Parameters TKey The type of the key. Item The type of items in the list. GetIndexBasedEnumerable<TItem>(IList<TItem>) Creates an enumerable that provides access to all elements in a list by index. public static ListIndexBasedEnumerable<TItem> GetIndexBasedEnumerable<TItem>(this IList<TItem> src) Parameters src IList<TItem> The source list Returns ListIndexBasedEnumerable<TItem> A ListIndexBasedEnumerable for the entire list Type Parameters TItem The type of elements in the list GetIndexBasedEnumerable<TItem>(IList<TItem>, int, int) Creates an enumerable that provides access to a range of elements in a list by index. public static ListIndexBasedEnumerable<TItem> GetIndexBasedEnumerable<TItem>(this IList<TItem> src, int begin, int end) Parameters src IList<TItem> The source list begin int The starting index (inclusive) end int The ending index (exclusive) Returns ListIndexBasedEnumerable<TItem> A ListIndexBasedEnumerable for the specified range Type Parameters TItem The type of elements in the list GetIndexByBinarySearch<TItem>(IList<TItem>, TItem) Performs a binary search on the specified collection. public static int GetIndexByBinarySearch<TItem>(this IList<TItem> sortedItems, TItem value) Parameters sortedItems IList<TItem> The list to be searched. value TItem The value to search for. Returns int Type Parameters TItem The type of the item. GetIndexByBinarySearch<TItem>(IList<TItem>, TItem, IComparer<TItem>) Performs a binary search on the specified collection. public static int GetIndexByBinarySearch<TItem>(this IList<TItem> sortedItems, TItem value, IComparer<TItem> comparer) Parameters sortedItems IList<TItem> The list to be searched. value TItem The value to search for. comparer IComparer<TItem> The comparer that is used to compare the value with the list items. Returns int Type Parameters TItem The type of the item. GetIndexByBinarySearch<TItem, TSearch>(IList<TItem>, TSearch, Func<TSearch, TItem, int>) Performs a binary search on the specified collection. public static int GetIndexByBinarySearch<TItem, TSearch>(this IList<TItem> sortedItems, TSearch value, Func<TSearch, TItem, int> comparer) Parameters sortedItems IList<TItem> The list to be searched. value TSearch The value to search for. comparer Func<TSearch, TItem, int> The comparer that is used to compare the value with the list items. Returns int Type Parameters TItem The type of the item. TSearch The type of the searched item. GetInterpolatedBoundary<TItem>(List<TItem>, double, double, Func<TItem, double>, out TItem, out TItem, out TItem) Gets interpolated boundary items from a list based on a key value and interval. public static void GetInterpolatedBoundary<TItem>(this List<TItem> scpList, double z, double zInterval, Func<TItem, double> keyFunc, out TItem cur, out TItem floor, out TItem ceil) where TItem : IAdditionOperators<TItem, TItem, TItem>, IMultiplyOperators<TItem, double, TItem> Parameters scpList List<TItem> The source list. z double The key value to find or interpolate at. zInterval double The interval to consider around the key value. keyFunc Func<TItem, double> A function that extracts the key from an item. cur TItem When this method returns, contains the interpolated item at the key value. floor TItem When this method returns, contains the floor item. ceil TItem When this method returns, contains the ceiling item. Type Parameters TItem The type of items in the list, which must support addition and multiplication operators. GetInterpolatedValue<TItem>(List<TItem>, double, Func<TItem, double>, OuterPolationMode) Gets an interpolated value from a sorted list based on a double key, using operators for addition and multiplication. public static TItem GetInterpolatedValue<TItem>(this List<TItem> sortedItems, double keyQuantity, Func<TItem, double> getKeyQuantityFunc, ListUtil.OuterPolationMode outerPolationMode) where TItem : IAdditionOperators<TItem, TItem, TItem>, IMultiplyOperators<TItem, double, TItem> Parameters sortedItems List<TItem> The sorted list to interpolate from. keyQuantity double The key to find or interpolate at. getKeyQuantityFunc Func<TItem, double> A function that extracts the key from an item. outerPolationMode ListUtil.OuterPolationMode The mode to use when the key is outside the range of the list. Returns TItem The interpolated value. Type Parameters TItem The type of items in the list, which must support addition and multiplication operators. GetInterpolatedValue<TItem>(List<TItem>, double, Func<TItem, double>, Func<TItem, TItem, TItem>, Func<TItem, double, TItem>, OuterPolationMode) Gets an interpolated value from a sorted list based on a double key. public static TItem GetInterpolatedValue<TItem>(this List<TItem> sortedItems, double key, Func<TItem, double> getKeyFunc, Func<TItem, TItem, TItem> itemAddingFunc, Func<TItem, double, TItem> itemScalingFunc, ListUtil.OuterPolationMode outerPolationMode) Parameters sortedItems List<TItem> The sorted list to interpolate from. key double The key to find or interpolate at. getKeyFunc Func<TItem, double> A function that extracts the key from an item. itemAddingFunc Func<TItem, TItem, TItem> A function that adds two items together. itemScalingFunc Func<TItem, double, TItem> A function that scales an item by a factor. outerPolationMode ListUtil.OuterPolationMode The mode to use when the key is outside the range of the list. Returns TItem The interpolated value. Type Parameters TItem The type of items in the list. GetInterpolatedValue<TItem>(List<TItem>, TimeSpan, Func<TItem, TimeSpan>, OuterPolationMode) Gets an interpolated value from a sorted list based on a TimeSpan key, using operators for addition and multiplication. public static TItem GetInterpolatedValue<TItem>(this List<TItem> sortedItems, TimeSpan keyQuantity, Func<TItem, TimeSpan> getKeyQuantityFunc, ListUtil.OuterPolationMode outerPolationMode) where TItem : IAdditionOperators<TItem, TItem, TItem>, IMultiplyOperators<TItem, double, TItem> Parameters sortedItems List<TItem> The sorted list to interpolate from. keyQuantity TimeSpan The TimeSpan key to find or interpolate at. getKeyQuantityFunc Func<TItem, TimeSpan> A function that extracts the TimeSpan key from an item. outerPolationMode ListUtil.OuterPolationMode The mode to use when the key is outside the range of the list. Returns TItem The interpolated value. Type Parameters TItem The type of items in the list, which must support addition and multiplication operators. GetInterpolatedValue<TItem>(List<TItem>, TimeSpan, Func<TItem, TimeSpan>, Func<TItem, TItem, TItem>, Func<TItem, double, TItem>, OuterPolationMode) Gets an interpolated value from a sorted list based on a TimeSpan key. public static TItem GetInterpolatedValue<TItem>(this List<TItem> sortedItems, TimeSpan key, Func<TItem, TimeSpan> getKeyFunc, Func<TItem, TItem, TItem> itemAddingFunc, Func<TItem, double, TItem> itemScalingFunc, ListUtil.OuterPolationMode outerPolationMode) Parameters sortedItems List<TItem> The sorted list to interpolate from. key TimeSpan The TimeSpan key to find or interpolate at. getKeyFunc Func<TItem, TimeSpan> A function that extracts the TimeSpan key from an item. itemAddingFunc Func<TItem, TItem, TItem> A function that adds two items together. itemScalingFunc Func<TItem, double, TItem> A function that scales an item by a factor. outerPolationMode ListUtil.OuterPolationMode The mode to use when the key is outside the range of the list. Returns TItem The interpolated value. Type Parameters TItem The type of items in the list. GetInterpolatedValue<TKey, TItem>(List<TItem>, TKey, Func<TItem, TKey>, Func<TKey, TKey, int>, Func<TKey, TKey, TKey>, Func<TKey, TKey, double>, Func<TItem, TItem, TItem>, Func<TItem, double, TItem>, OuterPolationMode) Gets an interpolated value from a sorted list based on a key using custom comparison and arithmetic functions. public static TItem GetInterpolatedValue<TKey, TItem>(this List<TItem> sortedItems, TKey key, Func<TItem, TKey> getKeyFunc, Func<TKey, TKey, int> keyCompareFunc, Func<TKey, TKey, TKey> keyMinusFunc, Func<TKey, TKey, double> keyDivFunc, Func<TItem, TItem, TItem> addingFunc, Func<TItem, double, TItem> scalingFunc, ListUtil.OuterPolationMode outerPolationMode) Parameters sortedItems List<TItem> The sorted list of items key TKey The key to search for getKeyFunc Func<TItem, TKey> A function that extracts the key from an item keyCompareFunc Func<TKey, TKey, int> A function that compares two keys keyMinusFunc Func<TKey, TKey, TKey> A function that subtracts one key from another keyDivFunc Func<TKey, TKey, double> A function that divides one key by another addingFunc Func<TItem, TItem, TItem> A function that adds two items scalingFunc Func<TItem, double, TItem> A function that scales an item by a factor outerPolationMode ListUtil.OuterPolationMode The mode for handling values outside the range Returns TItem The interpolated value Type Parameters TKey The type of the key TItem The type of elements in the list GetListByKeyBoundary<TKey, TItem>(List<TItem>, Func<TItem, TKey>, TKey, bool, TKey, bool) Gets a subset of a sorted list based on key boundaries. public static List<TItem> GetListByKeyBoundary<TKey, TItem>(this List<TItem> sortedItems, Func<TItem, TKey> getKeyQuantityFunc, TKey begin, bool isIncludingBeginFloor, TKey end, bool isIncludingEndCeil) where TKey : IComparable<TKey> Parameters sortedItems List<TItem> The sorted list to filter. getKeyQuantityFunc Func<TItem, TKey> A function that extracts the key from an item. begin TKey The beginning key of the range. isIncludingBeginFloor bool Whether to include the floor of the beginning key. end TKey The ending key of the range. isIncludingEndCeil bool Whether to include the ceiling of the ending key. Returns List<TItem> A new list containing only the items within the specified key range. return empty new list instead of null if no elements in the boundary. Type Parameters TKey The type of the key, which must be comparable. TItem The type of items in the list. GetNearestIndex<TItem, TItemKey>(IList<TItem>, TItemKey, Func<TItem, TItemKey, double>, out int) Finds the index of the element in a sorted list that is nearest to the specified key. public static SearchResult GetNearestIndex<TItem, TItemKey>(this IList<TItem> src, TItemKey key, Func<TItem, TItemKey, double> itemToKeyDistanceFunc, out int index) Parameters src IList<TItem> The source list key TItemKey The key to search for itemToKeyDistanceFunc Func<TItem, TItemKey, double> A function that calculates the distance between an item and the key index int When this method returns, contains the index of the nearest element if found; otherwise, -1 Returns SearchResult A BinarySearchResult indicating the result of the search Type Parameters TItem The type of elements in the list TItemKey The type of the key to search for GetNearestIndex<TItem, TItemKey>(IList<TItem>, TItemKey, Func<TItem, TItemKey, int>, Func<TItem, TItemKey, double>, out int) Finds the index of the element in a sorted list that is nearest to the specified key using custom comparison functions. public static SearchResult GetNearestIndex<TItem, TItemKey>(this IList<TItem> src, TItemKey key, Func<TItem, TItemKey, int> itemCompareToKeyFunc, Func<TItem, TItemKey, double> itemToKeyDistanceFunc, out int index) Parameters src IList<TItem> The source list (must be in ascending order) key TItemKey The key to search for itemCompareToKeyFunc Func<TItem, TItemKey, int> A function that compares an item to the key itemToKeyDistanceFunc Func<TItem, TItemKey, double> A function that calculates the distance between an item and the key index int When this method returns, contains the index of the nearest element if found; otherwise, -1 Returns SearchResult A BinarySearchResult indicating the result of the search Type Parameters TItem The type of elements in the list TItemKey The type of the key to search for Exceptions InvalidProgramException Thrown when an unexpected search result occurs GetSubListWithInterpolatedHeadAndTail<TItem>(List<TItem>, double, double, Func<TItem, double>, Func<TItem, TItem, TItem>, Func<TItem, double, TItem>) Creates a new list with interpolated head and tail items based on the specified double key range. public static List<TItem> GetSubListWithInterpolatedHeadAndTail<TItem>(this List<TItem> src, double beginKey, double endKey, Func<TItem, double> getKeyFunc, Func<TItem, TItem, TItem> itemAddingFunc, Func<TItem, double, TItem> itemScalingFunc) Parameters src List<TItem> The source list. beginKey double The beginning key of the range. endKey double The ending key of the range. getKeyFunc Func<TItem, double> A function that extracts the double key from an item. itemAddingFunc Func<TItem, TItem, TItem> A function that adds two items together. itemScalingFunc Func<TItem, double, TItem> A function that scales an item by a factor. Returns List<TItem> A new list with interpolated head and tail items. Type Parameters TItem The type of items in the list. GetSubListWithInterpolatedHeadAndTail<TItem>(List<TItem>, TimeSpan, TimeSpan, Func<TItem, TimeSpan>, Func<TItem, TItem, TItem>, Func<TItem, double, TItem>) Creates a new list with interpolated head and tail items based on the specified TimeSpan key range. public static List<TItem> GetSubListWithInterpolatedHeadAndTail<TItem>(this List<TItem> src, TimeSpan beginKey, TimeSpan endKey, Func<TItem, TimeSpan> getKeyFunc, Func<TItem, TItem, TItem> itemAddingFunc, Func<TItem, double, TItem> itemScalingFunc) Parameters src List<TItem> The source list. beginKey TimeSpan The beginning TimeSpan key of the range. endKey TimeSpan The ending TimeSpan key of the range. getKeyFunc Func<TItem, TimeSpan> A function that extracts the TimeSpan key from an item. itemAddingFunc Func<TItem, TItem, TItem> A function that adds two items together. itemScalingFunc Func<TItem, double, TItem> A function that scales an item by a factor. Returns List<TItem> A new list with interpolated head and tail items. Type Parameters TItem The type of items in the list. GetSubListWithInterpolatedHeadAndTail<TKey, TItem>(List<TItem>, TKey, TKey, Func<TItem, TKey>, Func<TKey, TKey, int>, Func<TKey, TKey, TKey>, Func<TKey, TKey, double>, Func<TItem, TItem, TItem>, Func<TItem, double, TItem>) Creates a new list with interpolated head and tail items based on the specified key range. public static List<TItem> GetSubListWithInterpolatedHeadAndTail<TKey, TItem>(this List<TItem> src, TKey beginKey, TKey endKey, Func<TItem, TKey> getKeyFunc, Func<TKey, TKey, int> keyCompareFunc, Func<TKey, TKey, TKey> keyMinusFunc, Func<TKey, TKey, double> keyDivFunc, Func<TItem, TItem, TItem> itemAddingFunc, Func<TItem, double, TItem> itemScalingFunc) Parameters src List<TItem> The source list. beginKey TKey The beginning key of the range. endKey TKey The ending key of the range. getKeyFunc Func<TItem, TKey> A function that extracts the key from an item. keyCompareFunc Func<TKey, TKey, int> A function that compares two keys. keyMinusFunc Func<TKey, TKey, TKey> A function that subtracts one key from another. keyDivFunc Func<TKey, TKey, double> A function that divides one key by another to get a ratio. itemAddingFunc Func<TItem, TItem, TItem> A function that adds two items together. itemScalingFunc Func<TItem, double, TItem> A function that scales an item by a factor. Returns List<TItem> A new list with interpolated head and tail items. Type Parameters TKey The type of the key. TItem The type of items in the list. GetSubListWithInterpolatedTail<TItem>(List<TItem>, TimeSpan, Func<TItem, TimeSpan>, Func<TItem, TItem, TItem>, Func<TItem, double, TItem>) Creates a new list with an interpolated tail item based on the specified TimeSpan key. public static List<TItem> GetSubListWithInterpolatedTail<TItem>(this List<TItem> src, TimeSpan endKey, Func<TItem, TimeSpan> getKeyFunc, Func<TItem, TItem, TItem> addingFunc, Func<TItem, double, TItem> scalingFunc) Parameters src List<TItem> The source list. endKey TimeSpan The ending TimeSpan key for interpolation. getKeyFunc Func<TItem, TimeSpan> A function that extracts the TimeSpan key from an item. addingFunc Func<TItem, TItem, TItem> A function that adds two items together. scalingFunc Func<TItem, double, TItem> A function that scales an item by a factor. Returns List<TItem> A new list with an interpolated tail item. Type Parameters TItem The type of items in the list. GetSubListWithInterpolatedTail<TKey, TItem>(List<TItem>, TKey, Func<TItem, TKey>) Creates a new list with an interpolated tail item based on the specified key, using operators for both key and item operations. public static List<TItem> GetSubListWithInterpolatedTail<TKey, TItem>(this List<TItem> src, TKey endKey, Func<TItem, TKey> getKeyFunc) where TKey : IComparable<TKey>, ISubtractionOperators<TKey, TKey, TKey>, IDivisionOperators<TKey, TKey, double> where TItem : IAdditionOperators<TItem, TItem, TItem>, IMultiplyOperators<TItem, double, TItem> Parameters src List<TItem> The source list. endKey TKey The ending key for interpolation. getKeyFunc Func<TItem, TKey> A function that extracts the key from an item. Returns List<TItem> A new list with an interpolated tail item. Type Parameters TKey The type of the key, which must support comparison, subtraction, and division operators. TItem The type of items in the list, which must support addition and multiplication operators. GetSubListWithInterpolatedTail<TKey, TItem>(List<TItem>, TKey, Func<TItem, TKey>, Func<TKey, TKey, int>, Func<TKey, TKey, TKey>, Func<TKey, TKey, double>, Func<TItem, TItem, TItem>, Func<TItem, double, TItem>) Creates a new list with an interpolated tail item based on the specified key. public static List<TItem> GetSubListWithInterpolatedTail<TKey, TItem>(this List<TItem> src, TKey endKey, Func<TItem, TKey> getKeyFunc, Func<TKey, TKey, int> keyCompareFunc, Func<TKey, TKey, TKey> keyMinusFunc, Func<TKey, TKey, double> keyDivFunc, Func<TItem, TItem, TItem> itemAddingFunc, Func<TItem, double, TItem> itemScalingFunc) Parameters src List<TItem> The source list. endKey TKey The ending key for interpolation. getKeyFunc Func<TItem, TKey> A function that extracts the key from an item. keyCompareFunc Func<TKey, TKey, int> A function that compares two keys. keyMinusFunc Func<TKey, TKey, TKey> A function that subtracts one key from another. keyDivFunc Func<TKey, TKey, double> A function that divides one key by another to get a ratio. itemAddingFunc Func<TItem, TItem, TItem> A function that adds two items together. itemScalingFunc Func<TItem, double, TItem> A function that scales an item by a factor. Returns List<TItem> A new list with an interpolated tail item. Type Parameters TKey The type of the key. TItem The type of items in the list. GetSubListWithInterpolatedTail<TKey, TItem>(List<TItem>, TKey, Func<TItem, TKey>, Func<TItem, TItem, TItem>, Func<TItem, double, TItem>) Creates a new list with an interpolated tail item based on the specified key, using operators for key operations. public static List<TItem> GetSubListWithInterpolatedTail<TKey, TItem>(this List<TItem> src, TKey endKey, Func<TItem, TKey> getKeyFunc, Func<TItem, TItem, TItem> addingFunc, Func<TItem, double, TItem> scalingFunc) where TKey : IComparable<TKey>, ISubtractionOperators<TKey, TKey, TKey>, IDivisionOperators<TKey, TKey, double> Parameters src List<TItem> The source list. endKey TKey The ending key for interpolation. getKeyFunc Func<TItem, TKey> A function that extracts the key from an item. addingFunc Func<TItem, TItem, TItem> A function that adds two items together. scalingFunc Func<TItem, double, TItem> A function that scales an item by a factor. Returns List<TItem> A new list with an interpolated tail item. Type Parameters TKey The type of the key, which must support comparison, subtraction, and division operators. TItem The type of items in the list. GetSubList<TItem>(IList<TItem>, int, int) Gets a sub-list view of the specified list within the given index range. public static SubList<TItem> GetSubList<TItem>(this IList<TItem> src, int beginIndex, int endIndex) Parameters src IList<TItem> The source list. beginIndex int The starting index (inclusive). endIndex int The ending index (exclusive). Returns SubList<TItem> A sub-list view of the specified range. Type Parameters TItem The type of items in the list. Swap<TItem>(IList<TItem>, int, int) Swaps two elements in a list at the specified indices. public static void Swap<TItem>(this IList<TItem> src, int indexA, int indexB) Parameters src IList<TItem> The source list indexA int The index of the first element to swap indexB int The index of the second element to swap Type Parameters TItem The type of elements in the list TestFloorCeil() Tests the floor and ceiling functionality with sample data. public static void TestFloorCeil()"
  },
  "api/Hi.Common.Collections.SearchTargetMode.html": {
    "href": "api/Hi.Common.Collections.SearchTargetMode.html",
    "title": "Enum SearchTargetMode | HiAPI-C# 2025",
    "summary": "Enum SearchTargetMode Namespace Hi.Common.Collections Assembly HiGeom.dll Specifies the search method to use when looking for values in a sorted list. public enum SearchTargetMode Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Ceil = 1 Find the smallest element greater than or equal to the key. Floor = 0 Find the largest element less than or equal to the key."
  },
  "api/Hi.Common.Collections.SeekDirection.html": {
    "href": "api/Hi.Common.Collections.SeekDirection.html",
    "title": "Enum SeekDirection | HiAPI-C# 2025",
    "summary": "Enum SeekDirection Namespace Hi.Common.Collections Assembly HiGeom.dll Specifies the seek direction for sorted list operations. public enum SeekDirection Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Backward = 2 Backward seek direction. Forward = 1 Forward seek direction. Free = 0 Free seek direction without additional performance cost."
  },
  "api/Hi.Common.Collections.SortedListUtil.html": {
    "href": "api/Hi.Common.Collections.SortedListUtil.html",
    "title": "Class SortedListUtil | HiAPI-C# 2025",
    "summary": "Class SortedListUtil Namespace Hi.Common.Collections Assembly HiGeom.dll Utility class providing extension methods for SortedList operations. public static class SortedListUtil Inheritance object SortedListUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetByMethod<TKey, V>(SortedList<TKey, V>, TKey, SearchTargetMode, out V, int, int) Get value by searchMethod. If return value is NotExisted, resultValue will be the default value of V. public static SearchResult GetByMethod<TKey, V>(this SortedList<TKey, V> src, TKey key, SearchTargetMode searchMethod, out V resultValue, int beginIndex = 0, int endIndex = -1) where TKey : IComparable<TKey> Parameters src SortedList<TKey, V> source key TKey key searchMethod SearchTargetMode search method resultValue V searched value beginIndex int The starting index for the search range (inclusive). Default is 0. endIndex int The ending index for the search range (exclusive). Default is -1, which means the end of the list. Returns SearchResult search result Type Parameters TKey Key type V Value type GetCeilBySeek<TKey, V>(SortedList<TKey, V>, TKey, out V, out int, int, SeekDirection) Gets the ceil value by seeking with the specified direction. public static SearchResult GetCeilBySeek<TKey, V>(this SortedList<TKey, V> src, TKey key, out V ceilValue, out int ceilListIndex, int seekingStartListIndex, SeekDirection seekDirection = SeekDirection.Free) where TKey : IComparable<TKey> Parameters src SortedList<TKey, V> The source sorted list. key TKey The key to search for. ceilValue V The output ceil value. ceilListIndex int The output ceil list index. seekingStartListIndex int The start list index for seeking. seekDirection SeekDirection The seek direction. Returns SearchResult The binary search result. Type Parameters TKey The type of keys in the sorted list. V The type of values in the sorted list. GetCeilListIndexBySeek<TKey, V>(SortedList<TKey, V>, TKey, out int, int, SeekDirection) Gets the ceil list index by seeking with the specified direction. public static SearchResult GetCeilListIndexBySeek<TKey, V>(this SortedList<TKey, V> src, TKey key, out int ceilListIndex, int seekingStartListIndex, SeekDirection seekDirection = SeekDirection.Free) where TKey : IComparable<TKey> Parameters src SortedList<TKey, V> The source sorted list. key TKey The key to search for. ceilListIndex int The output ceil list index. seekingStartListIndex int Start list index for seeking. seekDirection SeekDirection The seek direction. Default is Free. Returns SearchResult The search result. Type Parameters TKey The type of keys in the sorted list. V The type of values in the sorted list. Remarks The Free seek direction does not loss additional performance. The seek direction only effect the resulting value by the seekingStartListIndex bound. GetCeilListIndex<TKey, V>(SortedList<TKey, V>, TKey, out int, int, int) Gets the index of the element in a sorted list that has a key greater than or equal to a specified key. public static SearchResult GetCeilListIndex<TKey, V>(this SortedList<TKey, V> src, TKey key, out int resultListIndex, int beginListIndex = 0, int endListIndex = -1) where TKey : IComparable<TKey> Parameters src SortedList<TKey, V> The source sorted list. key TKey The key to search for. resultListIndex int When this method returns, contains the index of the ceiling element if found; otherwise, -1. beginListIndex int The starting index for the search range (inclusive). endListIndex int The ending index for the search range (exclusive). Returns SearchResult A value indicating whether an exact match was found, a ceiling value was found, or no suitable element exists. Type Parameters TKey The type of keys in the sorted list. V The type of values in the sorted list. GetCeil<TKey, V>(SortedList<TKey, V>, TKey, out V, int, int) Get ceil value by key without returning the ceil index. public static SearchResult GetCeil<TKey, V>(this SortedList<TKey, V> src, TKey key, out V resultValue, int beginIndex = 0, int endIndex = -1) where TKey : IComparable<TKey> Parameters src SortedList<TKey, V> The source sorted list. key TKey The key to search for. resultValue V The ceil value. beginIndex int The starting index for the search range (inclusive). endIndex int The ending index for the search range (exclusive). Returns SearchResult The binary search result. Type Parameters TKey Key type. V Value type. GetCeil<TKey, V>(SortedList<TKey, V>, TKey, out V, out int, int, int) Get ceil value by key. If return value is NotExisted, resultValue will be the default value of V. public static SearchResult GetCeil<TKey, V>(this SortedList<TKey, V> src, TKey key, out V resultValue, out int ceilIndex, int beginIndex = 0, int endIndex = -1) where TKey : IComparable<TKey> Parameters src SortedList<TKey, V> source key TKey key resultValue V ceil value ceilIndex int The output ceil index. beginIndex int The starting index for the search range (inclusive). Default is 0. endIndex int The ending index for the search range (exclusive). Default is -1, which means the end of the list. Returns SearchResult search result Type Parameters TKey Key type V Value type GetEnumerableByKeyBoundary<TKey, V>(SortedList<TKey, V>, TKey, bool, TKey, bool, int, int) Gets a sequence of key-value pairs from a sorted list within a specified key range. public static IEnumerable<KeyValuePair<TKey, V>> GetEnumerableByKeyBoundary<TKey, V>(this SortedList<TKey, V> src, TKey begin, bool isIncludingBeginFloor, TKey end, bool isIncludingEndCeil, int beginIndex = 0, int endIndex = -1) where TKey : IComparable<TKey> Parameters src SortedList<TKey, V> The source sorted list. begin TKey The beginning key of the range. isIncludingBeginFloor bool Whether to include the floor value of the beginning key. end TKey The ending key of the range. isIncludingEndCeil bool Whether to include the ceiling value of the ending key. beginIndex int The starting index for the search range (inclusive). Default is 0. endIndex int The ending index for the search range (exclusive). Default is -1, which means the end of the list. Returns IEnumerable<KeyValuePair<TKey, V>> A sequence of key-value pairs within the specified range. Type Parameters TKey The type of keys in the sorted list. V The type of values in the sorted list. GetFloorBySeek<TKey, V>(SortedList<TKey, V>, TKey, out V, out int, int, SeekDirection) Gets the floor value by seeking with the specified direction. public static SearchResult GetFloorBySeek<TKey, V>(this SortedList<TKey, V> src, TKey key, out V floorValue, out int floorListIndex, int seekingStartListIndex, SeekDirection seekDirection = SeekDirection.Free) where TKey : IComparable<TKey> Parameters src SortedList<TKey, V> The source sorted list. key TKey The key to search for. floorValue V The output floor value. floorListIndex int The output floor list index. seekingStartListIndex int The start list index for seeking. seekDirection SeekDirection The seek direction. Returns SearchResult The binary search result. Type Parameters TKey The type of keys in the sorted list. V The type of values in the sorted list. GetFloorListIndexBySeek<TKey, V>(SortedList<TKey, V>, TKey, out int, int, SeekDirection) Gets the floor list index by seeking with the specified direction. public static SearchResult GetFloorListIndexBySeek<TKey, V>(this SortedList<TKey, V> src, TKey key, out int floorListIndex, int seekingStartListIndex, SeekDirection seekDirection = SeekDirection.Free) where TKey : IComparable<TKey> Parameters src SortedList<TKey, V> The source sorted list. key TKey The key to search for. floorListIndex int The output floor list index. seekingStartListIndex int Start list index for seeking. seekDirection SeekDirection The seek direction. Default is Free. Returns SearchResult The search result. Type Parameters TKey The type of keys in the sorted list. V The type of values in the sorted list. Remarks The Free seek direction does not loss additional performance. The seek direction only effect the resulting value by the seekingStartListIndex bound. GetFloorListIndex<TKey, V>(SortedList<TKey, V>, TKey, out int, int, int) Gets the index of the element in a sorted list that has a key less than or equal to a specified key. public static SearchResult GetFloorListIndex<TKey, V>(this SortedList<TKey, V> src, TKey key, out int resultListIndex, int beginListIndex = 0, int endListIndex = -1) where TKey : IComparable<TKey> Parameters src SortedList<TKey, V> The source sorted list. key TKey The key to search for. resultListIndex int When this method returns, contains the index of the floor element if found; otherwise, -1. beginListIndex int The starting index for the search range (inclusive). endListIndex int The ending index for the search range (exclusive). Returns SearchResult A value indicating whether an exact match was found, a floor value was found, or no suitable element exists. Type Parameters TKey The type of keys in the sorted list. V The type of values in the sorted list. GetFloor<TKey, V>(SortedList<TKey, V>, TKey, out V, int, int) Get floor value by key. If return value is NotExisted, resultValue will be the default value of V. public static SearchResult GetFloor<TKey, V>(this SortedList<TKey, V> src, TKey key, out V resultValue, int beginIndex = 0, int endIndex = -1) where TKey : IComparable<TKey> Parameters src SortedList<TKey, V> source key TKey key resultValue V floor value beginIndex int The starting index for the search range (inclusive). Default is 0. endIndex int The ending index for the search range (exclusive). Default is -1, which means the end of the list. Returns SearchResult search result Type Parameters TKey Key type V Value type GetFloor<TKey, V>(SortedList<TKey, V>, TKey, out V, out int, int, int) Get floor value by key. If return value is NotExisted, resultValue will be the default value of V. public static SearchResult GetFloor<TKey, V>(this SortedList<TKey, V> src, TKey key, out V resultValue, out int floorIndex, int beginIndex = 0, int endIndex = -1) where TKey : IComparable<TKey> Parameters src SortedList<TKey, V> source key TKey key resultValue V floor value floorIndex int The output floor index. beginIndex int The starting index for the search range (inclusive). Default is 0. endIndex int The ending index for the search range (exclusive). Default is -1, which means the end of the list. Returns SearchResult search result Type Parameters TKey Key type V Value type GetIndexRangeByKeyBoundary<TKey, V>(SortedList<TKey, V>, TKey, bool, TKey, bool, int, int) Gets the index range by key boundary. public static Range<int> GetIndexRangeByKeyBoundary<TKey, V>(this SortedList<TKey, V> src, TKey begin, bool isIncludingBeginFloor, TKey end, bool isIncludingEndCeil, int beginListIndex = 0, int endListIndex = -1) where TKey : IComparable<TKey> Parameters src SortedList<TKey, V> The source sorted list. begin TKey The begin key. isIncludingBeginFloor bool Whether to include the floor of begin key. end TKey The end key. isIncludingEndCeil bool Whether to include the ceil of end key. beginListIndex int The starting index for the search range (inclusive). endListIndex int The ending index for the search range (exclusive). Returns Range<int> The index range, or null if not found. Type Parameters TKey The type of keys in the sorted list. V The type of values in the sorted list. GetNearestIndex<V>(SortedList<double, V>, double, out int, int, int) Gets the index of the element in a sorted list that has a key nearest to a specified key. public static SearchResult GetNearestIndex<V>(this SortedList<double, V> src, double key, out int resultIndex, int beginIndex = 0, int endIndex = -1) Parameters src SortedList<double, V> The source sorted list. key double The key to search for. resultIndex int When this method returns, contains the index of the nearest element if found; otherwise, -1. beginIndex int The starting index for the search range (inclusive). Default is 0. endIndex int The ending index for the search range (exclusive). Default is -1, which means the end of the list. Returns SearchResult A value indicating whether an exact match was found, or the nearest floor/ceiling value. Type Parameters V The type of values in the sorted list. GetNearestKey<V>(SortedList<double, V>, double, out double, int, int) Gets the key in a sorted list that is nearest to a specified key. public static SearchResult GetNearestKey<V>(this SortedList<double, V> src, double key, out double resultKey, int beginIndex = 0, int endIndex = -1) Parameters src SortedList<double, V> The source sorted list. key double The key to search for. resultKey double When this method returns, contains the nearest key if found; otherwise, NaN. beginIndex int The starting index for the search range (inclusive). Default is 0. endIndex int The ending index for the search range (exclusive). Default is -1, which means the end of the list. Returns SearchResult A value indicating whether an exact match was found, or the nearest floor/ceiling value. Type Parameters V The type of values in the sorted list. GetNearestValue<V>(SortedList<double, V>, double, out V, int, int) Gets the value in a sorted list that corresponds to the key nearest to a specified key. public static SearchResult GetNearestValue<V>(this SortedList<double, V> src, double key, out V resultValue, int beginIndex = 0, int endIndex = -1) Parameters src SortedList<double, V> The source sorted list. key double The key to search for. resultValue V When this method returns, contains the value corresponding to the nearest key if found; otherwise, the default value for the type. beginIndex int The starting index for the search range (inclusive). Default is 0. endIndex int The ending index for the search range (exclusive). Default is -1, which means the end of the list. Returns SearchResult A value indicating whether an exact match was found, or the nearest floor/ceiling value. Type Parameters V The type of values in the sorted list. GetSortedListByKeyBoundary<TKey, V>(SortedList<TKey, V>, TKey, bool, TKey, bool, int, int) Creates a new sorted list containing key-value pairs from a source sorted list within a specified key range. public static SortedList<TKey, V> GetSortedListByKeyBoundary<TKey, V>(this SortedList<TKey, V> src, TKey begin, bool isIncludingBeginFloor, TKey end, bool isIncludingEndCeil, int beginIndex = 0, int endIndex = -1) where TKey : IComparable<TKey> Parameters src SortedList<TKey, V> The source sorted list. begin TKey The beginning key of the range. isIncludingBeginFloor bool Whether to include the floor value of the beginning key. end TKey The ending key of the range. isIncludingEndCeil bool Whether to include the ceiling value of the ending key. beginIndex int The starting index for the search range (inclusive). Default is 0. endIndex int The ending index for the search range (exclusive). Default is -1, which means the end of the list. Returns SortedList<TKey, V> A new sorted list containing key-value pairs within the specified range. Type Parameters TKey The type of keys in the sorted list. V The type of values in the sorted list. GetValuesByKeyBoundary<TKey, V>(SortedList<TKey, V>, TKey, bool, TKey, bool, int, int) Gets a list of values from a sorted list within a specified key range. public static List<V> GetValuesByKeyBoundary<TKey, V>(this SortedList<TKey, V> src, TKey begin, bool isIncludingBeginFloor, TKey end, bool isIncludingEndCeil, int beginIndex = 0, int endIndex = -1) where TKey : IComparable<TKey> Parameters src SortedList<TKey, V> The source sorted list. begin TKey The beginning key of the range. isIncludingBeginFloor bool Whether to include the floor value of the beginning key. end TKey The ending key of the range. isIncludingEndCeil bool Whether to include the ceiling value of the ending key. beginIndex int The starting index for the search range (inclusive). Default is 0. endIndex int The ending index for the search range (exclusive). Default is -1, which means the end of the list. Returns List<V> A list of values within the specified range. Type Parameters TKey The type of keys in the sorted list. V The type of values in the sorted list. ToSortedList<TKey, TValue>(List<TValue>, Func<TValue, TKey>) Converts a list of values to a sorted list using a key selector function. public static SortedList<TKey, TValue> ToSortedList<TKey, TValue>(this List<TValue> src, Func<TValue, TKey> keyFunc) where TKey : IComparable<TKey> Parameters src List<TValue> The source list of values. keyFunc Func<TValue, TKey> A function to extract a key from each value. Returns SortedList<TKey, TValue> A sorted list containing the values from the source list, keyed by the extracted keys. Type Parameters TKey The type of keys in the resulting sorted list. TValue The type of values in the list and the resulting sorted list."
  },
  "api/Hi.Common.Collections.SubList-1.html": {
    "href": "api/Hi.Common.Collections.SubList-1.html",
    "title": "Class SubList<T> | HiAPI-C# 2025",
    "summary": "Class SubList<T> Namespace Hi.Common.Collections Assembly HiGeom.dll Represents a sub-list view of a source list within a specified index range. public class SubList<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable Type Parameters T The type of elements in the list. Inheritance object SubList<T> Implements IList<T> ICollection<T> IEnumerable<T> IEnumerable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) StringUtil.ToDotSplitedString<T>(IEnumerable<T>) ListUtil.GetCeilBySeek<TItem, TKey>(IList<TItem>, TKey, Func<TItem, TKey>, out TItem, out int, int, SeekDirection) ListUtil.GetCeilIndexBySeek<TItem, TKey>(IList<TItem>, TKey, Func<TItem, TKey>, out int, int, SeekDirection) ListUtil.GetCeilIndex<Item, ItemKey>(IList<Item>, ItemKey, Func<Item, ItemKey, int>, out int) ListUtil.GetCeilIndex<TKey, Item>(IList<Item>, TKey, Func<Item, TKey>, out int) ListUtil.GetCeil<TKey, Item>(IList<Item>, TKey, Func<Item, TKey>, out Item) ListUtil.GetFloorBySeek<TItem, TKey>(IList<TItem>, TKey, Func<TItem, TKey>, out TItem, out int, int, SeekDirection) ListUtil.GetFloorIndexBySeek<TItem, TKey>(IList<TItem>, TKey, Func<TItem, TKey>, out int, int, SeekDirection) ListUtil.GetFloorIndex<Item, ItemKey>(IList<Item>, ItemKey, Func<Item, ItemKey, int>, out int) ListUtil.GetFloorIndex<TKey, Item>(IList<Item>, TKey, Func<Item, TKey>, out int) ListUtil.GetFloor<TKey, Item>(IList<Item>, TKey, Func<Item, TKey>, out Item) ListUtil.GetIndexBasedEnumerable<TItem>(IList<TItem>) ListUtil.GetIndexBasedEnumerable<TItem>(IList<TItem>, int, int) ListUtil.GetIndexByBinarySearch<TItem>(IList<TItem>, TItem) ListUtil.GetIndexByBinarySearch<TItem>(IList<TItem>, TItem, IComparer<TItem>) ListUtil.GetIndexByBinarySearch<TItem, TSearch>(IList<TItem>, TSearch, Func<TSearch, TItem, int>) ListUtil.GetNearestIndex<TItem, TItemKey>(IList<TItem>, TItemKey, Func<TItem, TItemKey, double>, out int) ListUtil.GetNearestIndex<TItem, TItemKey>(IList<TItem>, TItemKey, Func<TItem, TItemKey, int>, Func<TItem, TItemKey, double>, out int) ListUtil.GetSubList<TItem>(IList<TItem>, int, int) ListUtil.Swap<TItem>(IList<TItem>, int, int) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SubList(IList<T>, int, int) Initializes a new instance. public SubList(IList<T> source, int beginIndex, int endIndex) Parameters source IList<T> The source list. beginIndex int The starting index (inclusive). endIndex int The ending index (exclusive). Properties Count Gets the number of elements contained in the ICollection<T>. public int Count { get; } Property Value int The number of elements contained in the ICollection<T>. IsReadOnly Gets a value indicating whether the ICollection<T> is read-only. public bool IsReadOnly { get; } Property Value bool true if the ICollection<T> is read-only; otherwise, false. this[int] Gets or sets the element at the specified index. public T this[int index] { get; set; } Parameters index int The zero-based index of the element to get or set. Property Value T The element at the specified index. Exceptions ArgumentOutOfRangeException index is not a valid index in the IList<T>. NotSupportedException The property is set and the IList<T> is read-only. Methods Add(T) Adds an item to the ICollection<T>. public void Add(T item) Parameters item T The object to add to the ICollection<T>. Exceptions NotSupportedException The ICollection<T> is read-only. Clear() Removes all items from the ICollection<T>. public void Clear() Exceptions NotSupportedException The ICollection<T> is read-only. Contains(T) Determines whether the ICollection<T> contains a specific value. public bool Contains(T item) Parameters item T The object to locate in the ICollection<T>. Returns bool true if item is found in the ICollection<T>; otherwise, false. CopyTo(T[], int) Copies the elements of the ICollection<T> to an Array, starting at a particular Array index. public void CopyTo(T[] array, int arrayIndex) Parameters array T[] The one-dimensional Array that is the destination of the elements copied from ICollection<T>. The Array must have zero-based indexing. arrayIndex int The zero-based index in array at which copying begins. Exceptions ArgumentNullException array is null. ArgumentOutOfRangeException arrayIndex is less than 0. ArgumentException The number of elements in the source ICollection<T> is greater than the available space from arrayIndex to the end of the destination array. GetEnumerator() Returns an enumerator that iterates through the collection. public IEnumerator<T> GetEnumerator() Returns IEnumerator<T> An enumerator that can be used to iterate through the collection. IndexOf(T) Determines the index of a specific item in the IList<T>. public int IndexOf(T item) Parameters item T The object to locate in the IList<T>. Returns int The index of item if found in the list; otherwise, -1. Insert(int, T) Inserts an item to the IList<T> at the specified index. public void Insert(int index, T item) Parameters index int The zero-based index at which item should be inserted. item T The object to insert into the IList<T>. Exceptions ArgumentOutOfRangeException index is not a valid index in the IList<T>. NotSupportedException The IList<T> is read-only. Remove(T) Removes the first occurrence of a specific object from the ICollection<T>. public bool Remove(T item) Parameters item T The object to remove from the ICollection<T>. Returns bool true if item was successfully removed from the ICollection<T>; otherwise, false. This method also returns false if item is not found in the original ICollection<T>. Exceptions NotSupportedException The ICollection<T> is read-only. RemoveAt(int) Removes the IList<T> item at the specified index. public void RemoveAt(int index) Parameters index int The zero-based index of the item to remove. Exceptions ArgumentOutOfRangeException index is not a valid index in the IList<T>. NotSupportedException The IList<T> is read-only."
  },
  "api/Hi.Common.Collections.SynList-1.html": {
    "href": "api/Hi.Common.Collections.SynList-1.html",
    "title": "Class SynList<T> | HiAPI-C# 2025",
    "summary": "Class SynList<T> Namespace Hi.Common.Collections Assembly HiGeom.dll Thread-safe List. public class SynList<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable Type Parameters T T Inheritance object SynList<T> Implements IList<T> ICollection<T> IEnumerable<T> IEnumerable Derived DispList Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) StringUtil.ToDotSplitedString<T>(IEnumerable<T>) ListUtil.GetCeilBySeek<TItem, TKey>(IList<TItem>, TKey, Func<TItem, TKey>, out TItem, out int, int, SeekDirection) ListUtil.GetCeilIndexBySeek<TItem, TKey>(IList<TItem>, TKey, Func<TItem, TKey>, out int, int, SeekDirection) ListUtil.GetCeilIndex<Item, ItemKey>(IList<Item>, ItemKey, Func<Item, ItemKey, int>, out int) ListUtil.GetCeilIndex<TKey, Item>(IList<Item>, TKey, Func<Item, TKey>, out int) ListUtil.GetCeil<TKey, Item>(IList<Item>, TKey, Func<Item, TKey>, out Item) ListUtil.GetFloorBySeek<TItem, TKey>(IList<TItem>, TKey, Func<TItem, TKey>, out TItem, out int, int, SeekDirection) ListUtil.GetFloorIndexBySeek<TItem, TKey>(IList<TItem>, TKey, Func<TItem, TKey>, out int, int, SeekDirection) ListUtil.GetFloorIndex<Item, ItemKey>(IList<Item>, ItemKey, Func<Item, ItemKey, int>, out int) ListUtil.GetFloorIndex<TKey, Item>(IList<Item>, TKey, Func<Item, TKey>, out int) ListUtil.GetFloor<TKey, Item>(IList<Item>, TKey, Func<Item, TKey>, out Item) ListUtil.GetIndexBasedEnumerable<TItem>(IList<TItem>) ListUtil.GetIndexBasedEnumerable<TItem>(IList<TItem>, int, int) ListUtil.GetIndexByBinarySearch<TItem>(IList<TItem>, TItem) ListUtil.GetIndexByBinarySearch<TItem>(IList<TItem>, TItem, IComparer<TItem>) ListUtil.GetIndexByBinarySearch<TItem, TSearch>(IList<TItem>, TSearch, Func<TSearch, TItem, int>) ListUtil.GetNearestIndex<TItem, TItemKey>(IList<TItem>, TItemKey, Func<TItem, TItemKey, double>, out int) ListUtil.GetNearestIndex<TItem, TItemKey>(IList<TItem>, TItemKey, Func<TItem, TItemKey, int>, Func<TItem, TItemKey, double>, out int) ListUtil.GetSubList<TItem>(IList<TItem>, int, int) ListUtil.Swap<TItem>(IList<TItem>, int, int) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SynList(SynList<T>) public SynList(SynList<T> src) Parameters src SynList<T> SynList(IEnumerable<T>) public SynList(IEnumerable<T> ts) Parameters ts IEnumerable<T> SynList(int) public SynList(int cap = 8) Parameters cap int Properties Count Gets the number of elements contained in the ICollection<T>. public int Count { get; } Property Value int The number of elements contained in the ICollection<T>. Data public List<T> Data { get; set; } Property Value List<T> IsReadOnly Gets a value indicating whether the ICollection<T> is read-only. public bool IsReadOnly { get; } Property Value bool true if the ICollection<T> is read-only; otherwise, false. this[int] Gets or sets the element at the specified index. public T this[int index] { get; set; } Parameters index int The zero-based index of the element to get or set. Property Value T The element at the specified index. Exceptions ArgumentOutOfRangeException index is not a valid index in the IList<T>. NotSupportedException The property is set and the IList<T> is read-only. Lock Lock object, which is Data public object Lock { get; } Property Value object Methods Add(T) Adds an item to the ICollection<T>. public void Add(T item) Parameters item T The object to add to the ICollection<T>. Exceptions NotSupportedException The ICollection<T> is read-only. AddAndGetIndex(T) Atomically appends item and returns the index it was inserted at. Use this instead of Add(T) + Count when the caller needs the position of the just-added item under concurrent appends (computing Count - 1 after Add(T) would race with other writers). public int AddAndGetIndex(T item) Parameters item T Returns int Clear() Removes all items from the ICollection<T>. public void Clear() Exceptions NotSupportedException The ICollection<T> is read-only. Contains(T) Determines whether the ICollection<T> contains a specific value. public bool Contains(T item) Parameters item T The object to locate in the ICollection<T>. Returns bool true if item is found in the ICollection<T>; otherwise, false. CopyTo(T[], int) Copies the elements of the ICollection<T> to an Array, starting at a particular Array index. public void CopyTo(T[] array, int arrayIndex) Parameters array T[] The one-dimensional Array that is the destination of the elements copied from ICollection<T>. The Array must have zero-based indexing. arrayIndex int The zero-based index in array at which copying begins. Exceptions ArgumentNullException array is null. ArgumentOutOfRangeException arrayIndex is less than 0. ArgumentException The number of elements in the source ICollection<T> is greater than the available space from arrayIndex to the end of the destination array. GetEnumerator() Returns an enumerator that iterates through the collection. public IEnumerator<T> GetEnumerator() Returns IEnumerator<T> An enumerator that can be used to iterate through the collection. IndexOf(T) Determines the index of a specific item in the IList<T>. public int IndexOf(T item) Parameters item T The object to locate in the IList<T>. Returns int The index of item if found in the list; otherwise, -1. Insert(int, T) Inserts an item to the IList<T> at the specified index. public void Insert(int index, T item) Parameters index int The zero-based index at which item should be inserted. item T The object to insert into the IList<T>. Exceptions ArgumentOutOfRangeException index is not a valid index in the IList<T>. NotSupportedException The IList<T> is read-only. Remove(T) Removes the first occurrence of a specific object from the ICollection<T>. public bool Remove(T item) Parameters item T The object to remove from the ICollection<T>. Returns bool true if item was successfully removed from the ICollection<T>; otherwise, false. This method also returns false if item is not found in the original ICollection<T>. Exceptions NotSupportedException The ICollection<T> is read-only. RemoveAt(int) Removes the IList<T> item at the specified index. public void RemoveAt(int index) Parameters index int The zero-based index of the item to remove. Exceptions ArgumentOutOfRangeException index is not a valid index in the IList<T>. NotSupportedException The IList<T> is read-only. ToList() Creates a new List<T> containing all elements from this synchronized list. This operation is thread-safe as it acquires a lock on the underlying data. public List<T> ToList() Returns List<T> A new List<T> containing all elements from this synchronized list."
  },
  "api/Hi.Common.Collections.html": {
    "href": "api/Hi.Common.Collections.html",
    "title": "Namespace Hi.Common.Collections | HiAPI-C# 2025",
    "summary": "Namespace Hi.Common.Collections Classes DictionaryUtil Utility class providing extension methods for dictionary operations. EnumerableUtil Utility class providing extension methods for enumerable collections. FixedSizeConcurrentLinkedListUtil Utility of Fixed Size Concurrent LinkedList. LazyLinkedListNode<T> Node for LazyLinkedList<T>. Accessing Next on the tail node automatically materializes the next item from the list's source (if any). LazyLinkedList<T> A singly-growable linked list that can lazily materialize nodes from an IEnumerable<T> source. Without a source it behaves like a regular append-only linked list. With a source, nodes are pulled on demand when Next is accessed on the tail, or when First is accessed on an empty list. LinkedListUtil Utility methods for working with linked lists. ListIndexBasedEnumerable<T> Provides an enumerable wrapper for a list that iterates over a specified range of indices. ListIndexBasedIEnumerator<T> Provides an enumerator that iterates over a specified range of indices in a list. ListUtil Provides utility methods for working with lists and collections. SortedListUtil Utility class providing extension methods for SortedList operations. SubList<T> Represents a sub-list view of a source list within a specified index range. SynList<T> Thread-safe List. Enums ListUtil.OuterPolationMode Defines the mode for handling values outside the range of a collection during interpolation. SearchTargetMode Specifies the search method to use when looking for values in a sorted list. SeekDirection Specifies the seek direction for sorted list operations."
  },
  "api/Hi.Common.ConcurrentTimeCounter.html": {
    "href": "api/Hi.Common.ConcurrentTimeCounter.html",
    "title": "Class ConcurrentTimeCounter | HiAPI-C# 2025",
    "summary": "Class ConcurrentTimeCounter Namespace Hi.Common Assembly HiGeom.dll Thread-safe utility for measuring and tracking execution time across multiple tasks. public static class ConcurrentTimeCounter Inheritance object ConcurrentTimeCounter Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Remarks This is the concurrent version of TimeCounter, designed for multi-threaded environments. It measures the time elapsed between paired calls to Bound(object) with the same key in the same task. The timing starts on the first (odd-numbered) call to Bound(object) and stops on the second (even-numbered) call, accumulating statistics for each key. Methods Bound(object) Marks a boundary for time measurement for the specified key. public static void Bound(object key) Parameters key object The key to identify this measurement Remarks This method acts as both the start and end point for timing: On first call with a key, starts the timer On second call with the same key, stops the timer and records the elapsed time Subsequent calls alternate between starting and stopping Pass(object) Cancels an active time measurement for the specified key without recording the elapsed time. public static void Pass(object key) Parameters key object The key identifying the measurement to cancel Remarks If timing has not been started for the key, this method has no effect. This is useful when you want to abort a measurement without affecting statistics. Reset() Resets all time measurements across all tasks. Clears all accumulated statistics and counters. public static void Reset() Show() Displays all accumulated time measurements to the console. public static void Show() Remarks For each task and key, shows the count of measurements, total time, and average time. ShowExt(int) Displays time measurements and resets counters periodically based on call frequency. public static void ShowExt(int gap) Parameters gap int The number of calls to this method before showing results and resetting Remarks This method increments an internal counter with each call. When the counter reaches the specified gap value, it displays all measurements, resets the counters, and resets the internal counter to zero."
  },
  "api/Hi.Common.ConsoleUtil.html": {
    "href": "api/Hi.Common.ConsoleUtil.html",
    "title": "Class ConsoleUtil | HiAPI-C# 2025",
    "summary": "Class ConsoleUtil Namespace Hi.Common Assembly HiGeom.dll Utility class for console window operations. public static class ConsoleUtil Inheritance object ConsoleUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods ApplyCppConsole() Applies the console handle to standard output and error streams for C++ compatibility. public static void ApplyCppConsole() Hide() Hides the console window. public static void Hide() SetStdHandle(int, nint) Sets the handle for the specified standard device (standard input, standard output, or standard error). public static extern int SetStdHandle(int stdHandle, nint handle) Parameters stdHandle int The standard device handle nint The handle Returns int Nonzero if the function succeeds; otherwise, zero Show() Shows the console window. If the console doesn't exist, it creates a new one. public static void Show()"
  },
  "api/Hi.Common.CppLogUtil.LogDelegate.html": {
    "href": "api/Hi.Common.CppLogUtil.LogDelegate.html",
    "title": "Delegate CppLogUtil.LogDelegate | HiAPI-C# 2025",
    "summary": "Delegate CppLogUtil.LogDelegate Namespace Hi.Common Assembly HiDisp.dll Internal Use Only. public delegate void CppLogUtil.LogDelegate(string msg) Parameters msg string Internal Use Only. Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Common.CppLogUtil.html": {
    "href": "api/Hi.Common.CppLogUtil.html",
    "title": "Class CppLogUtil | HiAPI-C# 2025",
    "summary": "Class CppLogUtil Namespace Hi.Common Assembly HiDisp.dll Internal Use Only. public static class CppLogUtil Inheritance object CppLogUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods SetLogFunc(LogDelegate) Sets the logging function for C++ code. public static void SetLogFunc(CppLogUtil.LogDelegate logFunc) Parameters logFunc CppLogUtil.LogDelegate The logging delegate to use."
  },
  "api/Hi.Common.CsvUtils.CsvInputKit.html": {
    "href": "api/Hi.Common.CsvUtils.CsvInputKit.html",
    "title": "Class CsvInputKit | HiAPI-C# 2025",
    "summary": "Class CsvInputKit Namespace Hi.Common.CsvUtils Assembly HiGeom.dll Utility class for parsing and processing CSV input data. public class CsvInputKit Inheritance object CsvInputKit Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CsvInputKit() Initializes a new instance of the CsvInputKit class. public CsvInputKit() Properties TitleLine Gets or sets the CSV header line as a comma-separated string. public string TitleLine { get; set; } Property Value string TitleList Gets or sets the list of column titles from the CSV header. public List<string> TitleList { get; set; } Property Value List<string> TypeDictionary Dictionary mapping type names to their corresponding Type objects. public Dictionary<string, Type> TypeDictionary { get; } Property Value Dictionary<string, Type> Methods GetCsvDictionary(IList<string>, string) Splits a CSV row into a title→cell dictionary. Stateless allocation-light variant of GetCsvDictionary(string); use this when the caller already has the title list and does not need to hold a CsvInputKit instance. public static Dictionary<string, string> GetCsvDictionary(IList<string> titleList, string row) Parameters titleList IList<string> Column titles, in CSV column order. row string CSV data row (not the header line). Returns Dictionary<string, string> Dictionary keyed by column title; cells past titleList are keyed by column[i]. GetCsvDictionary(string) Creates a dictionary from a CSV row, mapping column titles to their values. The row should not be the header line, and TitleLine or TitleList must be set first. public Dictionary<string, string> GetCsvDictionary(string row) Parameters row string The CSV row to process Returns Dictionary<string, string> A dictionary mapping column titles to their values"
  },
  "api/Hi.Common.CsvUtils.CsvOutputKit.html": {
    "href": "api/Hi.Common.CsvUtils.CsvOutputKit.html",
    "title": "Class CsvOutputKit | HiAPI-C# 2025",
    "summary": "Class CsvOutputKit Namespace Hi.Common.CsvUtils Assembly HiGeom.dll CSV output toolkit. Toolkit for getting Comma-seperated Csv lines. public class CsvOutputKit Inheritance object CsvOutputKit Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CsvOutputKit(List<string>) Ctor. public CsvOutputKit(List<string> prefixTitleList = null) Parameters prefixTitleList List<string> Custom title order at the leading columns. If no custom order needed, keep the parameter null. Methods BuildCsvTitleByCsvRow(IGetCsvDictionary) Builds the CSV title structure based on the keys in the dictionary provided by an IGetCsvDictionary object. public void BuildCsvTitleByCsvRow(IGetCsvDictionary row) Parameters row IGetCsvDictionary An object implementing IGetCsvDictionary interface. BuildCsvTitleByCsvRow(Dictionary<string, string>) Builds the CSV title structure based on the keys in the provided dictionary. public void BuildCsvTitleByCsvRow(Dictionary<string, string> row) Parameters row Dictionary<string, string> Dictionary containing key-value pairs to be used for building the CSV title. GetCsvRowText(IGetCsvDictionary) Converts an object implementing IGetCsvDictionary to a CSV row text. public string GetCsvRowText(IGetCsvDictionary row) Parameters row IGetCsvDictionary An object implementing IGetCsvDictionary interface. Returns string A comma-separated string representing the row, or null if the input is null. GetCsvRowText(Dictionary<string, object>) Converts a dictionary of string keys and object values to a CSV row text. public string GetCsvRowText(Dictionary<string, object> row) Parameters row Dictionary<string, object> Dictionary containing key-value pairs to be converted to CSV format. Returns string A comma-separated string representing the row, or null if the input is null. GetCsvRowText(Dictionary<string, string>) Converts a dictionary of string keys and values to a CSV row text. public string GetCsvRowText(Dictionary<string, string> row) Parameters row Dictionary<string, string> Dictionary containing key-value pairs to be converted to CSV format. Returns string A comma-separated string representing the row, or null if the input is null. GetCsvTitle() The title is obtained by the previous added csv row. public string GetCsvTitle() Returns string"
  },
  "api/Hi.Common.CsvUtils.CsvUtil.html": {
    "href": "api/Hi.Common.CsvUtils.CsvUtil.html",
    "title": "Class CsvUtil | HiAPI-C# 2025",
    "summary": "Class CsvUtil Namespace Hi.Common.CsvUtils Assembly HiGeom.dll Provides utility methods for working with CSV (Comma-Separated Values) data. public static class CsvUtil Inheritance object CsvUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetCsvLines(IEnumerable<IGetCsvDictionary>, List<string>) Get Comma-seperated Csv lines. The title line is at the last return. public static IEnumerable<string> GetCsvLines(this IEnumerable<IGetCsvDictionary> rows, List<string> prefixTitleList = null) Parameters rows IEnumerable<IGetCsvDictionary> rows prefixTitleList List<string> Custom title order at the leading columns. If no custom order needed, keep the parameter null. Returns IEnumerable<string> CSV lines. GetCsvLines(IEnumerable<Dictionary<string, string>>, List<string>) Get Comma-seperated Csv lines. The title line is at the last return. public static IEnumerable<string> GetCsvLines(IEnumerable<Dictionary<string, string>> rows, List<string> prefixTitleList = null) Parameters rows IEnumerable<Dictionary<string, string>> rows prefixTitleList List<string> Custom title order at the leading columns. If no custom order needed, keep the parameter null. Returns IEnumerable<string> CSV lines. GetCsvRowText(object[]) Converts an array of objects to a CSV row text. public static string GetCsvRowText(object[] objs) Parameters objs object[] Array of objects to be converted to CSV format. Returns string A comma-separated string representing the objects."
  },
  "api/Hi.Common.CsvUtils.ICsvRowIo.html": {
    "href": "api/Hi.Common.CsvUtils.ICsvRowIo.html",
    "title": "Interface ICsvRowIo | HiAPI-C# 2025",
    "summary": "Interface ICsvRowIo Namespace Hi.Common.CsvUtils Assembly HiGeom.dll Object that can be two-way converting between CSV row. public interface ICsvRowIo Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties CsvText Csv text. string CsvText { get; set; } Property Value string CsvTitleText Csv titles text. string CsvTitleText { get; } Property Value string"
  },
  "api/Hi.Common.CsvUtils.IGetCsvDictionary.html": {
    "href": "api/Hi.Common.CsvUtils.IGetCsvDictionary.html",
    "title": "Interface IGetCsvDictionary | HiAPI-C# 2025",
    "summary": "Interface IGetCsvDictionary Namespace Hi.Common.CsvUtils Assembly HiGeom.dll Interface of GetCsvDictionary(). It suits for CSV output. public interface IGetCsvDictionary Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetCsvDictionary() Get row dictionary. It suits for CSV output. Dictionary<string, string> GetCsvDictionary() Returns Dictionary<string, string> csv row dictionary"
  },
  "api/Hi.Common.CsvUtils.html": {
    "href": "api/Hi.Common.CsvUtils.html",
    "title": "Namespace Hi.Common.CsvUtils | HiAPI-C# 2025",
    "summary": "Namespace Hi.Common.CsvUtils Classes CsvInputKit Utility class for parsing and processing CSV input data. CsvOutputKit CSV output toolkit. Toolkit for getting Comma-seperated Csv lines. CsvUtil Provides utility methods for working with CSV (Comma-Separated Values) data. Interfaces ICsvRowIo Object that can be two-way converting between CSV row. IGetCsvDictionary Interface of GetCsvDictionary(). It suits for CSV output."
  },
  "api/Hi.Common.CultureTextAttribute.html": {
    "href": "api/Hi.Common.CultureTextAttribute.html",
    "title": "Class CultureTextAttribute | HiAPI-C# 2025",
    "summary": "Class CultureTextAttribute Namespace Hi.Common Assembly HiGeom.dll Declares one culture's text for one vocabulary key on the member carrying the attribute — the static wording of command titles and labels, owned by the declaring library as a DEFAULT: a GUI layer may override it or add cultures the library never declared (see SetTextOverride(string, string, string)), and a culture left undeclared is not an error — lookups fall back toward the English key. The key defaults to the member's own display name: its DisplayNameAttribute value when present, otherwise the member name spaced into words (SpacePascalWords(string)). Set Key to declare a word the member does not itself name (a shared switch word, a mode label). Apply the attribute once per culture. [AttributeUsage(AttributeTargets.Class|AttributeTargets.Struct|AttributeTargets.Enum|AttributeTargets.Method|AttributeTargets.Property|AttributeTargets.Field|AttributeTargets.Interface, AllowMultiple = true, Inherited = false)] public sealed class CultureTextAttribute : Attribute Inheritance object Attribute CultureTextAttribute Inherited Members Attribute.Equals(object) Attribute.GetCustomAttribute(Assembly, Type) Attribute.GetCustomAttribute(Assembly, Type, bool) Attribute.GetCustomAttribute(MemberInfo, Type) Attribute.GetCustomAttribute(MemberInfo, Type, bool) Attribute.GetCustomAttribute(Module, Type) Attribute.GetCustomAttribute(Module, Type, bool) Attribute.GetCustomAttribute(ParameterInfo, Type) Attribute.GetCustomAttribute(ParameterInfo, Type, bool) Attribute.GetCustomAttributes(Assembly) Attribute.GetCustomAttributes(Assembly, bool) Attribute.GetCustomAttributes(Assembly, Type) Attribute.GetCustomAttributes(Assembly, Type, bool) Attribute.GetCustomAttributes(MemberInfo) Attribute.GetCustomAttributes(MemberInfo, bool) Attribute.GetCustomAttributes(MemberInfo, Type) Attribute.GetCustomAttributes(MemberInfo, Type, bool) Attribute.GetCustomAttributes(Module) Attribute.GetCustomAttributes(Module, bool) Attribute.GetCustomAttributes(Module, Type) Attribute.GetCustomAttributes(Module, Type, bool) Attribute.GetCustomAttributes(ParameterInfo) Attribute.GetCustomAttributes(ParameterInfo, bool) Attribute.GetCustomAttributes(ParameterInfo, Type) Attribute.GetCustomAttributes(ParameterInfo, Type, bool) Attribute.GetHashCode() Attribute.IsDefaultAttribute() Attribute.IsDefined(Assembly, Type) Attribute.IsDefined(Assembly, Type, bool) Attribute.IsDefined(MemberInfo, Type) Attribute.IsDefined(MemberInfo, Type, bool) Attribute.IsDefined(Module, Type) Attribute.IsDefined(Module, Type, bool) Attribute.IsDefined(ParameterInfo, Type) Attribute.IsDefined(ParameterInfo, Type, bool) Attribute.Match(object) Attribute.TypeId object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CultureTextAttribute(string, string) Declares text as the wording of this member's vocabulary key in the culture named cultureName. public CultureTextAttribute(string cultureName, string text) Parameters cultureName string Culture name the text is written in (e.g. zh-Hant). text string The text in that culture. Properties CultureName Culture name the text is written in (e.g. zh-Hant). public string CultureName { get; } Property Value string Key Explicit vocabulary key. Default (null): the member's display name as described on the class summary. public string Key { get; set; } Property Value string Text The text in that culture. public string Text { get; } Property Value string"
  },
  "api/Hi.Common.CultureUtil.html": {
    "href": "api/Hi.Common.CultureUtil.html",
    "title": "Class CultureUtil | HiAPI-C# 2025",
    "summary": "Class CultureUtil Namespace Hi.Common Assembly HiGeom.dll The English culture the engine formats and parses with, and the one call that pins a thread to it. public static class CultureUtil Inheritance object CultureUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Properties English English, with NaNSymbol forced to “NaN” so a non-finite value round-trips through text. public static CultureInfo English { get; } Property Value CultureInfo Remarks Read-only, and safe to hand to APIs that keep the reference: ASP.NET request localization matches by name and returns ReadOnly(CultureInfo) clones, which preserve the patched symbol. Methods SetCurrentCultureEn() Pins the calling thread to English. public static void SetCurrentCultureEn()"
  },
  "api/Hi.Common.DuplicateUtil.html": {
    "href": "api/Hi.Common.DuplicateUtil.html",
    "title": "Class DuplicateUtil | HiAPI-C# 2025",
    "summary": "Class DuplicateUtil Namespace Hi.Common Assembly HiGeom.dll Utility methods for duplication operations. public static class DuplicateUtil Inheritance object DuplicateUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods TryDuplicate<TSelf>(TSelf, params object[]) Attempts to create a duplicate of the source object using the most appropriate method available. public static TSelf TryDuplicate<TSelf>(this TSelf src, params object[] res) where TSelf : class Parameters src TSelf The source object to duplicate res object[] Optional parameters that may be needed during the duplication process Returns TSelf A duplicate of the source object if it implements IDuplicate or ICloneable; otherwise, null. Type Parameters TSelf The type of the source object Remarks The method first tries to use Duplicate(params object[]) if the source implements IDuplicate. If that's not available, it falls back to Clone() if the source implements ICloneable."
  },
  "api/Hi.Common.EnumUtil.html": {
    "href": "api/Hi.Common.EnumUtil.html",
    "title": "Class EnumUtil | HiAPI-C# 2025",
    "summary": "Class EnumUtil Namespace Hi.Common Assembly HiGeom.dll Utility class for enum operations. public static class EnumUtil Inheritance object EnumUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetEnumBitArrayCap(Type) Gets the capacity needed for a bit array to represent all values of an enum type. public static int GetEnumBitArrayCap(Type enumType) Parameters enumType Type The enum type Returns int The maximum value in the enum plus 1 GetEnumBitArrayCap<TEnum>() Gets the capacity needed for a bit array to represent all values of an enum type. public static int GetEnumBitArrayCap<TEnum>() where TEnum : struct, Enum Returns int The maximum value in the enum plus 1 Type Parameters TEnum The enum type"
  },
  "api/Hi.Common.EnumerablePlayer.html": {
    "href": "api/Hi.Common.EnumerablePlayer.html",
    "title": "Class EnumerablePlayer | HiAPI-C# 2025",
    "summary": "Class EnumerablePlayer Namespace Hi.Common Assembly HiGeom.dll Run enumerable with Pause(), Resume() and etc. functions. public class EnumerablePlayer : IDisposable Inheritance object EnumerablePlayer Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors EnumerablePlayer() Ctor. public EnumerablePlayer() Properties Actions Collection of actions to be executed by the player. public IEnumerable<Action> Actions { get; set; } Property Value IEnumerable<Action> ExceptionAction Action to handle exceptions that occur during execution. public Action<Exception> ExceptionAction { get; set; } Property Value Action<Exception> IsFinished Is the process finished from Start(). public bool IsFinished { get; } Property Value bool IsLocked Is started but not finished. IsLocked keeps true even if Pause() is called. The property is true if a task started and the task has not yet finished. public bool IsLocked { get; } Property Value bool IsRunning Is running. Not paused either finished. The property is true if a task started and the task has not yet finished and Pause() is not called. public bool IsRunning { get; } Property Value bool ResettingSemaphore internal use. public SemaphoreSlim ResettingSemaphore { get; set; } Property Value SemaphoreSlim Methods BreakAsync() Breaks the current execution asynchronously. public Task BreakAsync() Returns Task A task representing the asynchronous operation. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool Pause() Pauses the execution of actions. public void Pause() Reset() Resets the player synchronously. public void Reset() ResetAsync() Asynchronously resets the player. public Task ResetAsync() Returns Task A task representing the asynchronous operation. Resume() Resume the process. public void Resume() RunToOneActionEnd() Runs the player until one action completes. public void RunToOneActionEnd() Start() Start the process. public Task Start() Returns Task Terminate() Terminates the execution of actions synchronously. public void Terminate() TerminateAsync() Terminates the execution of actions asynchronously. public Task TerminateAsync() Returns Task A task representing the asynchronous operation. WaitPlayingTask() Wait playing to an end. Wait Hi.Common.EnumerablePlayer.PlayingTask. public void WaitPlayingTask() Events EndedEvent Event triggered when the player ends. public event Action EndedEvent Event Type Action IsLockedEventHandler Event triggered when the lock state changes. public event Action<bool> IsLockedEventHandler Event Type Action<bool> IsRunningChangedEvent Event triggered when the running state changes. public event Action<bool> IsRunningChangedEvent Event Type Action<bool> OnCallingTerminate Event triggered when termination is being called. public event EventHandler OnCallingTerminate Event Type EventHandler OnFinished Event triggered when the player has finished playing all actions public event EventHandler OnFinished Event Type EventHandler ResetedEvent Event triggered after the player has been reset. public event Func<Task> ResetedEvent Event Type Func<Task> ResetingEvent Event triggered before resetting the player. public event Func<Task> ResetingEvent Event Type Func<Task> StartingEvent Event triggered when the player starts. public event Action StartingEvent Event Type Action"
  },
  "api/Hi.Common.FileLines.FileBeginEventArgs.html": {
    "href": "api/Hi.Common.FileLines.FileBeginEventArgs.html",
    "title": "Class FileBeginEventArgs | HiAPI-C# 2025",
    "summary": "Class FileBeginEventArgs Namespace Hi.Common.FileLines Assembly HiGeom.dll Event arguments for when a file processing begins. public class FileBeginEventArgs : EventArgs Inheritance object EventArgs FileBeginEventArgs Inherited Members EventArgs.Empty object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FileBeginEventArgs() Initializes a new instance of the FileBeginEventArgs class. public FileBeginEventArgs() FileBeginEventArgs(string) Initializes a new instance of the FileBeginEventArgs class with a specified file path. public FileBeginEventArgs(string file) Parameters file string The file path being processed. Properties File Gets or sets the file path being processed. public string File { get; set; } Property Value string"
  },
  "api/Hi.Common.FileLines.FileEndEventArgs.html": {
    "href": "api/Hi.Common.FileLines.FileEndEventArgs.html",
    "title": "Class FileEndEventArgs | HiAPI-C# 2025",
    "summary": "Class FileEndEventArgs Namespace Hi.Common.FileLines Assembly HiGeom.dll Event arguments for when a file processing ends. public class FileEndEventArgs : EventArgs Inheritance object EventArgs FileEndEventArgs Inherited Members EventArgs.Empty object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FileEndEventArgs() Initializes a new instance of the FileEndEventArgs class. public FileEndEventArgs() FileEndEventArgs(string) Initializes a new instance of the FileEndEventArgs class with a specified file path. public FileEndEventArgs(string file) Parameters file string The file path that was processed. Properties File Gets or sets the file path that was processed. public string File { get; set; } Property Value string"
  },
  "api/Hi.Common.FileLines.FileLineCharIndex.html": {
    "href": "api/Hi.Common.FileLines.FileLineCharIndex.html",
    "title": "Class FileLineCharIndex | HiAPI-C# 2025",
    "summary": "Class FileLineCharIndex Namespace Hi.Common.FileLines Assembly HiGeom.dll Represents a character-level position within a file by file index, line index, and character index. All indices are 0-based. public class FileLineCharIndex : IFileLineCharIndex, IFileLineIndex, IGetFileLineIndex, IComparable<FileLineCharIndex>, IEquatable<FileLineCharIndex> Inheritance object FileLineCharIndex Implements IFileLineCharIndex IFileLineIndex IGetFileLineIndex IComparable<FileLineCharIndex> IEquatable<FileLineCharIndex> Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MathUtil.Clamp<T>(T, T, T) FileLineUtil.CompareFileLine(IFileLineIndex, IFileLineIndex) FileLineUtil.GetFileNo(IFileLineIndex) FileLineUtil.GetLineNo(IFileLineIndex) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FileLineCharIndex() Initializes a new instance of the FileLineCharIndex class. public FileLineCharIndex() FileLineCharIndex(IFileLineCharIndex) Initializes a new instance of the FileLineCharIndex class by copying another instance. public FileLineCharIndex(IFileLineCharIndex src) Parameters src IFileLineCharIndex The source to copy from. FileLineCharIndex(int, int, int) Initializes a new instance of the FileLineCharIndex class with specified indices. public FileLineCharIndex(int fileIndex, int lineIndex, int charIndex) Parameters fileIndex int The zero-based file index. lineIndex int The zero-based line index. charIndex int The zero-based character index within the line. Properties CharIndex Character index within the line. 0-based. public int CharIndex { get; set; } Property Value int FileIndex File Index. Start on 0. public int FileIndex { get; set; } Property Value int LineIndex Line Index. Start on 0. public int LineIndex { get; set; } Property Value int Methods AtLineBegin(int, int) Creates a FileLineCharIndex at the beginning of a line (CharIndex = 0). public static FileLineCharIndex AtLineBegin(int fileIndex, int lineIndex) Parameters fileIndex int The zero-based file index. lineIndex int The zero-based line index. Returns FileLineCharIndex CompareTo(FileLineCharIndex) Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other object. public int CompareTo(FileLineCharIndex other) Parameters other FileLineCharIndex An object to compare with this instance. Returns int A value that indicates the relative order of the objects being compared. The return value has these meanings: Value Meaning Less than zero This instance precedes other in the sort order. Zero This instance occurs in the same position in the sort order as other. Greater than zero This instance follows other in the sort order. Equals(FileLineCharIndex) Indicates whether the current object is equal to another object of the same type. public bool Equals(FileLineCharIndex other) Parameters other FileLineCharIndex An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. GetFileLineIndex() Get FileLineIndex. public FileLineIndex GetFileLineIndex() Returns FileLineIndex FileLineIndex GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. ToUserString() Returns a user-friendly string representation. public string ToUserString() Returns string Operators operator ==(FileLineCharIndex, FileLineCharIndex) Returns true when both operands point to the same position, treating two null references as equal. public static bool operator ==(FileLineCharIndex left, FileLineCharIndex right) Parameters left FileLineCharIndex right FileLineCharIndex Returns bool operator >(FileLineCharIndex, FileLineCharIndex) Returns true when left orders after right; a null left is never after any value. public static bool operator >(FileLineCharIndex left, FileLineCharIndex right) Parameters left FileLineCharIndex right FileLineCharIndex Returns bool operator >=(FileLineCharIndex, FileLineCharIndex) Returns true when left orders at or after right; treats two null references as equal. public static bool operator >=(FileLineCharIndex left, FileLineCharIndex right) Parameters left FileLineCharIndex right FileLineCharIndex Returns bool operator !=(FileLineCharIndex, FileLineCharIndex) Returns true when the operands point to different positions. Inverse of operator ==(FileLineCharIndex, FileLineCharIndex). public static bool operator !=(FileLineCharIndex left, FileLineCharIndex right) Parameters left FileLineCharIndex right FileLineCharIndex Returns bool operator <(FileLineCharIndex, FileLineCharIndex) Returns true when left orders before right; a null left is treated as the lowest position. public static bool operator <(FileLineCharIndex left, FileLineCharIndex right) Parameters left FileLineCharIndex right FileLineCharIndex Returns bool operator <=(FileLineCharIndex, FileLineCharIndex) Returns true when left orders at or before right; a null left is always at-or-before any value. public static bool operator <=(FileLineCharIndex left, FileLineCharIndex right) Parameters left FileLineCharIndex right FileLineCharIndex Returns bool"
  },
  "api/Hi.Common.FileLines.FileLineCharIndexSegment.html": {
    "href": "api/Hi.Common.FileLines.FileLineCharIndexSegment.html",
    "title": "Class FileLineCharIndexSegment | HiAPI-C# 2025",
    "summary": "Class FileLineCharIndexSegment Namespace Hi.Common.FileLines Assembly HiGeom.dll Represents a character-level segment within file(s). Begin is inclusive, End is exclusive: [Begin, End). public class FileLineCharIndexSegment : IEquatable<FileLineCharIndexSegment> Inheritance object FileLineCharIndexSegment Implements IEquatable<FileLineCharIndexSegment> Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FileLineCharIndexSegment() Initializes a new instance of the FileLineCharIndexSegment class. public FileLineCharIndexSegment() FileLineCharIndexSegment(FileLineCharIndex, FileLineCharIndex) Initializes a new instance of the FileLineCharIndexSegment class with specified begin and end positions. public FileLineCharIndexSegment(FileLineCharIndex begin, FileLineCharIndex end) Parameters begin FileLineCharIndex The beginning position (inclusive). end FileLineCharIndex The ending position (exclusive). FileLineCharIndexSegment(FileLineCharIndexSegment) Initializes a new instance of the FileLineCharIndexSegment class by copying another instance. public FileLineCharIndexSegment(FileLineCharIndexSegment src) Parameters src FileLineCharIndexSegment The source to copy from. FileLineCharIndexSegment(IIndexedFileLine) Initializes a new instance that spans the entire indexedFileLine — from its first character to one past its last character. public FileLineCharIndexSegment(IIndexedFileLine indexedFileLine) Parameters indexedFileLine IIndexedFileLine The file line whose full extent the segment should cover. Properties Begin Beginning position (inclusive). public FileLineCharIndex Begin { get; set; } Property Value FileLineCharIndex End Ending position (exclusive). public FileLineCharIndex End { get; set; } Property Value FileLineCharIndex IsMultiLine Whether the segment spans multiple lines. public bool IsMultiLine { get; } Property Value bool Methods Any() Whether this segment contains any characters (End > Begin). public bool Any() Returns bool Equals(FileLineCharIndexSegment) Indicates whether the current object is equal to another object of the same type. public bool Equals(FileLineCharIndexSegment other) Parameters other FileLineCharIndexSegment An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Common.FileLines.FileLineIndex.html": {
    "href": "api/Hi.Common.FileLines.FileLineIndex.html",
    "title": "Class FileLineIndex | HiAPI-C# 2025",
    "summary": "Class FileLineIndex Namespace Hi.Common.FileLines Assembly HiGeom.dll Represents a location in a file by its file index and line number. public class FileLineIndex : IFileLineIndex, IGetFileLineIndex, IComparable<IFileLineIndex>, IComparable<FileLineIndex>, IMakeXmlSource, IToXElement, IToPresentDto Inheritance object FileLineIndex Implements IFileLineIndex IGetFileLineIndex IComparable<IFileLineIndex> IComparable<FileLineIndex> IMakeXmlSource IToXElement IToPresentDto Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MathUtil.Clamp<T>(T, T, T) FileLineUtil.CompareFileLine(IFileLineIndex, IFileLineIndex) FileLineUtil.GetFileNo(IFileLineIndex) FileLineUtil.GetLineNo(IFileLineIndex) XmlUtil.MakeXmlSourceToFile(IMakeXmlSource, string, bool) XmlUtil.MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) XmlUtil.SaveToByteArrayAsync(IMakeXmlSource, string) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FileLineIndex() Initializes a new instance of the FileLineIndex class. public FileLineIndex() FileLineIndex(IFileLineIndex) Initializes a new instance of the FileLineIndex class by copying another instance. public FileLineIndex(IFileLineIndex src) Parameters src IFileLineIndex The source FileLineIndex to copy from FileLineIndex(int, int) Initializes a new instance of the FileLineIndex class with specified indices. public FileLineIndex(int fileIndex, int lineIndex) Parameters fileIndex int The zero-based file index lineIndex int The zero-based line index FileLineIndex(XElement) Initializes a new instance of the FileLineIndex class from an XML element. public FileLineIndex(XElement src) Parameters src XElement The XML element containing the file and line indices Properties FileIndex File Index. Start on 0. public int FileIndex { get; set; } Property Value int FileNo Gets or sets the one-based file number (FileIndex + 1) public int FileNo { get; set; } Property Value int LineIndex Line Index. Start on 0. public int LineIndex { get; set; } Property Value int LineNo Gets or sets the one-based line number (LineIndex + 1) public int LineNo { get; set; } Property Value int XName Gets the XML element name used for serialization. public static string XName { get; } Property Value string Methods CompareTo(FileLineIndex) Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other object. public int CompareTo(FileLineIndex other) Parameters other FileLineIndex An object to compare with this instance. Returns int A value that indicates the relative order of the objects being compared. The return value has these meanings: Value Meaning Less than zero This instance precedes other in the sort order. Zero This instance occurs in the same position in the sort order as other. Greater than zero This instance follows other in the sort order. CompareTo(IFileLineIndex) Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other object. public int CompareTo(IFileLineIndex other) Parameters other IFileLineIndex An object to compare with this instance. Returns int A value that indicates the relative order of the objects being compared. The return value has these meanings: Value Meaning Less than zero This instance precedes other in the sort order. Zero This instance occurs in the same position in the sort order as other. Greater than zero This instance follows other in the sort order. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. GetFileLineIndex() Get FileLineIndex. public FileLineIndex GetFileLineIndex() Returns FileLineIndex FileLineIndex GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. ToPresentDto() Convert FileLineIndex to presentation DTO (Data Transfer Object) for JSON serialization. The returned object includes type metadata for web API presentation. public object ToPresentDto() Returns object DTO dictionary with Type, FileIndex, LineIndex keys ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. ToUserString() Returns a user-friendly string representation of the file and line numbers. public string ToUserString() Returns string A string in the format “(FileNo:X,LineNo:Y)” ToXElement() Converts the current instance to an XElement. public XElement ToXElement() Returns XElement An XElement representing this index. Operators operator ==(FileLineIndex, FileLineIndex) Determines whether two FileLineIndex instances are equal. public static bool operator ==(FileLineIndex left, FileLineIndex right) Parameters left FileLineIndex right FileLineIndex Returns bool operator >(FileLineIndex, FileLineIndex) Determines whether left is greater than right. public static bool operator >(FileLineIndex left, FileLineIndex right) Parameters left FileLineIndex right FileLineIndex Returns bool operator >=(FileLineIndex, FileLineIndex) Determines whether left is greater than or equal to right. public static bool operator >=(FileLineIndex left, FileLineIndex right) Parameters left FileLineIndex right FileLineIndex Returns bool operator !=(FileLineIndex, FileLineIndex) Determines whether two FileLineIndex instances are not equal. public static bool operator !=(FileLineIndex left, FileLineIndex right) Parameters left FileLineIndex right FileLineIndex Returns bool operator <(FileLineIndex, FileLineIndex) Determines whether left is less than right. public static bool operator <(FileLineIndex left, FileLineIndex right) Parameters left FileLineIndex right FileLineIndex Returns bool operator <=(FileLineIndex, FileLineIndex) Determines whether left is less than or equal to right. public static bool operator <=(FileLineIndex left, FileLineIndex right) Parameters left FileLineIndex right FileLineIndex Returns bool"
  },
  "api/Hi.Common.FileLines.FileLineUtil.html": {
    "href": "api/Hi.Common.FileLines.FileLineUtil.html",
    "title": "Class FileLineUtil | HiAPI-C# 2025",
    "summary": "Class FileLineUtil Namespace Hi.Common.FileLines Assembly HiGeom.dll Utility of IFileLineIndex. public static class FileLineUtil Inheritance object FileLineUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods CompareFileLine(IFileLineIndex, IFileLineIndex) Orders two file-line positions by FileIndex then LineIndex. Both operands must be non-null; callers decide how a missing (null) position sorts. public static int CompareFileLine(this IFileLineIndex a, IFileLineIndex b) Parameters a IFileLineIndex b IFileLineIndex Returns int GetFileNo(IFileLineIndex) Gets the file number (1-based) from the file line index. public static int GetFileNo(this IFileLineIndex src) Parameters src IFileLineIndex The file line index. Returns int The file number (1-based). GetLineNo(IFileLineIndex) Gets the line number (1-based) from the file line index. public static int GetLineNo(this IFileLineIndex src) Parameters src IFileLineIndex The file line index. Returns int The line number (1-based)."
  },
  "api/Hi.Common.FileLines.FileUtil.html": {
    "href": "api/Hi.Common.FileLines.FileUtil.html",
    "title": "Class FileUtil | HiAPI-C# 2025",
    "summary": "Class FileUtil Namespace Hi.Common.FileLines Assembly HiGeom.dll Utility to manage files. public static class FileUtil Inheritance object FileUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods CopyDirectory(string, string) Copies a directory and all its contents to a destination folder. public static void CopyDirectory(string sourceFolder, string destFolder) Parameters sourceFolder string Source directory path destFolder string Destination directory path CreateWithDirectoryAndGetFileStream(string) Creates or loads a file with directory. public static FileStream CreateWithDirectoryAndGetFileStream(string filePath) Parameters filePath string file path Returns FileStream file stream CreateWithDirectoryIfNotExisted(string) public static bool CreateWithDirectoryIfNotExisted(string filePath) Parameters filePath string Returns bool true if file created. DetectRoundTripEncoding(string) Detects a text encoding for filePath that survives a read-modify-write round trip byte for byte on untouched lines. public static Encoding DetectRoundTripEncoding(string filePath) Parameters filePath string The path of the file to sniff. Returns Encoding The encoding of the UTF-8 / UTF-16 byte-order mark when one is present; otherwise strict-validated UTF-8 (without a mark); otherwise Latin-1. Remarks The Latin-1 fallback maps every byte to the char of the same value, so a file in any ANSI-family encoding (GBK, Big5, Shift-JIS, ...) re-encodes to its original bytes. ASCII-keyed parsing is unaffected: those encodings never reuse bytes below 0x40 as trail bytes, so delimiters such as ‘;’ and ‘(’ cannot occur inside a multi-byte character. The BCL's default UTF-8 reader instead replaces every undecodable byte with U+FFFD, which irreversibly destroys such content on write-back. EnsureDirectory(string) Ensures that the specified directory exists, creating it if necessary. public static void EnsureDirectory(string directory) Parameters directory string The directory path to ensure exists. GetAbsentPath(string, string) Gets a path that doesn't exist by appending a number to the base path. public static string GetAbsentPath(string pathWithoutExtension, string extension) Parameters pathWithoutExtension string The base path without extension. extension string The file extension. Returns string A path that doesn't exist. GetAbsentRelPath(string, string, string) Gets a relative path that doesn't exist by appending a number to the base path. public static string GetAbsentRelPath(string baseDirectory, string relPathWithoutExtension, string extension) Parameters baseDirectory string The base directory. relPathWithoutExtension string The relative path without extension. extension string The file extension. Returns string A relative path that doesn't exist. GetDescendentPath(string) Get descendent path if the path is descendent of current path; otherwise return path. public static string GetDescendentPath(string path) Parameters path string path Returns string descendent path if the path is descendent of current path; otherwise return path GetFileSizeString(FileInfo, string) Gets a formatted string representing the file size. public static string GetFileSizeString(this FileInfo fileInfo, string format = \"{0,6:###.00} {1,-2:##}\") Parameters fileInfo FileInfo The file information. format string The format string to use. Returns string A formatted string representing the file size. IsBinaryFile(string) Determines if a file is likely to be a binary file by checking for control characters. public static bool IsBinaryFile(string filePath) Parameters filePath string Path to the file to check Returns bool True if the file appears to be binary, false otherwise ReadAllTextWithFileShareAsync(string) Reads all text from a file with file sharing enabled. public static Task<string> ReadAllTextWithFileShareAsync(string filePath) Parameters filePath string The path of the file to read. Returns Task<string> A task that represents the asynchronous read operation, which wraps the file contents. ToIndexedFile(IEnumerable<string>) Converts a collection of file paths to a collection of indexed files. public static IEnumerable<IndexedFile> ToIndexedFile(this IEnumerable<string> files) Parameters files IEnumerable<string> The collection of file paths. Returns IEnumerable<IndexedFile> A collection of indexed files."
  },
  "api/Hi.Common.FileLines.IFileChangedEventSupport.html": {
    "href": "api/Hi.Common.FileLines.IFileChangedEventSupport.html",
    "title": "Interface IFileChangedEventSupport | HiAPI-C# 2025",
    "summary": "Interface IFileChangedEventSupport Namespace Hi.Common.FileLines Assembly HiGeom.dll Interface for supporting file change events. public interface IFileChangedEventSupport Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Events FileBeginEventHandler Event that is raised when file processing begins. event EventHandler<IndexedFile> FileBeginEventHandler Event Type EventHandler<IndexedFile> FileEndEventHandler Event that is raised when file processing ends. event EventHandler<IndexedFile> FileEndEventHandler Event Type EventHandler<IndexedFile>"
  },
  "api/Hi.Common.FileLines.IFileLine.html": {
    "href": "api/Hi.Common.FileLines.IFileLine.html",
    "title": "Interface IFileLine | HiAPI-C# 2025",
    "summary": "Interface IFileLine Namespace Hi.Common.FileLines Assembly HiGeom.dll Interface of file line. public interface IFileLine Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties FilePath File path. string FilePath { get; } Property Value string Line The line. string Line { get; } Property Value string"
  },
  "api/Hi.Common.FileLines.IFileLineCharIndex.html": {
    "href": "api/Hi.Common.FileLines.IFileLineCharIndex.html",
    "title": "Interface IFileLineCharIndex | HiAPI-C# 2025",
    "summary": "Interface IFileLineCharIndex Namespace Hi.Common.FileLines Assembly HiGeom.dll Interface for a character-level position within a file: file, line, and character index. All indices are 0-based. public interface IFileLineCharIndex : IFileLineIndex, IGetFileLineIndex Inherited Members IFileLineIndex.FileIndex IFileLineIndex.LineIndex IGetFileLineIndex.GetFileLineIndex() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) FileLineUtil.CompareFileLine(IFileLineIndex, IFileLineIndex) FileLineUtil.GetFileNo(IFileLineIndex) FileLineUtil.GetLineNo(IFileLineIndex) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties CharIndex Character index within the line. 0-based. int CharIndex { get; } Property Value int"
  },
  "api/Hi.Common.FileLines.IFileLineIndex.html": {
    "href": "api/Hi.Common.FileLines.IFileLineIndex.html",
    "title": "Interface IFileLineIndex | HiAPI-C# 2025",
    "summary": "Interface IFileLineIndex Namespace Hi.Common.FileLines Assembly HiGeom.dll Interface of file number and line number. public interface IFileLineIndex : IGetFileLineIndex Inherited Members IGetFileLineIndex.GetFileLineIndex() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) FileLineUtil.CompareFileLine(IFileLineIndex, IFileLineIndex) FileLineUtil.GetFileNo(IFileLineIndex) FileLineUtil.GetLineNo(IFileLineIndex) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties FileIndex File Index. Start on 0. int FileIndex { get; } Property Value int LineIndex Line Index. Start on 0. int LineIndex { get; } Property Value int"
  },
  "api/Hi.Common.FileLines.IGetFileLineIndex.html": {
    "href": "api/Hi.Common.FileLines.IGetFileLineIndex.html",
    "title": "Interface IGetFileLineIndex | HiAPI-C# 2025",
    "summary": "Interface IGetFileLineIndex Namespace Hi.Common.FileLines Assembly HiGeom.dll Interface of GetFileLineIndex(). public interface IGetFileLineIndex Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetFileLineIndex() Get FileLineIndex. FileLineIndex GetFileLineIndex() Returns FileLineIndex FileLineIndex"
  },
  "api/Hi.Common.FileLines.IGetIndexedFileLine.html": {
    "href": "api/Hi.Common.FileLines.IGetIndexedFileLine.html",
    "title": "Interface IGetIndexedFileLine | HiAPI-C# 2025",
    "summary": "Interface IGetIndexedFileLine Namespace Hi.Common.FileLines Assembly HiGeom.dll Interface for objects that can provide a file line. public interface IGetIndexedFileLine Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetIndexedFileLine() Gets the file line associated with this object. IndexedFileLine GetIndexedFileLine() Returns IndexedFileLine The file line object."
  },
  "api/Hi.Common.FileLines.IIndexedFileLine.html": {
    "href": "api/Hi.Common.FileLines.IIndexedFileLine.html",
    "title": "Interface IIndexedFileLine | HiAPI-C# 2025",
    "summary": "Interface IIndexedFileLine Namespace Hi.Common.FileLines Assembly HiGeom.dll Interface for a file line with associated file and line index information. public interface IIndexedFileLine : IFileLine, IFileLineIndex, IGetIndexedFileLine, IGetFileLineIndex Inherited Members IFileLine.FilePath IFileLine.Line IFileLineIndex.FileIndex IFileLineIndex.LineIndex IGetIndexedFileLine.GetIndexedFileLine() IGetFileLineIndex.GetFileLineIndex() Extension Methods FileLineUtil.CompareFileLine(IFileLineIndex, IFileLineIndex) FileLineUtil.GetFileNo(IFileLineIndex) FileLineUtil.GetLineNo(IFileLineIndex) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Common.FileLines.ILineChangedEventSupport.html": {
    "href": "api/Hi.Common.FileLines.ILineChangedEventSupport.html",
    "title": "Interface ILineChangedEventSupport | HiAPI-C# 2025",
    "summary": "Interface ILineChangedEventSupport Namespace Hi.Common.FileLines Assembly HiGeom.dll Interface for objects that support line change events. public interface ILineChangedEventSupport Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Events LineBeginEventHandler Event that is raised when a line begins processing. event EventHandler<IndexedFileLine> LineBeginEventHandler Event Type EventHandler<IndexedFileLine> LineEndEventHandler Event that is raised when a line ends processing. event EventHandler<IndexedFileLine> LineEndEventHandler Event Type EventHandler<IndexedFileLine>"
  },
  "api/Hi.Common.FileLines.IndexedFile.html": {
    "href": "api/Hi.Common.FileLines.IndexedFile.html",
    "title": "Class IndexedFile | HiAPI-C# 2025",
    "summary": "Class IndexedFile Namespace Hi.Common.FileLines Assembly HiGeom.dll Represents a file with an associated index. public class IndexedFile : IEquatable<IndexedFile> Inheritance object IndexedFile Implements IEquatable<IndexedFile> Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors IndexedFile() Initializes a new instance of the IndexedFile class. public IndexedFile() IndexedFile(IndexedFile) Copy ctor. public IndexedFile(IndexedFile src) Parameters src IndexedFile src IndexedFile(string, int) Initializes a new instance of the IndexedFile class with the specified file path and index. public IndexedFile(string filePath, int fileIndex) Parameters filePath string The path of the file. fileIndex int The index of the file. Properties FileIndex File Index. Start on 0. public int FileIndex { get; set; } Property Value int FilePath File path. public string FilePath { get; set; } Property Value string Methods Equals(IndexedFile) Indicates whether the current object is equal to another object of the same type. public bool Equals(IndexedFile other) Parameters other IndexedFile An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Common.FileLines.IndexedFileLine.html": {
    "href": "api/Hi.Common.FileLines.IndexedFileLine.html",
    "title": "Class IndexedFileLine | HiAPI-C# 2025",
    "summary": "Class IndexedFileLine Namespace Hi.Common.FileLines Assembly HiGeom.dll Represents a line of text from a file with associated file and line information. public class IndexedFileLine : IIndexedFileLine, IFileLine, IFileLineIndex, IGetIndexedFileLine, IGetFileLineIndex Inheritance object IndexedFileLine Implements IIndexedFileLine IFileLine IFileLineIndex IGetIndexedFileLine IGetFileLineIndex Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods FileLineUtil.CompareFileLine(IFileLineIndex, IFileLineIndex) FileLineUtil.GetFileNo(IFileLineIndex) FileLineUtil.GetLineNo(IFileLineIndex) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors IndexedFileLine() Initializes a new instance of the IndexedFileLine class. public IndexedFileLine() IndexedFileLine(IIndexedFileLine) Initializes a new instance of the IndexedFileLine class by copying from an IIndexedFileLine. public IndexedFileLine(IIndexedFileLine src) Parameters src IIndexedFileLine The source IIndexedFileLine to copy from. IndexedFileLine(IndexedFileLine) Initializes a new instance of the IndexedFileLine class by copying another instance. public IndexedFileLine(IndexedFileLine src) Parameters src IndexedFileLine The source IndexedFileLine to copy from. IndexedFileLine(int, string, int, string) Initializes a new instance of the IndexedFileLine class with the specified file information and line content. public IndexedFileLine(int fileIndex, string filePath, int lineIndex, string line) Parameters fileIndex int The zero-based index of the file. filePath string The path of the file. lineIndex int The zero-based index of the line within the file. line string The content of the line. Properties FileIndex File Index. Start on 0. public int FileIndex { get; set; } Property Value int FileNo FileIndex+1. public int FileNo { get; set; } Property Value int FilePath File path. public string FilePath { get; set; } Property Value string Line The line. public string Line { get; set; } Property Value string LineIndex Line Index. Start on 0. public int LineIndex { get; set; } Property Value int LineNo LineIndex+1. public int LineNo { get; set; } Property Value int Methods Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. Remarks Checks the equalty of FileIndex and LineIndex. GetFileLine() public IFileLine GetFileLine() Returns IFileLine GetFileLineIndex() Get FileLineIndex. public FileLineIndex GetFileLineIndex() Returns FileLineIndex FileLineIndex GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. Remarks The hashcode is composed of FileIndex and LineIndex. GetIndexedFileLine() Gets the file line associated with this object. public IndexedFileLine GetIndexedFileLine() Returns IndexedFileLine The file line object. ReadFile(int, string) Read file to IndexedFileLines. public static IEnumerable<IndexedFileLine> ReadFile(int fileIndex, string filePath) Parameters fileIndex int file number. If only one file in the scenerio, assign zero is prefered. filePath string file path Returns IEnumerable<IndexedFileLine> IndexedFileLines ReadFiles(List<string>) Read files to IndexedFileLines. public static IEnumerable<IndexedFileLine> ReadFiles(List<string> files) Parameters files List<string> files Returns IEnumerable<IndexedFileLine> IndexedFileLines ToHumanString() Returns a human-readable string representation of this file line. public string ToHumanString() Returns string A formatted string with file number, path, line number, and line content. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Common.FileLines.IndexedFileLineChar.html": {
    "href": "api/Hi.Common.FileLines.IndexedFileLineChar.html",
    "title": "Class IndexedFileLineChar | HiAPI-C# 2025",
    "summary": "Class IndexedFileLineChar Namespace Hi.Common.FileLines Assembly HiGeom.dll Represents a character-level position within a file, with associated file path context. Analogous to IndexedFileLine but at character granularity. public class IndexedFileLineChar : IFileLineCharIndex, IFileLineIndex, IGetFileLineIndex, IEquatable<IndexedFileLineChar> Inheritance object IndexedFileLineChar Implements IFileLineCharIndex IFileLineIndex IGetFileLineIndex IEquatable<IndexedFileLineChar> Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods FileLineUtil.CompareFileLine(IFileLineIndex, IFileLineIndex) FileLineUtil.GetFileNo(IFileLineIndex) FileLineUtil.GetLineNo(IFileLineIndex) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors IndexedFileLineChar() Initializes a new instance of the IndexedFileLineChar class. public IndexedFileLineChar() IndexedFileLineChar(IndexedFileLine, int) Creates an IndexedFileLineChar from an IndexedFileLine at the specified character index. public IndexedFileLineChar(IndexedFileLine src, int charIndex) Parameters src IndexedFileLine The source indexed file line. charIndex int The zero-based character index within the line. IndexedFileLineChar(IndexedFileLineChar) Initializes a new instance of the IndexedFileLineChar class by copying another instance. public IndexedFileLineChar(IndexedFileLineChar src) Parameters src IndexedFileLineChar The source to copy from. IndexedFileLineChar(int, string, int, int) Initializes a new instance of the IndexedFileLineChar class with specified values. public IndexedFileLineChar(int fileIndex, string filePath, int lineIndex, int charIndex) Parameters fileIndex int The zero-based file index. filePath string The file path. lineIndex int The zero-based line index. charIndex int The zero-based character index within the line. Properties CharIndex Character index within the line. 0-based. public int CharIndex { get; set; } Property Value int FileIndex File Index. Start on 0. public int FileIndex { get; set; } Property Value int FilePath File path. public string FilePath { get; set; } Property Value string LineIndex Line Index. Start on 0. public int LineIndex { get; set; } Property Value int Methods Equals(IndexedFileLineChar) Indicates whether the current object is equal to another object of the same type. public bool Equals(IndexedFileLineChar other) Parameters other IndexedFileLineChar An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. GetFileLineIndex() Get FileLineIndex. public FileLineIndex GetFileLineIndex() Returns FileLineIndex FileLineIndex GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. ToFileLineCharIndex() Converts to a FileLineCharIndex (without file path context). public FileLineCharIndex ToFileLineCharIndex() Returns FileLineCharIndex ToHumanString() Returns a human-readable string representation. public string ToHumanString() Returns string ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Common.FileLines.LineBeginEventArgs.html": {
    "href": "api/Hi.Common.FileLines.LineBeginEventArgs.html",
    "title": "Class LineBeginEventArgs | HiAPI-C# 2025",
    "summary": "Class LineBeginEventArgs Namespace Hi.Common.FileLines Assembly HiGeom.dll Event arguments for when line processing begins. public class LineBeginEventArgs : EventArgs Inheritance object EventArgs LineBeginEventArgs Inherited Members EventArgs.Empty object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors LineBeginEventArgs() Initializes a new instance of the LineBeginEventArgs class. public LineBeginEventArgs() LineBeginEventArgs(IndexedFileLine) Initializes a new instance of the LineBeginEventArgs class with a specified file line. public LineBeginEventArgs(IndexedFileLine fileLine) Parameters fileLine IndexedFileLine The file line being processed. Properties FileLine Gets or sets the file line being processed. public IndexedFileLine FileLine { get; set; } Property Value IndexedFileLine"
  },
  "api/Hi.Common.FileLines.LineEndEventArgs.html": {
    "href": "api/Hi.Common.FileLines.LineEndEventArgs.html",
    "title": "Class LineEndEventArgs | HiAPI-C# 2025",
    "summary": "Class LineEndEventArgs Namespace Hi.Common.FileLines Assembly HiGeom.dll Event arguments for when line processing ends. public class LineEndEventArgs : EventArgs Inheritance object EventArgs LineEndEventArgs Inherited Members EventArgs.Empty object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors LineEndEventArgs() Initializes a new instance of the LineEndEventArgs class. public LineEndEventArgs() LineEndEventArgs(IndexedFileLine) Initializes a new instance of the LineEndEventArgs class with a specified file line. public LineEndEventArgs(IndexedFileLine fileLine) Parameters fileLine IndexedFileLine The file line that was processed. Properties FileLine Gets or sets the file line that was processed. public IndexedFileLine FileLine { get; set; } Property Value IndexedFileLine"
  },
  "api/Hi.Common.FileLines.html": {
    "href": "api/Hi.Common.FileLines.html",
    "title": "Namespace Hi.Common.FileLines | HiAPI-C# 2025",
    "summary": "Namespace Hi.Common.FileLines Classes FileBeginEventArgs Event arguments for when a file processing begins. FileEndEventArgs Event arguments for when a file processing ends. FileLineCharIndex Represents a character-level position within a file by file index, line index, and character index. All indices are 0-based. FileLineCharIndexSegment Represents a character-level segment within file(s). Begin is inclusive, End is exclusive: [Begin, End). FileLineIndex Represents a location in a file by its file index and line number. FileLineUtil Utility of IFileLineIndex. FileUtil Utility to manage files. IndexedFile Represents a file with an associated index. IndexedFileLine Represents a line of text from a file with associated file and line information. IndexedFileLineChar Represents a character-level position within a file, with associated file path context. Analogous to IndexedFileLine but at character granularity. LineBeginEventArgs Event arguments for when line processing begins. LineEndEventArgs Event arguments for when line processing ends. Interfaces IFileChangedEventSupport Interface for supporting file change events. IFileLine Interface of file line. IFileLineCharIndex Interface for a character-level position within a file: file, line, and character index. All indices are 0-based. IFileLineIndex Interface of file number and line number. IGetFileLineIndex Interface of GetFileLineIndex(). IGetIndexedFileLine Interface for objects that can provide a file line. IIndexedFileLine Interface for a file line with associated file and line index information. ILineChangedEventSupport Interface for objects that support line change events."
  },
  "api/Hi.Common.IAbstractNote.html": {
    "href": "api/Hi.Common.IAbstractNote.html",
    "title": "Interface IAbstractNote | HiAPI-C# 2025",
    "summary": "Interface IAbstractNote Namespace Hi.Common Assembly HiGeom.dll Interface for objects that provide an abstract description or note. public interface IAbstractNote Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties AbstractNote Gets a descriptive note or abstract about the object. string AbstractNote { get; } Property Value string"
  },
  "api/Hi.Common.IBinaryIo.html": {
    "href": "api/Hi.Common.IBinaryIo.html",
    "title": "Interface IBinaryIo | HiAPI-C# 2025",
    "summary": "Interface IBinaryIo Namespace Hi.Common Assembly HiGeom.dll Interface for binary input/output operations. Extends IWriteBin to provide both read and write capabilities. public interface IBinaryIo : IWriteBin Inherited Members IWriteBin.WriteBin(BinaryWriter) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) BinIoUtil.ToBytes(IWriteBin) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods ReadBin(BinaryReader) Reads binary data to initialize the object. void ReadBin(BinaryReader reader) Parameters reader BinaryReader The binary reader to read from"
  },
  "api/Hi.Common.IClearCache.html": {
    "href": "api/Hi.Common.IClearCache.html",
    "title": "Interface IClearCache | HiAPI-C# 2025",
    "summary": "Interface IClearCache Namespace Hi.Common Assembly HiGeom.dll Interface for objects that can clear their internal cache. public interface IClearCache Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods ClearCache() Clears any cached data held by the implementing object. void ClearCache()"
  },
  "api/Hi.Common.ICommandTextSource.html": {
    "href": "api/Hi.Common.ICommandTextSource.html",
    "title": "Interface ICommandTextSource | HiAPI-C# 2025",
    "summary": "Interface ICommandTextSource Namespace Hi.Common Assembly HiGeom.dll A culture-bearing vocabulary commands compose their titles and labels from: it maps a vocabulary key — the English default text — onto that culture's text. The CALLER picks the source, so the presentation layer owns the language (no thread culture involved); the command keeps its composition and degradation rules. Presentation layers can implement their own source or take the engine-default one from GenTextSource(CultureInfo, params Type[]) ([CultureText] declarations overlaid by SetTextOverride(string, string, string) registrations). public interface ICommandTextSource Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties this[string] The text of key in this source's culture; the key itself when the source carries no entry — the key doubles as the English default. string this[string key] { get; } Parameters key string Vocabulary key — the English default text. Property Value string The culture's text, or the key itself."
  },
  "api/Hi.Common.IDuplicate.html": {
    "href": "api/Hi.Common.IDuplicate.html",
    "title": "Interface IDuplicate | HiAPI-C# 2025",
    "summary": "Interface IDuplicate Namespace Hi.Common Assembly HiGeom.dll Interface for objects that support deep cloning/duplication. public interface IDuplicate Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks Unlike ICloneable, which is typically used for shallow copying of simple objects, IDuplicate is designed for deep copying of complex objects with nested references. Implementations should ensure that all nested objects are properly duplicated. Methods Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object"
  },
  "api/Hi.Common.IGetQuantityByKey.html": {
    "href": "api/Hi.Common.IGetQuantityByKey.html",
    "title": "Interface IGetQuantityByKey | HiAPI-C# 2025",
    "summary": "Interface IGetQuantityByKey Namespace Hi.Common Assembly HiGeom.dll Interface for retrieving a quantity value using a string key. public interface IGetQuantityByKey Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetQuantityByKey(string) Gets a quantity value associated with the specified key. double GetQuantityByKey(string key) Parameters key string The key to look up Returns double The quantity value associated with the key"
  },
  "api/Hi.Common.IGetSelectionName.html": {
    "href": "api/Hi.Common.IGetSelectionName.html",
    "title": "Interface IGetSelectionName | HiAPI-C# 2025",
    "summary": "Interface IGetSelectionName Namespace Hi.Common Assembly HiGeom.dll Interface for objects that can provide a name for selection purposes. public interface IGetSelectionName Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetSelectionName() Gets a name that can be used for selection in UI or other contexts. string GetSelectionName() Returns string The selection name for this object"
  },
  "api/Hi.Common.INameNote.html": {
    "href": "api/Hi.Common.INameNote.html",
    "title": "Interface INameNote | HiAPI-C# 2025",
    "summary": "Interface INameNote Namespace Hi.Common Assembly HiGeom.dll Interface for objects that have a name and note property. public interface INameNote Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) XmlUtil.GetNameNoteXElementList(INameNote) XmlUtil.SetNameNote(INameNote, XElement) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Name Gets or sets the name of the object. string Name { get; set; } Property Value string Note Gets or sets the descriptive note for the object. string Note { get; set; } Property Value string"
  },
  "api/Hi.Common.IPreferredFileName.html": {
    "href": "api/Hi.Common.IPreferredFileName.html",
    "title": "Interface IPreferredFileName | HiAPI-C# 2025",
    "summary": "Interface IPreferredFileName Namespace Hi.Common Assembly HiGeom.dll Interface for objects that can specify a preferred file name. Generally used to suggest a name when generating or saving files. public interface IPreferredFileName Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties PreferredFileName Gets or sets the preferred file name for this object when generating or saving files. string PreferredFileName { get; set; } Property Value string"
  },
  "api/Hi.Common.IProgressFraction.html": {
    "href": "api/Hi.Common.IProgressFraction.html",
    "title": "Interface IProgressFraction | HiAPI-C# 2025",
    "summary": "Interface IProgressFraction Namespace Hi.Common Assembly HiDisp.dll Interface for progress reporting functionality. public interface IProgressFraction Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetDenominator() Gets the denominator value for progress calculation. int GetDenominator() Returns int The denominator value. GetDetail() Gets the detailed information about the progress. string GetDetail() Returns string The detail string. GetMsg() Get message. string GetMsg() Returns string The message string. GetNumerator() Gets the numerator value for progress calculation. int GetNumerator() Returns int The numerator value."
  },
  "api/Hi.Common.ISourceFile.html": {
    "href": "api/Hi.Common.ISourceFile.html",
    "title": "Interface ISourceFile | HiAPI-C# 2025",
    "summary": "Interface ISourceFile Namespace Hi.Common Assembly HiGeom.dll Interface for objects that have a source file. public interface ISourceFile Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties SourceFile Gets or sets the source file path. string SourceFile { get; set; } Property Value string"
  },
  "api/Hi.Common.IToPresentDto.html": {
    "href": "api/Hi.Common.IToPresentDto.html",
    "title": "Interface IToPresentDto | HiAPI-C# 2025",
    "summary": "Interface IToPresentDto Namespace Hi.Common Assembly HiGeom.dll Interface for converting objects to presentation DTOs (Data Transfer Objects) for JSON serialization. public interface IToPresentDto Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks Implementations must not return anonymous types: release assemblies are obfuscated with only the public API kept, so an anonymous type gets renamed and loses its constructor parameter names, which makes System.Text.Json throw NotSupportedException when serializing it. Return a Dictionary<string, object> instead — its keys are emitted verbatim as the JSON property names. Key by nameof of the mirrored member where one exists (nameof compiles to a string literal, so obfuscation cannot touch it); use a literal for marker keys such as “Type”. Methods ToPresentDto() Convert to presentation DTO (Data Transfer Object) for JSON serialization. The returned object includes type metadata for web API presentation. object ToPresentDto() Returns object DTO object with type and object properties"
  },
  "api/Hi.Common.IUpdateByContent.html": {
    "href": "api/Hi.Common.IUpdateByContent.html",
    "title": "Interface IUpdateByContent | HiAPI-C# 2025",
    "summary": "Interface IUpdateByContent Namespace Hi.Common Assembly HiGeom.dll Interface for objects that can update themselves based on their content. public interface IUpdateByContent : IClearCache Inherited Members IClearCache.ClearCache() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks This interface is considered obsolete. Use IClearCache instead. Methods UpdateByContent() Updates the object based on its current content. void UpdateByContent()"
  },
  "api/Hi.Common.IUriGetter.html": {
    "href": "api/Hi.Common.IUriGetter.html",
    "title": "Interface IUriGetter | HiAPI-C# 2025",
    "summary": "Interface IUriGetter Namespace Hi.Common Assembly HiGeom.dll Interface for retrieving a URI string. public interface IUriGetter Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Uri Gets the URI string. string Uri { get; } Property Value string"
  },
  "api/Hi.Common.IWriteBin.html": {
    "href": "api/Hi.Common.IWriteBin.html",
    "title": "Interface IWriteBin | HiAPI-C# 2025",
    "summary": "Interface IWriteBin Namespace Hi.Common Assembly HiGeom.dll Interface for writing binary data. public interface IWriteBin Extension Methods BinIoUtil.ToBytes(IWriteBin) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods WriteBin(BinaryWriter) Writes the object's data to a binary stream. void WriteBin(BinaryWriter writer) Parameters writer BinaryWriter The binary writer to write to"
  },
  "api/Hi.Common.IndexSegment.html": {
    "href": "api/Hi.Common.IndexSegment.html",
    "title": "Class IndexSegment | HiAPI-C# 2025",
    "summary": "Class IndexSegment Namespace Hi.Common Assembly HiGeom.dll Represents a segment of indices with a beginning (inclusive) and ending (exclusive> point. Used for defining segment of data in collections or arrays. public class IndexSegment : IEquatable<IndexSegment>, IMakeXmlSource Inheritance object IndexSegment Implements IEquatable<IndexSegment> IMakeXmlSource Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) XmlUtil.MakeXmlSourceToFile(IMakeXmlSource, string, bool) XmlUtil.MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) XmlUtil.SaveToByteArrayAsync(IMakeXmlSource, string) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors IndexSegment() Initializes a new instance of the IndexSegment class. public IndexSegment() IndexSegment(IndexSegment) Initializes a new instance of the IndexSegment class by copying another instance. public IndexSegment(IndexSegment src) Parameters src IndexSegment The source index segment to copy from. IndexSegment(int, int) Initializes a new instance of the IndexSegment class with the specified begin and end indices. public IndexSegment(int begin, int end) Parameters begin int The beginning index (inclusive). end int The ending index (exclusive). IndexSegment(XElement) Initializes a new instance of the IndexSegment class from an XML element. public IndexSegment(XElement src) Parameters src XElement The XML element containing the index segment data. Fields XName The XML element name used for serialization. public static string XName Field Value string begin Begin index. Inclusive. public int begin Field Value int end End index. Exclusive. public int end Field Value int Properties Begin Gets or sets the beginning index of the segment (inclusive). public int Begin { get; set; } Property Value int End Gets or sets the ending index of the segment (exclusive). public int End { get; set; } Property Value int Length Gets the length of the segment (End - Begin). public int Length { get; } Property Value int Methods Any() Determines whether this index segment contains any indices. public bool Any() Returns bool true if the segment contains any indices; otherwise, false. Contains(int) Determines whether this index segment contains the specified index. public bool Contains(int index) Parameters index int The index to check. Returns bool true if the index is within the segment; otherwise, false. Enumerate() Enumerates all indices within this segment. public IEnumerable<int> Enumerate() Returns IEnumerable<int> An enumerable collection of all indices within the segment. Equals(IndexSegment) Determines whether the specified index segment is equal to the current index segment. public bool Equals(IndexSegment other) Parameters other IndexSegment The index segment to compare with the current index segment. Returns bool true if the specified index segment is equal to the current index segment; otherwise, false. Equals(object) Determines whether the specified object is equal to the current index segment. public override bool Equals(object obj) Parameters obj object The object to compare with the current index segment. Returns bool true if the specified object is equal to the current index segment; otherwise, false. Expand(int) Expands this index segment to include the specified value if needed. public void Expand(int v) Parameters v int The value to include in the segment. GetHashCode() Returns a hash code for this index segment. public override int GetHashCode() Returns int A hash code for the current index segment. GetIndexSegment<TData, TKey>(IList<TData>, int, TKey, Func<TData, TKey>, TKey) Finds the contiguous run of items whose key equals targetGroupKey, scanning outward from seekingStartListIndex. public static IndexSegment GetIndexSegment<TData, TKey>(IList<TData> steps, int seekingStartListIndex, TKey targetGroupKey, Func<TData, TKey> keyFunc, TKey seekStartFallbackKey = null) where TKey : class, IComparable<TKey> Parameters steps IList<TData> The list of data items. seekingStartListIndex int The start step index for seeking. targetGroupKey TKey The key of the segment to locate. keyFunc Func<TData, TKey> Extracts the ordering key from a data item; may return null for an item with no key. seekStartFallbackKey TKey Key used when the seeking-start item has none (a null cache lands in the equality branch). Returns IndexSegment An index segment representing the range of indices. Type Parameters TData The type of data items. TKey The ordering key type (e.g. a file-line position). MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToString() Returns a string representation of this index segment. public override string ToString() Returns string A string representation of the current index segment."
  },
  "api/Hi.Common.IntegerKeyDictionaryConverter-1.html": {
    "href": "api/Hi.Common.IntegerKeyDictionaryConverter-1.html",
    "title": "Class IntegerKeyDictionaryConverter<TValue> | HiAPI-C# 2025",
    "summary": "Class IntegerKeyDictionaryConverter<TValue> Namespace Hi.Common Assembly HiGeom.dll Generic version of IntegerKeyDictionaryConverter that works with a specific value type. public class IntegerKeyDictionaryConverter<TValue> : IMakeXmlSource Type Parameters TValue The type of values in the dictionary. Inheritance object IntegerKeyDictionaryConverter<TValue> Implements IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) XmlUtil.MakeXmlSourceToFile(IMakeXmlSource, string, bool) XmlUtil.MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) XmlUtil.SaveToByteArrayAsync(IMakeXmlSource, string) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors IntegerKeyDictionaryConverter() Ctor. public IntegerKeyDictionaryConverter() IntegerKeyDictionaryConverter(XElement) Ctor. public IntegerKeyDictionaryConverter(XElement src) Parameters src XElement XML Properties RawKeyList Dont modify. public List<string> RawKeyList { get; } Property Value List<string> RawKeyToIndex Dont modify. public Dictionary<string, int> RawKeyToIndex { get; } Property Value Dictionary<string, int> XName Name for XML IO. public static string XName { get; } Property Value string Methods GetIntegerKeyDictionary(Dictionary<string, TValue>) Converts a dictionary with string keys to a dictionary with integer keys. public Dictionary<int, TValue> GetIntegerKeyDictionary(Dictionary<string, TValue> rawKeyDictionary) Parameters rawKeyDictionary Dictionary<string, TValue> The dictionary with string keys to convert. Returns Dictionary<int, TValue> A dictionary with integer keys. GetRestoredDictionary(Dictionary<int, TValue>) Converts a dictionary with integer keys back to a dictionary with string keys. public Dictionary<string, TValue> GetRestoredDictionary(Dictionary<int, TValue> integerKeyDictionary) Parameters integerKeyDictionary Dictionary<int, TValue> The dictionary with integer keys to convert. Returns Dictionary<string, TValue> A dictionary with string keys. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Common.IntegerKeyDictionaryConverter.html": {
    "href": "api/Hi.Common.IntegerKeyDictionaryConverter.html",
    "title": "Class IntegerKeyDictionaryConverter | HiAPI-C# 2025",
    "summary": "Class IntegerKeyDictionaryConverter Namespace Hi.Common Assembly HiGeom.dll Converts dictionaries with string keys to dictionaries with integer keys for more efficient storage and lookup. public class IntegerKeyDictionaryConverter : IMakeXmlSource Inheritance object IntegerKeyDictionaryConverter Implements IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) XmlUtil.MakeXmlSourceToFile(IMakeXmlSource, string, bool) XmlUtil.MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) XmlUtil.SaveToByteArrayAsync(IMakeXmlSource, string) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors IntegerKeyDictionaryConverter() Initializes a new instance of the IntegerKeyDictionaryConverter class. public IntegerKeyDictionaryConverter() IntegerKeyDictionaryConverter(XElement) Initializes a new instance of the IntegerKeyDictionaryConverter class from XML. public IntegerKeyDictionaryConverter(XElement src) Parameters src XElement XML element containing the converter data. Properties RawKeyList Dont modify. public List<string> RawKeyList { get; } Property Value List<string> RawKeyToIndex Dont modify. public Dictionary<string, int> RawKeyToIndex { get; } Property Value Dictionary<string, int> XName Name for XML IO. public static string XName { get; } Property Value string Methods GetIntegerKeyDictionary(Dictionary<string, object>) Converts a dictionary with string keys to a dictionary with integer keys. public Dictionary<int, object> GetIntegerKeyDictionary(Dictionary<string, object> rawKeyDictionary) Parameters rawKeyDictionary Dictionary<string, object> The dictionary with string keys to convert. Returns Dictionary<int, object> A dictionary with integer keys. GetRestoredDictionary(Dictionary<int, object>) Converts a dictionary with integer keys back to a dictionary with string keys. public Dictionary<string, object> GetRestoredDictionary(Dictionary<int, object> integerKeyDictionary) Parameters integerKeyDictionary Dictionary<int, object> The dictionary with integer keys to convert. Returns Dictionary<string, object> A dictionary with string keys. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Common.InternalException.html": {
    "href": "api/Hi.Common.InternalException.html",
    "title": "Class InternalException | HiAPI-C# 2025",
    "summary": "Class InternalException Namespace Hi.Common Assembly HiGeom.dll Exception that represents an internal error that should never occur during normal operation. Used to indicate programming errors or unexpected states that require developer attention. public class InternalException : Exception, ISerializable Inheritance object Exception InternalException Implements ISerializable Inherited Members Exception.GetBaseException() Exception.GetType() Exception.ToString() Exception.Data Exception.HelpLink Exception.HResult Exception.InnerException Exception.Message Exception.Source Exception.StackTrace Exception.TargetSite Exception.SerializeObjectState object.Equals(object) object.Equals(object, object) object.GetHashCode() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors InternalException() Initializes a new instance of the InternalException class with a default message. public InternalException() InternalException(string) Initializes a new instance of the InternalException class with a specified error message. public InternalException(string message) Parameters message string The message that describes the error"
  },
  "api/Hi.Common.InvokeUtil.html": {
    "href": "api/Hi.Common.InvokeUtil.html",
    "title": "Class InvokeUtil | HiAPI-C# 2025",
    "summary": "Class InvokeUtil Namespace Hi.Common Assembly HiGeom.dll Utility class for method invocation operations. public static class InvokeUtil Inheritance object InvokeUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods SelfInvoke<TSrc>(TSrc, Action<TSrc>) Invokes the specified action on the source object itself. public static void SelfInvoke<TSrc>(this TSrc src, Action<TSrc> func) Parameters src TSrc The source object func Action<TSrc> The action to invoke on the source object Type Parameters TSrc The type of the source object SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) Invokes the specified function on the source object itself and returns the result. This function is usually used to apply a temporary variable, so that the property call is not computed twice. public static TDst SelfInvoke<TSrc, TDst>(this TSrc src, Func<TSrc, TDst> func) Parameters src TSrc The source object func Func<TSrc, TDst> The function to invoke on the source object Returns TDst The result of the function invocation Type Parameters TSrc The type of the source object TDst The type of the result"
  },
  "api/Hi.Common.JsonUtil.html": {
    "href": "api/Hi.Common.JsonUtil.html",
    "title": "Class JsonUtil | HiAPI-C# 2025",
    "summary": "Class JsonUtil Namespace Hi.Common Assembly HiGeom.dll Helper utilities for reading and writing JSON files. public static class JsonUtil Inheritance object JsonUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Properties CompactNanOptions Compact (single-line) serializer options supporting NaN / Infinity / -Infinity as quoted literal strings. This is the exact leaf encoding ToLeafCompactJsonString(JsonNode, JsonSerializerOptions) uses, exposed so other serialization paths (e.g. freezing a parse tree to UTF-8 bytes) can guarantee a byte-identical projection after a serialize → parse round-trip. Null-valued entries are written explicitly. public static JsonSerializerOptions CompactNanOptions { get; } Property Value JsonSerializerOptions Methods CallJsonArrayByPath(JsonObject, IEnumerable<string>) Navigates or creates a JSON array path in the source JSON object. Creates missing intermediate objects and the final array as needed. public static JsonArray CallJsonArrayByPath(this JsonObject srcdst, IEnumerable<string> jsonObjectPath) Parameters srcdst JsonObject The source JSON object to navigate. jsonObjectPath IEnumerable<string> The path segments to navigate through. The last segment will be treated as an array. Returns JsonArray The JSON array at the specified path, creating it if it doesn't exist. Returns null if the path is empty. CallJsonObjectByPath(JsonObject, IEnumerable<string>) Navigates or creates a JSON object path in the source JSON object. Creates missing intermediate objects as needed. public static JsonObject CallJsonObjectByPath(this JsonObject srcdst, IEnumerable<string> jsonObjectPath) Parameters srcdst JsonObject The source JSON object to navigate. jsonObjectPath IEnumerable<string> The path segments to navigate through. Returns JsonObject The JSON object at the specified path, creating it if it doesn't exist. GetDouble(JsonNode) Gets a double from a JsonNode that may hold int, long, or double. Also maps the named floating-point literal strings “NaN”, “Infinity” and \"-Infinity\" — the quoted form AllowNamedFloatingPointLiterals writes for those values — back to their double constants, so a node re-parsed from serialized JSON reads the same as the live value. public static double? GetDouble(this JsonNode node) Parameters node JsonNode Returns double? GetJsonNodeByPath(JsonObject, List<string>) Navigates a JSON object tree by path segments and returns the node at the end of the path. public static JsonNode GetJsonNodeByPath(this JsonObject root, List<string> pathSegments) Parameters root JsonObject The root JSON object. pathSegments List<string> The path segments to navigate through. Returns JsonNode The JSON node at the specified path, or null if the path does not exist. ToLeafCompactJsonString(JsonNode, JsonSerializerOptions) Serializes a JsonNode so that stem containers are indented but leaf containers (all children are primitive values) are written on a single compact line. Supports NaN / Infinity / -Infinity. public static string ToLeafCompactJsonString(this JsonNode src, JsonSerializerOptions options = null) Parameters src JsonNode options JsonSerializerOptions Returns string WritePartialJson<TConfig>(string, string, TConfig) Writes a config object into a named section of a JSON file; merges when file exists and overwrites the same section name. public static void WritePartialJson<TConfig>(string filePath, string configName, TConfig config) Parameters filePath string JSON file path configName string Section name to write config TConfig Section object to write Type Parameters TConfig Type of the config object"
  },
  "api/Hi.Common.LooseRunner.MergedCancellationTokenRun.html": {
    "href": "api/Hi.Common.LooseRunner.MergedCancellationTokenRun.html",
    "title": "Delegate LooseRunner.MergedCancellationTokenRun | HiAPI-C# 2025",
    "summary": "Delegate LooseRunner.MergedCancellationTokenRun Namespace Hi.Common Assembly HiGeom.dll Delegate for actions that accept a merged cancellation token. The merged token combines the runner's disposal token with an optional external cancellation token. public delegate void LooseRunner.MergedCancellationTokenRun(CancellationToken mergedCancellationToken) Parameters mergedCancellationToken CancellationToken The merged cancellation token combining disposal and external tokens. Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Common.LooseRunner.html": {
    "href": "api/Hi.Common.LooseRunner.html",
    "title": "Class LooseRunner | HiAPI-C# 2025",
    "summary": "Class LooseRunner Namespace Hi.Common Assembly HiGeom.dll Provides a mechanism for running actions asynchronously in a loose manner. Only the most recent action is executed and previous pending actions are discarded. public class LooseRunner : IDisposable Inheritance object LooseRunner Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors LooseRunner(ILogger, CancellationToken?) Initializes a new instance of the LooseRunner class with an ILogger for exception reporting. public LooseRunner(ILogger logger, CancellationToken? cancellationToken = null) Parameters logger ILogger The logger used to report exceptions. cancellationToken CancellationToken? Optional cancellation token to control the lifetime of the runner. LooseRunner(Action<Exception>, CancellationToken?) Initializes a new instance of the LooseRunner class. public LooseRunner(Action<Exception> exceptionAction = null, CancellationToken? cancellationToken = null) Parameters exceptionAction Action<Exception> Optional action invoked when an exception occurs. If null, exceptions are silently ignored. cancellationToken CancellationToken? Optional cancellation token to control the lifetime of the runner. If not provided, a new token will be created. Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) Releases the unmanaged resources used by the LooseRunner and optionally releases the managed resources. protected virtual void Dispose(bool disposing) Parameters disposing bool true to release both managed and unmanaged resources; false to release only unmanaged resources. GetLastWaiting() Asynchronously waits for the last action to complete execution. public Task GetLastWaiting() Returns Task A task representing the asynchronous wait operation. TryRun(MergedCancellationTokenRun, CancellationToken?) Tries to run the specified action asynchronously. If an action is already pending, it will be replaced with the new action. public void TryRun(LooseRunner.MergedCancellationTokenRun action, CancellationToken? cancellationToken = null) Parameters action LooseRunner.MergedCancellationTokenRun The action to run. The input cancellation token is the merge of cancellationToken and the runner hosted cancellation token that called on disposing. cancellationToken CancellationToken? external cancellation token WaitLastActionDone() Waits for the last action to complete execution. public void WaitLastActionDone()"
  },
  "api/Hi.Common.ManualUtil.html": {
    "href": "api/Hi.Common.ManualUtil.html",
    "title": "Class ManualUtil | HiAPI-C# 2025",
    "summary": "Class ManualUtil Namespace Hi.Common Assembly HiNc.dll Utility class for handling manual and documentation files with culture support. public static class ManualUtil Inheritance object ManualUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields culture_keyword Keyword placeholder for culture in URL templates. public const string culture_keyword = \"{culture}\" Field Value string Methods GetBestDeployUrl(string) Gets the best available deployment URL by removing the wwwroot prefix from the source URL. public static string GetBestDeployUrl(string urlTemplate) Parameters urlTemplate string URL template containing culture placeholder. Returns string The best matching deployment URL for the current culture. GetBestSourceUrl(string) Gets the best available source URL by matching the current culture or falling back to defaults. public static string GetBestSourceUrl(string urlTemplate) Parameters urlTemplate string URL template containing culture placeholder. Returns string The best matching source URL for the current culture. GetTitle(string, ILogger) Extracts the title from an HTML file by looking for the first h1 tag or title tag. public static string GetTitle(string urlTemplate, ILogger logger) Parameters urlTemplate string URL template containing culture placeholder. logger ILogger The logger instance. Returns string The extracted title or empty string if not found."
  },
  "api/Hi.Common.MaskUtil.html": {
    "href": "api/Hi.Common.MaskUtil.html",
    "title": "Class MaskUtil | HiAPI-C# 2025",
    "summary": "Class MaskUtil Namespace Hi.Common Assembly HiGeom.dll Utility for bits masking. public static class MaskUtil Inheritance object MaskUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetMaskedValue<T>(T, T, bool) Get converted src which all bits from mask is committing or not. If isCommitting is true, return src OR mask; otherwise , return src AND (~mask). public static T GetMaskedValue<T>(this T src, T mask, bool isCommitting) where T : struct Parameters src T src mask T mask isCommitting bool is committing or cancelling Returns T Converted value Type Parameters T number type SetMask<T>(ref T, T, bool) Set src converted by which all bits from mask is committing or not. If isCommitting is true, return src OR mask; otherwise , return src AND (~mask). public static void SetMask<T>(this ref T src, T mask, bool isCommitting) where T : struct Parameters src T src mask T mask isCommitting bool is committing or cancelling Type Parameters T number type"
  },
  "api/Hi.Common.Messages.ActionProgress-1.html": {
    "href": "api/Hi.Common.Messages.ActionProgress-1.html",
    "title": "Class ActionProgress<T> | HiAPI-C# 2025",
    "summary": "Class ActionProgress<T> Namespace Hi.Common.Messages Assembly HiGeom.dll Lightweight IProgress<T> that delegates to an Action<T>. Unlike Progress<T>, does not capture SynchronizationContext and invokes the handler synchronously on the caller's thread. public class ActionProgress<T> : IProgress<T> Type Parameters T Inheritance object ActionProgress<T> Implements IProgress<T> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActionProgress(Action<T>) Initializes a new instance that forwards each reported value to handler. public ActionProgress(Action<T> handler) Parameters handler Action<T> Delegate invoked synchronously by Report(T). Methods FromLogger(ILogger) Creates an IProgress<T> that routes an IMessage (or a raw Exception) to the appropriate ILogger level. public static IProgress<object> FromLogger(ILogger logger) Parameters logger ILogger Returns IProgress<object> Report(T) Reports a progress update. public void Report(T value) Parameters value T The value of the updated progress."
  },
  "api/Hi.Common.Messages.BootstrapTheme.html": {
    "href": "api/Hi.Common.Messages.BootstrapTheme.html",
    "title": "Enum BootstrapTheme | HiAPI-C# 2025",
    "summary": "Enum BootstrapTheme Namespace Hi.Common.Messages Assembly HiGeom.dll Bootstrap theme colors for UI styling. public enum BootstrapTheme Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields danger = 5 Danger theme color (typically red). dark = 7 Dark theme color (typically black or very dark gray). info = 3 Information theme color (typically light blue). light = 6 Light theme color (typically white or very light gray). primary = 0 Primary theme color (typically blue). secondary = 1 Secondary theme color (typically gray). success = 2 Success theme color (typically green). warning = 4 Warning theme color (typically yellow)."
  },
  "api/Hi.Common.Messages.Category.html": {
    "href": "api/Hi.Common.Messages.Category.html",
    "title": "Enum Category | HiAPI-C# 2025",
    "summary": "Enum Category Namespace Hi.Common.Messages Assembly HiGeom.dll Classification of an IMessage — the “what kind of concern” axis, orthogonal to the Severity importance axis it pairs with. Applies to every IMessage on the channel (lifecycle / progress notices, configuration checks, NC-pipeline diagnostics, …), not only NC messages. public enum Category Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Configuration = 3 Missing or misconfigured end-user dependency / configuration (e.g. coordinate table, tool offset table, machine axis config, rapid feedrate config). System = 0 General program / pipeline output — lifecycle, progress, infrastructure, internal exceptions. The default when no more-specific category applies. Unsupported = 1 Recognized but unimplemented feature. Validation = 2 Manufacturing / physics feasibility check. Remarks Representative (Category × Severity) combinations: System + Message / Progress → lifecycle, progress, general program output System + Error → exception / bug, unconsidered case Unsupported + Warning → known unsupported, likely harmless Unsupported + Error → known unsupported, likely matters Validation + Warning → manufacturing / physics may be unfeasible Validation + Error → manufacturing / physics is unfeasible Configuration + Message → dependency / config applied, informational Configuration + Warning → dependency / config missing, using fallback Configuration + Error → dependency / config missing, cannot proceed"
  },
  "api/Hi.Common.Messages.DebugUtil.html": {
    "href": "api/Hi.Common.Messages.DebugUtil.html",
    "title": "Class DebugUtil | HiAPI-C# 2025",
    "summary": "Class DebugUtil Namespace Hi.Common.Messages Assembly HiGeom.dll Debug utility provides functions: pause process, count execution time and show the count. public static class DebugUtil Inheritance object DebugUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Properties Count Count of calling C(). The Count is shown by S(string). The Count helps to trigger pause by P(int). public static int Count { get; set; } Property Value int Data The data storage for the DebugUtil class. public static Dictionary<object, object> Data { get; } Property Value Dictionary<object, object> Debugee The object being debugged. public static object Debugee { get; set; } Property Value object NativeDebugVar Gets or sets the native debug variable in the C++ core library. public static int NativeDebugVar { get; set; } Property Value int WriteLineAction The action to be performed when writing a line of text. public static Action<string> WriteLineAction { get; set; } Property Value Action<string> Methods C() Count++. public static int C() Returns int current count CPS(int, string) Execute C(). Pause and execute S(string) if count >= p. public static int CPS(int p = 0, string text = null) Parameters p int pause number text string text to show Returns int current count CS(string) Call C() and then call S(string). public static int CS(string shownText = null) Parameters shownText string the text to show Returns int count CSP(int, string) Execute the functions in sequence: C(), S(string), P(int). public static int CSP(int p = 0, string shownText = null) Parameters p int pause number shownText string text to show Returns int count P(int) Pause if count >= p. public static int P(int p = 0) Parameters p int pause number Returns int current count S(string) Call WriteLineAction?.Invoke to show the text and count. public static int S(string shownText = null) Parameters shownText string text to show Returns int current count SP(int, string) Call S(string) and then call P(int). public static int SP(int p = 0, string shownText = null) Parameters p int shownText string text to show Returns int count WriteLine(string) Writes a line of text with the current count. This is an alias for S(string). public static int WriteLine(string shownText = null) Parameters shownText string The text to show. Returns int The current count."
  },
  "api/Hi.Common.Messages.ExceptionUtil.html": {
    "href": "api/Hi.Common.Messages.ExceptionUtil.html",
    "title": "Class ExceptionUtil | HiAPI-C# 2025",
    "summary": "Class ExceptionUtil Namespace Hi.Common.Messages Assembly HiGeom.dll Provides utility methods for handling exceptions. public static class ExceptionUtil Inheritance object ExceptionUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods CatchExceptions(Task, Action<Exception>) Continues the task and reports any exception via onException. public static Task CatchExceptions(this Task task, Action<Exception> onException) Parameters task Task onException Action<Exception> Returns Task CatchExceptions<TSilent>(Task, Action<Exception>) Continues the task and reports exceptions via onException, silently ignoring TSilent. public static Task CatchExceptions<TSilent>(this Task task, Action<Exception> onException) where TSilent : Exception Parameters task Task onException Action<Exception> Returns Task Type Parameters TSilent"
  },
  "api/Hi.Common.Messages.IMessage.html": {
    "href": "api/Hi.Common.Messages.IMessage.html",
    "title": "Interface IMessage | HiAPI-C# 2025",
    "summary": "Interface IMessage Namespace Hi.Common.Messages Assembly HiGeom.dll Common contract for a single reportable item on an IProgress<T> channel — an NC diagnostic, a step-anchored notice, a simple message, or a progress fraction. Consumers (GUI / log) treat every kind uniformly through this view, while each concrete kind is still stored by its own owner (e.g. NcDiagnostic by NcDiagnosticProgress, ClStripPos by ClStrip) rather than being mixed into one shared collection. public interface IMessage Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetArgs() Gets the values interpolated into GetFormat(); null when GetFormat() is null, possibly empty for a hole-less template. Default interface method so external implementers are unaffected. object[] GetArgs() Returns object[] The interpolation arguments, or null when untemplated. GetCategory() Gets the classification — see Category. Category GetCategory() Returns Category The category of this message. GetDetail() Gets the optional detail payload or exception; null when not applicable. object GetDetail() Returns object The detail object, or null. GetFormat() Gets the composite-format template behind GetNotification() — a {0}-style .NET format string — when this message was produced from an interpolated template; null when the notification has no structured template. Together with GetArgs() this lets a consumer re-render the message in another language without losing the interpolated live values, while GetNotification() stays the invariant English rendering. Default interface method so external implementers are unaffected. string GetFormat() Returns string The composite format string, or null when untemplated. GetId() Gets the structured id used for filtering / suppression; may be null. string GetId() Returns string The message id, or null when not applicable. GetNotification() Gets the end-user friendly notification text. string GetNotification() Returns string The notification text. GetSeverity() Gets the importance level — see Severity. Severity GetSeverity() Returns Severity The severity of this message."
  },
  "api/Hi.Common.Messages.IProgressMessage.html": {
    "href": "api/Hi.Common.Messages.IProgressMessage.html",
    "title": "Interface IProgressMessage | HiAPI-C# 2025",
    "summary": "Interface IProgressMessage Namespace Hi.Common.Messages Assembly HiGeom.dll Marker for an IMessage that is itself a container of messages (a batch produced over the course of some scoped work) rather than a single leaf notice. A sink may give it special treatment — unrolling its accumulated children, in order, instead of storing the composite object itself. Empty by design: the contract is purely the marker. The children are exposed by the concrete type (e.g. StepScopedProgress.MessageList) and drained at the point that owns the ordering guarantee, so a consumer that does not recognize IProgressMessage simply treats the composite as an opaque IMessage. public interface IProgressMessage : IMessage Inherited Members IMessage.GetSeverity() IMessage.GetCategory() IMessage.GetId() IMessage.GetNotification() IMessage.GetDetail() IMessage.GetFormat() IMessage.GetArgs() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Common.Messages.MessageBoardUtil.html": {
    "href": "api/Hi.Common.Messages.MessageBoardUtil.html",
    "title": "Class MessageBoardUtil | HiAPI-C# 2025",
    "summary": "Class MessageBoardUtil Namespace Hi.Common.Messages Assembly HiGeom.dll Utility class for displaying messages on a message board. public static class MessageBoardUtil Inheritance object MessageBoardUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Properties IsEnabled Gets or sets whether message board functionality is enabled. When disabled in console applications, message board functions have no effect. public static bool IsEnabled { get; set; } Property Value bool Methods ShowError(string, string) Shows an error message on the message board. public static void ShowError(string title, string message) Parameters title string Title of the message message string Content of the message ShowFailed(string, string) Shows a failure message on the message board. public static void ShowFailed(string title, string message) Parameters title string Title of the message message string Content of the message ShowMessage(string, string, BootstrapTheme) Displays a message on the message board with specified title and theme color. public static void ShowMessage(string title, string message, BootstrapTheme bootstrapThemeColor) Parameters title string The title of the message message string The content of the message bootstrapThemeColor BootstrapTheme The theme color for the message display ShowSuccess(string, string) Shows a success message on the message board. public static void ShowSuccess(string title, string message) Parameters title string Title of the message message string Content of the message ShowWarning(string, string) Shows a warning message on the message board. public static void ShowWarning(string title, string message) Parameters title string Title of the message message string Content of the message Events ShowMessageBoard Event that is triggered when a message needs to be displayed. public static event ShowMessageBoardDelegate ShowMessageBoard Event Type ShowMessageBoardDelegate"
  },
  "api/Hi.Common.Messages.MessageCollector.html": {
    "href": "api/Hi.Common.Messages.MessageCollector.html",
    "title": "Class MessageCollector | HiAPI-C# 2025",
    "summary": "Class MessageCollector Namespace Hi.Common.Messages Assembly HiGeom.dll A minimal IProgress<T> of IMessage that buffers every reported message into Messages. Intended as a per-call / per-request sink: a caller injects it into a have-both function (one that takes an IProgress<IMessage> messageProgress), runs the operation, then reads the collected messages back — e.g. to return them in an HTTP response so a REST / AI caller sees progress, success, and error notifications inline. Unlike the session / step sinks (ShellProgress, StepDiagnosticProgress) it fires no events and holds no session or pipeline state; it is cheap to create and discard for the lifetime of a single call. public sealed class MessageCollector : IProgress<IMessage> Inheritance object MessageCollector Implements IProgress<IMessage> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MessageUtil.ConfigurationError(IProgress<IMessage>, string, string, object) MessageUtil.ConfigurationErrorFmt(IProgress<IMessage>, string, FormattableString, object) MessageUtil.ConfigurationMessage(IProgress<IMessage>, string, string, object) MessageUtil.ConfigurationMessageFmt(IProgress<IMessage>, string, FormattableString, object) MessageUtil.ConfigurationWarning(IProgress<IMessage>, string, string, object) MessageUtil.ConfigurationWarningFmt(IProgress<IMessage>, string, FormattableString, object) MessageUtil.SystemError(IProgress<IMessage>, string, string, object) MessageUtil.SystemErrorFmt(IProgress<IMessage>, string, FormattableString, object) MessageUtil.SystemMessage(IProgress<IMessage>, string, string, object) MessageUtil.SystemMessageFmt(IProgress<IMessage>, string, FormattableString, object) MessageUtil.SystemProgress(IProgress<IMessage>, string, string, object) MessageUtil.SystemProgressFmt(IProgress<IMessage>, string, FormattableString, object) MessageUtil.SystemSuccess(IProgress<IMessage>, string, string, object) MessageUtil.SystemSuccessFmt(IProgress<IMessage>, string, FormattableString, object) MessageUtil.SystemWarning(IProgress<IMessage>, string, string, object) MessageUtil.SystemWarningFmt(IProgress<IMessage>, string, FormattableString, object) MessageUtil.UnsupportedError(IProgress<IMessage>, string, string, object) MessageUtil.UnsupportedErrorFmt(IProgress<IMessage>, string, FormattableString, object) MessageUtil.UnsupportedMessage(IProgress<IMessage>, string, string, object) MessageUtil.UnsupportedMessageFmt(IProgress<IMessage>, string, FormattableString, object) MessageUtil.UnsupportedWarning(IProgress<IMessage>, string, string, object) MessageUtil.UnsupportedWarningFmt(IProgress<IMessage>, string, FormattableString, object) MessageUtil.ValidationError(IProgress<IMessage>, string, string, object) MessageUtil.ValidationErrorFmt(IProgress<IMessage>, string, FormattableString, object) MessageUtil.ValidationWarning(IProgress<IMessage>, string, string, object) MessageUtil.ValidationWarningFmt(IProgress<IMessage>, string, FormattableString, object) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Messages The messages reported so far, in arrival order. public List<IMessage> Messages { get; } Property Value List<IMessage> Methods Report(IMessage) Reports a progress update. public void Report(IMessage value) Parameters value IMessage The value of the updated progress."
  },
  "api/Hi.Common.Messages.MessageFlag.html": {
    "href": "api/Hi.Common.Messages.MessageFlag.html",
    "title": "Enum MessageFlag | HiAPI-C# 2025",
    "summary": "Enum MessageFlag Namespace Hi.Common.Messages Assembly HiGeom.dll Enumeration of common message types used for system notifications. public enum MessageFlag Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Error = 1 General error messages. For exception which is consciously handled. Exception = 0 System error messages. For exception which is not consciously handled. Info = 7 System behavior that end user not need to know. The message make help to tracing end user behavior. Message = 6 Something else from the upper flags to tell the end user. Progress = 4 Progress update messages. Success = 5 Progress complete on success messages. Warning = 2 Warning messages."
  },
  "api/Hi.Common.Messages.MessageUtil.html": {
    "href": "api/Hi.Common.Messages.MessageUtil.html",
    "title": "Class MessageUtil | HiAPI-C# 2025",
    "summary": "Class MessageUtil Namespace Hi.Common.Messages Assembly HiGeom.dll Extension helpers for reporting SimpleMessage records onto an IProgress<T> of IMessage sink — the IMessage-channel counterpart of NcDiagnosticProgress's shorthand methods. Every helper is named {Category}{Severity} and is id-first; the structured id is used for filtering / suppression. All overloads are null-safe on host. Each helper has a {Category}{Severity}Fmt sibling taking a FormattableString: it keeps the interpolated template and values (Format / Args) so a client can re-render the message in another language, while the notification stays the invariant English rendering. The sibling must be opted into by name — an interpolated string literal passed to the string helper binds to string and is not captured. public static class MessageUtil Inheritance object MessageUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods ConfigurationError(IProgress<IMessage>, string, string, object) Reports Configuration + Error (dependency/config missing, cannot proceed). public static void ConfigurationError(this IProgress<IMessage> host, string id, string text, object detail = null) Parameters host IProgress<IMessage> id string text string detail object ConfigurationErrorFmt(IProgress<IMessage>, string, FormattableString, object) Templated ConfigurationError(IProgress<IMessage>, string, string, object) — keeps format + args for localization. public static void ConfigurationErrorFmt(this IProgress<IMessage> host, string id, FormattableString text, object detail = null) Parameters host IProgress<IMessage> id string text FormattableString detail object ConfigurationMessage(IProgress<IMessage>, string, string, object) Reports Configuration + Message (dependency/config applied, informational). public static void ConfigurationMessage(this IProgress<IMessage> host, string id, string text, object detail = null) Parameters host IProgress<IMessage> id string text string detail object ConfigurationMessageFmt(IProgress<IMessage>, string, FormattableString, object) Templated ConfigurationMessage(IProgress<IMessage>, string, string, object) — keeps format + args for localization. public static void ConfigurationMessageFmt(this IProgress<IMessage> host, string id, FormattableString text, object detail = null) Parameters host IProgress<IMessage> id string text FormattableString detail object ConfigurationWarning(IProgress<IMessage>, string, string, object) Reports Configuration + Warning (dependency/config missing, using fallback). public static void ConfigurationWarning(this IProgress<IMessage> host, string id, string text, object detail = null) Parameters host IProgress<IMessage> id string text string detail object ConfigurationWarningFmt(IProgress<IMessage>, string, FormattableString, object) Templated ConfigurationWarning(IProgress<IMessage>, string, string, object) — keeps format + args for localization. public static void ConfigurationWarningFmt(this IProgress<IMessage> host, string id, FormattableString text, object detail = null) Parameters host IProgress<IMessage> id string text FormattableString detail object SystemError(IProgress<IMessage>, string, string, object) Reports System + Error (exception or unconsidered case). public static void SystemError(this IProgress<IMessage> host, string id, string text, object detail = null) Parameters host IProgress<IMessage> id string text string detail object SystemErrorFmt(IProgress<IMessage>, string, FormattableString, object) Templated SystemError(IProgress<IMessage>, string, string, object) — keeps format + args for localization. public static void SystemErrorFmt(this IProgress<IMessage> host, string id, FormattableString text, object detail = null) Parameters host IProgress<IMessage> id string text FormattableString detail object SystemMessage(IProgress<IMessage>, string, string, object) Reports System + Message (pipeline lifecycle / informational). public static void SystemMessage(this IProgress<IMessage> host, string id, string text, object detail = null) Parameters host IProgress<IMessage> id string text string detail object SystemMessageFmt(IProgress<IMessage>, string, FormattableString, object) Templated SystemMessage(IProgress<IMessage>, string, string, object) — keeps format + args for localization. public static void SystemMessageFmt(this IProgress<IMessage> host, string id, FormattableString text, object detail = null) Parameters host IProgress<IMessage> id string text FormattableString detail object SystemProgress(IProgress<IMessage>, string, string, object) Reports System + Progress (ongoing pipeline progress). public static void SystemProgress(this IProgress<IMessage> host, string id, string text, object detail = null) Parameters host IProgress<IMessage> id string text string detail object SystemProgressFmt(IProgress<IMessage>, string, FormattableString, object) Templated SystemProgress(IProgress<IMessage>, string, string, object) — keeps format + args for localization. public static void SystemProgressFmt(this IProgress<IMessage> host, string id, FormattableString text, object detail = null) Parameters host IProgress<IMessage> id string text FormattableString detail object SystemSuccess(IProgress<IMessage>, string, string, object) Reports System + Success (pipeline step completed). public static void SystemSuccess(this IProgress<IMessage> host, string id, string text, object detail = null) Parameters host IProgress<IMessage> id string text string detail object SystemSuccessFmt(IProgress<IMessage>, string, FormattableString, object) Templated SystemSuccess(IProgress<IMessage>, string, string, object) — keeps format + args for localization. public static void SystemSuccessFmt(this IProgress<IMessage> host, string id, FormattableString text, object detail = null) Parameters host IProgress<IMessage> id string text FormattableString detail object SystemWarning(IProgress<IMessage>, string, string, object) Reports System + Warning (pipeline anomaly, processing continues). public static void SystemWarning(this IProgress<IMessage> host, string id, string text, object detail = null) Parameters host IProgress<IMessage> id string text string detail object SystemWarningFmt(IProgress<IMessage>, string, FormattableString, object) Templated SystemWarning(IProgress<IMessage>, string, string, object) — keeps format + args for localization. public static void SystemWarningFmt(this IProgress<IMessage> host, string id, FormattableString text, object detail = null) Parameters host IProgress<IMessage> id string text FormattableString detail object UnsupportedError(IProgress<IMessage>, string, string, object) Reports Unsupported + Error (recognized but unimplemented, likely matters). public static void UnsupportedError(this IProgress<IMessage> host, string id, string text, object detail = null) Parameters host IProgress<IMessage> id string text string detail object UnsupportedErrorFmt(IProgress<IMessage>, string, FormattableString, object) Templated UnsupportedError(IProgress<IMessage>, string, string, object) — keeps format + args for localization. public static void UnsupportedErrorFmt(this IProgress<IMessage> host, string id, FormattableString text, object detail = null) Parameters host IProgress<IMessage> id string text FormattableString detail object UnsupportedMessage(IProgress<IMessage>, string, string, object) Reports Unsupported + Message (recognized, intentionally not simulated). public static void UnsupportedMessage(this IProgress<IMessage> host, string id, string text, object detail = null) Parameters host IProgress<IMessage> id string text string detail object UnsupportedMessageFmt(IProgress<IMessage>, string, FormattableString, object) Templated UnsupportedMessage(IProgress<IMessage>, string, string, object) — keeps format + args for localization. public static void UnsupportedMessageFmt(this IProgress<IMessage> host, string id, FormattableString text, object detail = null) Parameters host IProgress<IMessage> id string text FormattableString detail object UnsupportedWarning(IProgress<IMessage>, string, string, object) Reports Unsupported + Warning (recognized but unimplemented, likely harmless). public static void UnsupportedWarning(this IProgress<IMessage> host, string id, string text, object detail = null) Parameters host IProgress<IMessage> id string text string detail object UnsupportedWarningFmt(IProgress<IMessage>, string, FormattableString, object) Templated UnsupportedWarning(IProgress<IMessage>, string, string, object) — keeps format + args for localization. public static void UnsupportedWarningFmt(this IProgress<IMessage> host, string id, FormattableString text, object detail = null) Parameters host IProgress<IMessage> id string text FormattableString detail object ValidationError(IProgress<IMessage>, string, string, object) Reports Validation + Error (manufacturing/physics is unfeasible). public static void ValidationError(this IProgress<IMessage> host, string id, string text, object detail = null) Parameters host IProgress<IMessage> id string text string detail object ValidationErrorFmt(IProgress<IMessage>, string, FormattableString, object) Templated ValidationError(IProgress<IMessage>, string, string, object) — keeps format + args for localization. public static void ValidationErrorFmt(this IProgress<IMessage> host, string id, FormattableString text, object detail = null) Parameters host IProgress<IMessage> id string text FormattableString detail object ValidationWarning(IProgress<IMessage>, string, string, object) Reports Validation + Warning (manufacturing/physics may be unfeasible). public static void ValidationWarning(this IProgress<IMessage> host, string id, string text, object detail = null) Parameters host IProgress<IMessage> id string text string detail object ValidationWarningFmt(IProgress<IMessage>, string, FormattableString, object) Templated ValidationWarning(IProgress<IMessage>, string, string, object) — keeps format + args for localization. public static void ValidationWarningFmt(this IProgress<IMessage> host, string id, FormattableString text, object detail = null) Parameters host IProgress<IMessage> id string text FormattableString detail object"
  },
  "api/Hi.Common.Messages.Severity.html": {
    "href": "api/Hi.Common.Messages.Severity.html",
    "title": "Enum Severity | HiAPI-C# 2025",
    "summary": "Enum Severity Namespace Hi.Common.Messages Assembly HiGeom.dll Importance level of an IMessage. Combined with Category to form the full meaning (e.g. Validation + Warning). Promoted from the former NcDiagnosticSeverity so non-NC messages (simple notices, progress fractions) share a single scale. public enum Severity Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Error = 4 Definite issue — result may be incorrect. Message = 0 Informational status. Progress = 2 Ongoing progress / fraction update. Success = 1 Completed successfully. Warning = 3 Potential issue — processing continues."
  },
  "api/Hi.Common.Messages.ShowMessageBoardDelegate.html": {
    "href": "api/Hi.Common.Messages.ShowMessageBoardDelegate.html",
    "title": "Delegate ShowMessageBoardDelegate | HiAPI-C# 2025",
    "summary": "Delegate ShowMessageBoardDelegate Namespace Hi.Common.Messages Assembly HiGeom.dll Delegate for showing message board notifications. public delegate void ShowMessageBoardDelegate(string title, string message, BootstrapTheme bootstrapThemeColor) Parameters title string Title of the message message string Content of the message bootstrapThemeColor BootstrapTheme Theme color for the message Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Common.Messages.SimpleMessage.html": {
    "href": "api/Hi.Common.Messages.SimpleMessage.html",
    "title": "Class SimpleMessage | HiAPI-C# 2025",
    "summary": "Class SimpleMessage Namespace Hi.Common.Messages Assembly HiGeom.dll A plain IMessage with no anchor: severity, category, id, notification text and optional detail. This is the default carrier for ad-hoc messages that have no other home. When step context is available, a step-anchored decorator wraps a SimpleMessage to add the StepIndex / SentenceCarrier without the producer needing to know it. public class SimpleMessage : IMessage Inheritance object SimpleMessage Implements IMessage Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SimpleMessage(Severity, FormattableString, Category, string, object) Initializes a templated instance: the interpolated template and its values are kept on Format / Args and Notification becomes the culture-invariant English rendering. An interpolated string literal passed to the string constructor is NOT captured here — call sites opt in through the *Fmt helpers on MessageUtil. public SimpleMessage(Severity severity, FormattableString notification, Category category = Category.System, string id = null, object detail = null) Parameters severity Severity Importance level. notification FormattableString Interpolated notification template. category Category Classification; defaults to System. id string Optional structured id. detail object Optional detail payload or exception. SimpleMessage(Severity, string, Category, string, object) Initializes a new instance of the SimpleMessage class. public SimpleMessage(Severity severity, string notification, Category category = Category.System, string id = null, object detail = null) Parameters severity Severity Importance level. notification string End-user friendly notification text. category Category Classification; defaults to System. id string Optional structured id. detail object Optional detail payload or exception. Properties Args Gets the values interpolated into Format; null when untemplated. public object[] Args { get; } Property Value object[] Category Gets the classification. public Category Category { get; } Property Value Category Detail Gets the optional detail payload or exception; null when not applicable. public object Detail { get; } Property Value object Format Gets the composite-format template behind Notification; null when the message was built from a plain string (untemplated). public string Format { get; } Property Value string Id Gets the structured id for filtering / suppression; may be null. public string Id { get; } Property Value string Notification Gets the end-user friendly notification text. public string Notification { get; } Property Value string Severity Gets the importance level. public Severity Severity { get; } Property Value Severity Methods GetArgs() Gets the values interpolated into GetFormat(); null when GetFormat() is null, possibly empty for a hole-less template. Default interface method so external implementers are unaffected. public object[] GetArgs() Returns object[] The interpolation arguments, or null when untemplated. GetCategory() Gets the classification — see Category. public Category GetCategory() Returns Category The category of this message. GetDetail() Gets the optional detail payload or exception; null when not applicable. public object GetDetail() Returns object The detail object, or null. GetFormat() Gets the composite-format template behind GetNotification() — a {0}-style .NET format string — when this message was produced from an interpolated template; null when the notification has no structured template. Together with GetArgs() this lets a consumer re-render the message in another language without losing the interpolated live values, while GetNotification() stays the invariant English rendering. Default interface method so external implementers are unaffected. public string GetFormat() Returns string The composite format string, or null when untemplated. GetId() Gets the structured id used for filtering / suppression; may be null. public string GetId() Returns string The message id, or null when not applicable. GetNotification() Gets the end-user friendly notification text. public string GetNotification() Returns string The notification text. GetSeverity() Gets the importance level — see Severity. public Severity GetSeverity() Returns Severity The severity of this message. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Common.Messages.html": {
    "href": "api/Hi.Common.Messages.html",
    "title": "Namespace Hi.Common.Messages | HiAPI-C# 2025",
    "summary": "Namespace Hi.Common.Messages Classes ActionProgress<T> Lightweight IProgress<T> that delegates to an Action<T>. Unlike Progress<T>, does not capture SynchronizationContext and invokes the handler synchronously on the caller's thread. DebugUtil Debug utility provides functions: pause process, count execution time and show the count. ExceptionUtil Provides utility methods for handling exceptions. MessageBoardUtil Utility class for displaying messages on a message board. MessageCollector A minimal IProgress<T> of IMessage that buffers every reported message into Messages. Intended as a per-call / per-request sink: a caller injects it into a have-both function (one that takes an IProgress<IMessage> messageProgress), runs the operation, then reads the collected messages back — e.g. to return them in an HTTP response so a REST / AI caller sees progress, success, and error notifications inline. Unlike the session / step sinks (ShellProgress, StepDiagnosticProgress) it fires no events and holds no session or pipeline state; it is cheap to create and discard for the lifetime of a single call. MessageUtil Extension helpers for reporting SimpleMessage records onto an IProgress<T> of IMessage sink — the IMessage-channel counterpart of NcDiagnosticProgress's shorthand methods. Every helper is named {Category}{Severity} and is id-first; the structured id is used for filtering / suppression. All overloads are null-safe on host. Each helper has a {Category}{Severity}Fmt sibling taking a FormattableString: it keeps the interpolated template and values (Format / Args) so a client can re-render the message in another language, while the notification stays the invariant English rendering. The sibling must be opted into by name — an interpolated string literal passed to the string helper binds to string and is not captured. SimpleMessage A plain IMessage with no anchor: severity, category, id, notification text and optional detail. This is the default carrier for ad-hoc messages that have no other home. When step context is available, a step-anchored decorator wraps a SimpleMessage to add the StepIndex / SentenceCarrier without the producer needing to know it. Interfaces IMessage Common contract for a single reportable item on an IProgress<T> channel — an NC diagnostic, a step-anchored notice, a simple message, or a progress fraction. Consumers (GUI / log) treat every kind uniformly through this view, while each concrete kind is still stored by its own owner (e.g. NcDiagnostic by NcDiagnosticProgress, ClStripPos by ClStrip) rather than being mixed into one shared collection. IProgressMessage Marker for an IMessage that is itself a container of messages (a batch produced over the course of some scoped work) rather than a single leaf notice. A sink may give it special treatment — unrolling its accumulated children, in order, instead of storing the composite object itself. Empty by design: the contract is purely the marker. The children are exposed by the concrete type (e.g. StepScopedProgress.MessageList) and drained at the point that owns the ordering guarantee, so a consumer that does not recognize IProgressMessage simply treats the composite as an opaque IMessage. Enums BootstrapTheme Bootstrap theme colors for UI styling. Category Classification of an IMessage — the “what kind of concern” axis, orthogonal to the Severity importance axis it pairs with. Applies to every IMessage on the channel (lifecycle / progress notices, configuration checks, NC-pipeline diagnostics, …), not only NC messages. MessageFlag Enumeration of common message types used for system notifications. Severity Importance level of an IMessage. Combined with Category to form the full meaning (e.g. Validation + Warning). Promoted from the former NcDiagnosticSeverity so non-NC messages (simple notices, progress fractions) share a single scale. Delegates ShowMessageBoardDelegate Delegate for showing message board notifications."
  },
  "api/Hi.Common.MinMaxUtils.IndexedMinMaxPos-2.html": {
    "href": "api/Hi.Common.MinMaxUtils.IndexedMinMaxPos-2.html",
    "title": "Class IndexedMinMaxPos<TKey, TValue> | HiAPI-C# 2025",
    "summary": "Class IndexedMinMaxPos<TKey, TValue> Namespace Hi.Common.MinMaxUtils Assembly HiGeom.dll Represents a position with an index, key, and a range of values. public class IndexedMinMaxPos<TKey, TValue> Type Parameters TKey The type of the key TValue The type of the range values Inheritance object IndexedMinMaxPos<TKey, TValue> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors IndexedMinMaxPos() Initializes a new instance of the IndexedMinMaxPos class. public IndexedMinMaxPos() IndexedMinMaxPos(int, TKey, Range<TValue>) Initializes a new instance of the IndexedMinMaxPos class with specified values. public IndexedMinMaxPos(int index, TKey key, Range<TValue> range) Parameters index int Index value key TKey Key value range Range<TValue> Range value IndexedMinMaxPos(int, TKey, TValue, TValue) Initializes a new instance of the IndexedMinMaxPos class with specified values. public IndexedMinMaxPos(int index, TKey key, TValue min, TValue max) Parameters index int Index value key TKey Key value min TValue Minimum value max TValue Maximum value Properties Index Gets or sets the index of the position. public int Index { get; set; } Property Value int Key Gets or sets the key associated with the position. public TKey Key { get; set; } Property Value TKey Range Gets or sets the range of values for the position. public Range<TValue> Range { get; set; } Property Value Range<TValue>"
  },
  "api/Hi.Common.MinMaxUtils.MinMaxUtil.html": {
    "href": "api/Hi.Common.MinMaxUtils.MinMaxUtil.html",
    "title": "Class MinMaxUtil | HiAPI-C# 2025",
    "summary": "Class MinMaxUtil Namespace Hi.Common.MinMaxUtils Assembly HiGeom.dll Provides utility methods for finding minimum and maximum values in collections. public static class MinMaxUtil Inheritance object MinMaxUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetMinMaxList(IList<KeyValuePair<double, double[]>>, int, int) Creates a list of indexed minimum and maximum positions from a collection of key-value pairs where values are arrays. public static List<IndexedMinMaxPos<double, double[]>> GetMinMaxList(this IList<KeyValuePair<double, double[]>> src, int numThreshold, int posValueLength) Parameters src IList<KeyValuePair<double, double[]>> The source collection of key-value pairs numThreshold int The maximum number of positions to return posValueLength int The length of the value arrays Returns List<IndexedMinMaxPos<double, double[]>> A list of indexed minimum and maximum positions GetMinMaxList(IList<KeyValuePair<double, double>>, int) Creates a list of indexed minimum and maximum positions from a collection of key-value pairs. public static List<IndexedMinMaxPos<double, double>> GetMinMaxList(this IList<KeyValuePair<double, double>> src, int numThreshold) Parameters src IList<KeyValuePair<double, double>> The source collection of key-value pairs numThreshold int The maximum number of positions to return Returns List<IndexedMinMaxPos<double, double>> A list of indexed minimum and maximum positions"
  },
  "api/Hi.Common.MinMaxUtils.html": {
    "href": "api/Hi.Common.MinMaxUtils.html",
    "title": "Namespace Hi.Common.MinMaxUtils | HiAPI-C# 2025",
    "summary": "Namespace Hi.Common.MinMaxUtils Classes IndexedMinMaxPos<TKey, TValue> Represents a position with an index, key, and a range of values. MinMaxUtil Provides utility methods for finding minimum and maximum values in collections."
  },
  "api/Hi.Common.NameUtil.html": {
    "href": "api/Hi.Common.NameUtil.html",
    "title": "Class NameUtil | HiAPI-C# 2025",
    "summary": "Class NameUtil Namespace Hi.Common Assembly HiGeom.dll Utility class for handling object names and display names. public static class NameUtil Inheritance object NameUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields UnsetText Default text used when a name is not set. public const string UnsetText = \"Unset\" Field Value string Methods GetSelectionName(object) Gets the selection name for an object, using custom implementation if available, or falling back to type display name or type name. public static string GetSelectionName(this object src) Parameters src object The source object to get the name for Returns string The selection name for the object GetSelectionName(Type) Gets the selection name for a type, using its DisplayName attribute if available, or falling back to the type name. public static string GetSelectionName(this Type type) Parameters type Type The type to get the name for Returns string The selection name for the type SpacePascalWords(string) Spaces a PascalCase member name into display words: an underscore suffix is dropped and a space is inserted before each capital that starts a new word, so MachiningResolution_mm becomes “Machining Resolution” and ReadOnFirstOrWrite becomes “Read On First Or Write”. Consecutive capitals stay one word. public static string SpacePascalWords(string name) Parameters name string The member name to space. Returns string The spaced display words."
  },
  "api/Hi.Common.NativeProgresses.NativeProgressFraction.html": {
    "href": "api/Hi.Common.NativeProgresses.NativeProgressFraction.html",
    "title": "Class NativeProgressFraction | HiAPI-C# 2025",
    "summary": "Class NativeProgressFraction Namespace Hi.Common.NativeProgresses Assembly HiDisp.dll Native implementation of the progress report interface. public class NativeProgressFraction : IProgressFraction Inheritance object NativeProgressFraction Implements IProgressFraction Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NativeProgressFraction(progress_monitor_t*) Initializes a new instance of the NativeProgressFraction class. public NativeProgressFraction(progress_monitor_t* progress_monitor_ptr) Parameters progress_monitor_ptr progress_monitor_t* Pointer to the native progress monitor. Methods GetDenominator() Gets the denominator value for progress calculation. public int GetDenominator() Returns int The denominator value. GetDetail() Gets the detailed information about the progress. public string GetDetail() Returns string The detail string. GetMsg() Get message. public string GetMsg() Returns string The message string. GetNumerator() Gets the numerator value for progress calculation. public int GetNumerator() Returns int The numerator value."
  },
  "api/Hi.Common.NativeProgresses.html": {
    "href": "api/Hi.Common.NativeProgresses.html",
    "title": "Namespace Hi.Common.NativeProgresses | HiAPI-C# 2025",
    "summary": "Namespace Hi.Common.NativeProgresses Classes NativeProgressFraction Native implementation of the progress report interface. Structs progress_monitor_t Native structure for progress monitoring. Delegates report_progress_func_t Delegate for reporting progress from native code."
  },
  "api/Hi.Common.NativeProgresses.progress_monitor_t.html": {
    "href": "api/Hi.Common.NativeProgresses.progress_monitor_t.html",
    "title": "Struct progress_monitor_t | HiAPI-C# 2025",
    "summary": "Struct progress_monitor_t Namespace Hi.Common.NativeProgresses Assembly HiDisp.dll Native structure for progress monitoring. public struct progress_monitor_t Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Common.NativeProgresses.report_progress_func_t.html": {
    "href": "api/Hi.Common.NativeProgresses.report_progress_func_t.html",
    "title": "Delegate report_progress_func_t | HiAPI-C# 2025",
    "summary": "Delegate report_progress_func_t Namespace Hi.Common.NativeProgresses Assembly HiDisp.dll Delegate for reporting progress from native code. public delegate void report_progress_func_t(progress_monitor_t* progress_monitor_ptr) Parameters progress_monitor_ptr progress_monitor_t* Pointer to the progress monitor. Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Common.PacePlayee.html": {
    "href": "api/Hi.Common.PacePlayee.html",
    "title": "Class PacePlayee | HiAPI-C# 2025",
    "summary": "Class PacePlayee Namespace Hi.Common Assembly HiGeom.dll Represents an entity that can be controlled by the pace player. public class PacePlayee Inheritance object PacePlayee Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Player Gets the player that controls this playee. public PacePlayer Player { get; } Property Value PacePlayer Methods Pace() A pausable mark for the playing process. The function enables Pause() to take effect. public void Pace() Remarks Waits for the player to signal the next pace."
  },
  "api/Hi.Common.PacePlayer.html": {
    "href": "api/Hi.Common.PacePlayer.html",
    "title": "Class PacePlayer | HiAPI-C# 2025",
    "summary": "Class PacePlayer Namespace Hi.Common Assembly HiGeom.dll Controls the pace execution of a task. public class PacePlayer : IDisposable Inheritance object PacePlayer Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors PacePlayer(ILogger) Initializes a new instance with the specified logger for exception reporting. public PacePlayer(ILogger logger) Parameters logger ILogger Logger used by the player to report exceptions raised during pace execution. Properties CancellationToken Gets the cancellation token for the running task. public CancellationToken CancellationToken { get; } Property Value CancellationToken IsFinished Is the process finished from Start(). public bool IsFinished { get; } Property Value bool IsLocked Is started but not finished. IsLocked keeps true even if Pause() is called. The property is true if a task started and the task has not yet finished. public bool IsLocked { get; } Property Value bool IsRunning Is running. Not paused either finished. The property is true if a task started and the task has not yet finished and Pause() is not called. public bool IsRunning { get; } Property Value bool Logger Logger for reporting exceptions during task execution. public ILogger Logger { get; } Property Value ILogger MainAction Gets or sets the main action to be executed by the player. public Action<PacePlayee> MainAction { get; set; } Property Value Action<PacePlayee> RunCount Monotonically increasing count of runs started by Start(), incremented synchronously before the run's task launches (never reset). Serves as the run identity for status pollers: pairing this with IsFinished in one snapshot lets a client distinguish “the run I started has finished” from a stale Finished left by a previous run. 0 until the first run starts. public long RunCount { get; } Property Value long Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) Releases the unmanaged resources and optionally releases the managed resources. protected virtual void Dispose(bool disposing) Parameters disposing bool true to release both managed and unmanaged resources; false to release only unmanaged resources. Pause() Pauses the execution. public void Pause() Reset() Resets the player to its initial state. public void Reset() Resume() Resumes the execution if paused. public void Resume() RunToNextPace() Runs to the next pace point. public void RunToNextPace() Start() Starts the main action execution. public void Start() Terminate() Terminates the execution by cancelling the task. public void Terminate() Wait() Waits for the task to complete. public void Wait() Events IsFinishedChangedEvent Event triggered when the IsFinished state changes. public event Action<bool> IsFinishedChangedEvent Event Type Action<bool> IsLockedChangedEvent Event triggered when the lock state changes. public event Action<bool> IsLockedChangedEvent Event Type Action<bool> IsRunningChangedEvent Event triggered when the running state changes. public event Action<bool> IsRunningChangedEvent Event Type Action<bool> ResetedEvent Event triggered after the player has been reset. public event Action ResetedEvent Event Type Action"
  },
  "api/Hi.Common.Pair-2.html": {
    "href": "api/Hi.Common.Pair-2.html",
    "title": "Class Pair<TA, TB> | HiAPI-C# 2025",
    "summary": "Class Pair<TA, TB> Namespace Hi.Common Assembly HiGeom.dll Editable pair values. public class Pair<TA, TB> Type Parameters TA type of A TB type of B Inheritance object Pair<TA, TB> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Pair(TA, TB) constructor. public Pair(TA a, TB b) Parameters a TA member A b TB member B Properties A member A public TA A { get; set; } Property Value TA B member B public TB B { get; set; } Property Value TB Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Common.ParallelBulkUtils.ParallelBulkReader-1.html": {
    "href": "api/Hi.Common.ParallelBulkUtils.ParallelBulkReader-1.html",
    "title": "Class ParallelBulkReader<TData> | HiAPI-C# 2025",
    "summary": "Class ParallelBulkReader<TData> Namespace Hi.Common.ParallelBulkUtils Assembly HiGeom.dll Parallel bulk reader that provides efficient data access with caching capabilities. Manages reading data in parallel with forward and backward caching to optimize performance. public class ParallelBulkReader<TData> : IDisposable where TData : class Type Parameters TData The type of data to read. Inheritance object ParallelBulkReader<TData> Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ParallelBulkReader(int, int, int, ReadBulkDelegate<TData>, Func<TData, int?>, Action<Exception>) Initializes a new instance of the ParallelBulkReader<TData> class. public ParallelBulkReader(int cacheBackwardDistance, int cacheForwardDistance, int cacheQueueLimit, ReadBulkDelegate<TData> readBulkFunc, Func<TData, int?> getIndexFunc, Action<Exception> exceptionAction = null) Parameters cacheBackwardDistance int The distance to cache backward from the current index. cacheForwardDistance int The distance to cache forward from the current index. cacheQueueLimit int The maximum number of cache entries to maintain in the queue. readBulkFunc ReadBulkDelegate<TData> The function used to read bulk data. getIndexFunc Func<TData, int?> The function used to extract an index from a data item. exceptionAction Action<Exception> Optional action invoked when an exception occurs in cache operations. Properties GetIndexFunc Gets the function used to extract an index from a data item. public Func<TData, int?> GetIndexFunc { get; } Property Value Func<TData, int?> Methods ClearCache() Clears all cached data and disposes of all cache entries. public void ClearCache() Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) Releases the unmanaged resources used by the ParallelBulkReader<TData> and optionally releases the managed resources. protected virtual void Dispose(bool disposing) Parameters disposing bool true to release both managed and unmanaged resources; false to release only unmanaged resources. GetStep(int) Gets a data item at the specified step index, with automatic caching. public TData GetStep(int stepIndex) Parameters stepIndex int The index of the step to retrieve. Returns TData The data item at the specified index."
  },
  "api/Hi.Common.ParallelBulkUtils.ParallelBulkWriter-1.html": {
    "href": "api/Hi.Common.ParallelBulkUtils.ParallelBulkWriter-1.html",
    "title": "Class ParallelBulkWriter<TData> | HiAPI-C# 2025",
    "summary": "Class ParallelBulkWriter<TData> Namespace Hi.Common.ParallelBulkUtils Assembly HiGeom.dll Parallel bulk writer that efficiently processes and writes data in parallel. The writing data is buffered and processed on a separate task to improve performance. public class ParallelBulkWriter<TData> : IDisposable where TData : class Type Parameters TData The type of data to write. Inheritance object ParallelBulkWriter<TData> Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ParallelBulkWriter(Action<List<TData>>, int) Initializes a new instance of the ParallelBulkWriter<TData> class. public ParallelBulkWriter(Action<List<TData>> addAllFunc, int writingBufferCap = 131072) Parameters addAllFunc Action<List<TData>> The function used to add all data items to the destination. writingBufferCap int The capacity of the writing buffer. Default is 1024 * 128. Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) Releases the unmanaged resources used by the ParallelBulkWriter<TData> and optionally releases the managed resources. protected virtual void Dispose(bool disposing) Parameters disposing bool true to release both managed and unmanaged resources; false to release only unmanaged resources. Enqueue(TData) Adds a data item to the writing buffer for processing. public void Enqueue(TData step) Parameters step TData The data item to add. Wait() Waits for all data items in the buffer to be processed. public void Wait()"
  },
  "api/Hi.Common.ParallelBulkUtils.ReadBulkDelegate-1.html": {
    "href": "api/Hi.Common.ParallelBulkUtils.ReadBulkDelegate-1.html",
    "title": "Delegate ReadBulkDelegate<TData> | HiAPI-C# 2025",
    "summary": "Delegate ReadBulkDelegate<TData> Namespace Hi.Common.ParallelBulkUtils Assembly HiGeom.dll Delegate for reading a bulk of data from a specified range. public delegate List<TData> ReadBulkDelegate<TData>(int begin, int end) Parameters begin int The starting index (inclusive). end int The ending index (exclusive). Returns List<TData> A list of data items from the specified range. Type Parameters TData The type of data to read. Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Common.ParallelBulkUtils.SequentialBulkReader-1.html": {
    "href": "api/Hi.Common.ParallelBulkUtils.SequentialBulkReader-1.html",
    "title": "Class SequentialBulkReader<TData> | HiAPI-C# 2025",
    "summary": "Class SequentialBulkReader<TData> Namespace Hi.Common.ParallelBulkUtils Assembly HiGeom.dll Sequential bulk reader that provides efficient data access with caching capabilities. Unlike ParallelBulkReader<TData>, this reader processes data sequentially. public class SequentialBulkReader<TData> where TData : class Type Parameters TData The type of data to read. Inheritance object SequentialBulkReader<TData> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SequentialBulkReader(int, int, ReadBulkDelegate<TData>, Func<TData, int?>) Initializes a new instance of the SequentialBulkReader<TData> class. public SequentialBulkReader(int bulkListSize, int bulkSize, ReadBulkDelegate<TData> readBulkFunc, Func<TData, int?> getIndexFunc) Parameters bulkListSize int The number of bulk lists to maintain in the cache. bulkSize int The size of each bulk. readBulkFunc ReadBulkDelegate<TData> The function used to read bulk data. getIndexFunc Func<TData, int?> The function used to extract an index from a data item. Properties GetIndexFunc Gets the function used to extract an index from a data item. public Func<TData, int?> GetIndexFunc { get; } Property Value Func<TData, int?> Methods ClearCache() Clears all cached data. public void ClearCache() GetStep(int) Gets a data item at the specified step index, with automatic caching. public TData GetStep(int stepIndex) Parameters stepIndex int The index of the step to retrieve. Returns TData The data item at the specified index."
  },
  "api/Hi.Common.ParallelBulkUtils.html": {
    "href": "api/Hi.Common.ParallelBulkUtils.html",
    "title": "Namespace Hi.Common.ParallelBulkUtils | HiAPI-C# 2025",
    "summary": "Namespace Hi.Common.ParallelBulkUtils Classes ParallelBulkReader<TData> Parallel bulk reader that provides efficient data access with caching capabilities. Manages reading data in parallel with forward and backward caching to optimize performance. ParallelBulkWriter<TData> Parallel bulk writer that efficiently processes and writes data in parallel. The writing data is buffered and processed on a separate task to improve performance. SequentialBulkReader<TData> Sequential bulk reader that provides efficient data access with caching capabilities. Unlike ParallelBulkReader<TData>, this reader processes data sequentially. Delegates ReadBulkDelegate<TData> Delegate for reading a bulk of data from a specified range."
  },
  "api/Hi.Common.PathUtils.ExtendedNamedPath.html": {
    "href": "api/Hi.Common.PathUtils.ExtendedNamedPath.html",
    "title": "Class ExtendedNamedPath | HiAPI-C# 2025",
    "summary": "Class ExtendedNamedPath Namespace Hi.Common.PathUtils Assembly HiGeom.dll Represents a path with a named base path and an optional extended path component. public class ExtendedNamedPath : IEquatable<ExtendedNamedPath> Inheritance object ExtendedNamedPath Implements IEquatable<ExtendedNamedPath> Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ExtendedNamedPath() Initializes a new instance of the ExtendedNamedPath class. public ExtendedNamedPath() ExtendedNamedPath(ExtendedNamedPath) Copy constructor that performs a deep clone including the base named path. public ExtendedNamedPath(ExtendedNamedPath src) Parameters src ExtendedNamedPath The source ExtendedNamedPath to copy from ExtendedNamedPath(NamedPath) Initializes a new instance of the ExtendedNamedPath class with only a base path. public ExtendedNamedPath(NamedPath rootNamedPath) Parameters rootNamedPath NamedPath The base named path ExtendedNamedPath(NamedPath, string) Initializes a new instance of the ExtendedNamedPath class with a base path and extended path. public ExtendedNamedPath(NamedPath rootNamedPath, string extendedPath) Parameters rootNamedPath NamedPath The base named path extendedPath string The extended path component Properties BaseNamedPath Gets or sets the base named path component. public NamedPath BaseNamedPath { get; set; } Property Value NamedPath ExtendedPath Gets or sets the extended path component that is appended to the base path. A null value is acceptable. public string ExtendedPath { get; set; } Property Value string FullPath Gets the full path by combining the base path and extended path. public string FullPath { get; } Property Value string Remarks If the base path is null, returns the extended path or an empty string if that is also null. Methods Equals(ExtendedNamedPath) Indicates whether the current object is equal to another object of the same type. public bool Equals(ExtendedNamedPath other) Parameters other ExtendedNamedPath An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. GetName(StringLocalizer) Gets the display name of this path, optionally using a string localizer for the base path name. public string GetName(StringLocalizer loc = null) Parameters loc StringLocalizer Optional string localizer to translate the base path name Returns string The combined name of the base path and extended path, or the extended path alone if base path is null, or an empty string if both are null GetUriPara() Gets a URI parameter representation of this path for use in HTTP requests. public string GetUriPara() Returns string A string suitable for use as a URI parameter ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. Operators operator ==(ExtendedNamedPath, ExtendedNamedPath) public static bool operator ==(ExtendedNamedPath left, ExtendedNamedPath right) Parameters left ExtendedNamedPath right ExtendedNamedPath Returns bool operator !=(ExtendedNamedPath, ExtendedNamedPath) public static bool operator !=(ExtendedNamedPath left, ExtendedNamedPath right) Parameters left ExtendedNamedPath right ExtendedNamedPath Returns bool"
  },
  "api/Hi.Common.PathUtils.HttpUtil.html": {
    "href": "api/Hi.Common.PathUtils.HttpUtil.html",
    "title": "Class HttpUtil | HiAPI-C# 2025",
    "summary": "Class HttpUtil Namespace Hi.Common.PathUtils Assembly HiGeom.dll Utility class for HTTP operations such as URL validation and content retrieval. public static class HttpUtil Inheritance object HttpUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods ReadAllLinesFromUrl(string) Reads all lines from a URL's content. public static string[] ReadAllLinesFromUrl(string url) Parameters url string The URL to read from Returns string[] An array of strings containing the lines from the URL content, or an empty array if the request fails ReadAllLinesFromUrlAsync(string) Asynchronously reads all lines from a URL's content. public static Task<string[]> ReadAllLinesFromUrlAsync(string url) Parameters url string The URL to read from Returns Task<string[]> A task that represents the asynchronous operation. The task result contains an array of strings with the lines from the URL content, or an empty array if the request fails UrlExists(string) Checks if a URL exists by making a HEAD request. public static bool UrlExists(string url) Parameters url string The URL to check Returns bool True if the URL exists and returns a success status code; otherwise, false UrlExistsAsync(string) Asynchronously checks if a URL exists by making a HEAD request. public static Task<bool> UrlExistsAsync(string url) Parameters url string The URL to check Returns Task<bool> A task that represents the asynchronous operation. The task result contains true if the URL exists and returns a success status code; otherwise, false"
  },
  "api/Hi.Common.PathUtils.Lang.html": {
    "href": "api/Hi.Common.PathUtils.Lang.html",
    "title": "Class Lang | HiAPI-C# 2025",
    "summary": "Class Lang Namespace Hi.Common.PathUtils Assembly HiGeom.dll Provides language-related utilities for path handling. public class Lang Inheritance object Lang Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Common.PathUtils.NamedPath.html": {
    "href": "api/Hi.Common.PathUtils.NamedPath.html",
    "title": "Class NamedPath | HiAPI-C# 2025",
    "summary": "Class NamedPath Namespace Hi.Common.PathUtils Assembly HiGeom.dll Represents a file system path with an associated name or alias. public class NamedPath : IEquatable<NamedPath> Inheritance object NamedPath Implements IEquatable<NamedPath> Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NamedPath() Initializes a new instance of the NamedPath class. public NamedPath() NamedPath(NamedPath) Copy constructor that creates a new instance with the same name and path as the source. public NamedPath(NamedPath src) Parameters src NamedPath The source NamedPath to copy from NamedPath(string) Initializes a new instance of the NamedPath class with the specified name. public NamedPath(string name) Parameters name string The name or alias for the path NamedPath(string, string) Initializes a new instance of the NamedPath class with the specified name and path. public NamedPath(string name, string path) Parameters name string The name or alias for the path path string The file system path Properties Name Gets or sets the alias or display name for the path. A null value is acceptable. public string Name { get; set; } Property Value string Path Gets or sets the file system path. public string Path { get; set; } Property Value string Methods Equals(NamedPath) Indicates whether the current object is equal to another object of the same type. public bool Equals(NamedPath other) Parameters other NamedPath An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. Operators operator ==(NamedPath, NamedPath) public static bool operator ==(NamedPath left, NamedPath right) Parameters left NamedPath right NamedPath Returns bool operator !=(NamedPath, NamedPath) public static bool operator !=(NamedPath left, NamedPath right) Parameters left NamedPath right NamedPath Returns bool"
  },
  "api/Hi.Common.PathUtils.PathUtil.html": {
    "href": "api/Hi.Common.PathUtils.PathUtil.html",
    "title": "Class PathUtil | HiAPI-C# 2025",
    "summary": "Class PathUtil Namespace Hi.Common.PathUtils Assembly HiGeom.dll Utility class for path manipulation and management. public static class PathUtil Inheritance object PathUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields DotAlterWord Constant used to replace dots in HTTP string parameters. public const string DotAlterWord = \"-(dot)-\" Field Value string Methods Combine(string, string) Combines a base path with a subpath, ensuring consistent directory separators. public static string Combine(string basePath, string subPath) Parameters basePath string The base path subPath string The subpath to append Returns string The combined path with forward slashes as directory separators, or null if basePath is null Combine(params string[]) Combines multiple path segments, ensuring consistent directory separators. public static string Combine(params string[] paths) Parameters paths string[] The path segments to combine Returns string The combined path with forward slashes as directory separators GetDirectoryName(string) Gets the directory name of a path, ensuring consistent directory separators. public static string GetDirectoryName(string path) Parameters path string The path to get the directory name from Returns string The directory name with forward slashes as directory separators, or null if the path has no directory component GetFileDirectory(string, string) Gets the directory name from a combined base directory and relative file path. public static string GetFileDirectory(string baseDirectory, string relFile) Parameters baseDirectory string The base directory relFile string The relative file path Returns string The directory name of the combined path with forward slashes as directory separators GetParentDirectory(string) Gets the parent directory of a path, ignoring any trailing slashes. public static string GetParentDirectory(this string path) Parameters path string The path to get the parent of Returns string The parent directory path GetPathByTemplate(string, string, string, string) Generates a path by replacing keywords in a template path. public static string GetPathByTemplate(string templatePath, string replacingPath, string replacedPathKeyword, string replacedNameKeyword) Parameters templatePath string The template path containing keywords to be replaced replacingPath string The path to use as replacement replacedPathKeyword string The path keyword to be replaced in the template replacedNameKeyword string The name keyword to be replaced in the template Returns string The processed path with keywords replaced GetRelativePath(string, string) Gets the relative path from one path to another, ensuring consistent directory separators. public static string GetRelativePath(string relativeTo, string path) Parameters relativeTo string The path that is the reference point path string The path to which the relative path is calculated Returns string The relative path with forward slashes as directory separators GetRelativePathIfDescendant(string, string) Gets the relative path if the target path is a descendant of the reference path; otherwise, returns the original path. public static string GetRelativePathIfDescendant(string relativeTo, string path) Parameters relativeTo string The path that is the reference point path string The path to which the relative path is calculated Returns string The relative path if path is a descendant of relativeTo; otherwise, the original path. Forward slashes are used as directory separators in either case. GetResourceDirectory(string, string, string) Combines a base directory with a relative file path and appends a suffix to derive a sub-directory path. The suffix is only appended when relFile is not null or whitespace. public static string GetResourceDirectory(string baseDirectory, string relFile, string suffixIfAdded = \"-src\") Parameters baseDirectory string The base directory. relFile string The relative file path. suffixIfAdded string The suffix appended to the combined path when relFile is not null or whitespace. Returns string The combined sub-directory path with forward slashes as directory separators. IsDescendant(DirectoryInfo, string) Determines whether a path is a descendant of a specified directory. public static bool IsDescendant(this DirectoryInfo ascendentDirectory, string descendantPath) Parameters ascendentDirectory DirectoryInfo The potential ancestor directory descendantPath string The path to check Returns bool True if the path is a descendant of the directory; otherwise, false IsDescendant(string, string) Determines whether a path is a descendant of a specified directory. public static bool IsDescendant(string ascendentDirectory, string descendantPath) Parameters ascendentDirectory string The potential ancestor directory path descendantPath string The path to check Returns bool True if the path is a descendant of the directory; otherwise, false NormalizeToForwardSlash(string) Replaces backslashes with forward slashes in a path string. public static string NormalizeToForwardSlash(this string src) Parameters src string The source path string Returns string The path string with all backslashes replaced by forward slashes ResolveSubDirectory(string, string, string) Resolves the sub-directory for loading with legacy fallback. Returns the GetResourceDirectory(string, string, string) path if it exists; otherwise falls back to the legacy GetFileDirectory(string, string) path if it exists; otherwise defaults to the GetResourceDirectory(string, string, string) path. public static string ResolveSubDirectory(string baseDirectory, string relFile, string suffix = \"-src\") Parameters baseDirectory string The base directory. relFile string The relative file path. suffix string The suffix for the new sub-directory path. Returns string The resolved sub-directory path with forward slashes as directory separators. TrimTrailingSlash(string) Removes the trailing slash or backslash from a path if it exists. public static string TrimTrailingSlash(this string path) Parameters path string The path to process Returns string The path without a trailing slash or backslash"
  },
  "api/Hi.Common.PathUtils.html": {
    "href": "api/Hi.Common.PathUtils.html",
    "title": "Namespace Hi.Common.PathUtils | HiAPI-C# 2025",
    "summary": "Namespace Hi.Common.PathUtils Classes ExtendedNamedPath Represents a path with a named base path and an optional extended path component. HttpUtil Utility class for HTTP operations such as URL validation and content retrieval. Lang Provides language-related utilities for path handling. NamedPath Represents a file system path with an associated name or alias. PathUtil Utility class for path manipulation and management."
  },
  "api/Hi.Common.ProgressFraction.html": {
    "href": "api/Hi.Common.ProgressFraction.html",
    "title": "Class ProgressFraction | HiAPI-C# 2025",
    "summary": "Class ProgressFraction Namespace Hi.Common Assembly HiDisp.dll Represents a progress report implementation. Also exposes an IMessage view (explicitly implemented) so a progress fraction can ride the unified message channel uniformly alongside SimpleMessage / NcDiagnostic: Progress + System, with Msg as the notification and Detail as the detail payload. public class ProgressFraction : IProgressFraction, IMessage Inheritance object ProgressFraction Implements IProgressFraction IMessage Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ProgressFraction(NativeProgressFraction) Initializes a new instance of the ProgressFraction class from a native progress report. public ProgressFraction(NativeProgressFraction src) Parameters src NativeProgressFraction The native progress report source. Properties Denominator Gets or sets the denominator value for progress calculation. public int Denominator { get; set; } Property Value int Detail Gets or sets the detailed information about the progress. public string Detail { get; set; } Property Value string Msg Gets or sets the message string. public string Msg { get; set; } Property Value string Numerator Gets or sets the numerator value for progress calculation. public int Numerator { get; set; } Property Value int Methods GetDenominator() Gets the denominator value for progress calculation. public int GetDenominator() Returns int The denominator value. GetDetail() Gets the detailed information about the progress. public string GetDetail() Returns string The detail string. GetMsg() Get message. public string GetMsg() Returns string The message string. GetNumerator() Gets the numerator value for progress calculation. public int GetNumerator() Returns int The numerator value."
  },
  "api/Hi.Common.QueueCacheUtils.QueueCacher-1.html": {
    "href": "api/Hi.Common.QueueCacheUtils.QueueCacher-1.html",
    "title": "Class QueueCacher<TData> | HiAPI-C# 2025",
    "summary": "Class QueueCacher<TData> Namespace Hi.Common.QueueCacheUtils Assembly HiGeom.dll This cacher suits scattered IO with repeatity. public class QueueCacher<TData> where TData : class Type Parameters TData The type of data to cache Inheritance object QueueCacher<TData> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors QueueCacher(QueueCacherHost<TData>) Initializes a new instance of the QueueCacher class with the specified host. public QueueCacher(QueueCacherHost<TData> host) Parameters host QueueCacherHost<TData> The host that manages this cacher Properties Cache Gets the cached data, loading it if necessary and managing the cache queue. public TData Cache { get; } Property Value TData"
  },
  "api/Hi.Common.QueueCacheUtils.QueueCacherHost-1.html": {
    "href": "api/Hi.Common.QueueCacheUtils.QueueCacherHost-1.html",
    "title": "Class QueueCacherHost<TData> | HiAPI-C# 2025",
    "summary": "Class QueueCacherHost<TData> Namespace Hi.Common.QueueCacheUtils Assembly HiGeom.dll This cacher suits scattered IO with repeatity. public class QueueCacherHost<TData> where TData : class Type Parameters TData The type of data to cache Inheritance object QueueCacherHost<TData> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Capacity Gets or sets the maximum number of items to keep in the cache. public int Capacity { get; set; } Property Value int Provider Gets or sets the function that provides data when it's not in the cache. public Func<TData> Provider { get; set; } Property Value Func<TData> Methods Clear() Clears all items from the cache. public void Clear()"
  },
  "api/Hi.Common.QueueCacheUtils.html": {
    "href": "api/Hi.Common.QueueCacheUtils.html",
    "title": "Namespace Hi.Common.QueueCacheUtils | HiAPI-C# 2025",
    "summary": "Namespace Hi.Common.QueueCacheUtils Classes QueueCacherHost<TData> This cacher suits scattered IO with repeatity. QueueCacher<TData> This cacher suits scattered IO with repeatity."
  },
  "api/Hi.Common.Range-1.html": {
    "href": "api/Hi.Common.Range-1.html",
    "title": "Class Range<T> | HiAPI-C# 2025",
    "summary": "Class Range<T> Namespace Hi.Common Assembly HiGeom.dll Range from Min to Max. public class Range<T> : IEquatable<Range<T>> Type Parameters T Any Type Inheritance object Range<T> Implements IEquatable<Range<T>> Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Range() Initializes a new instance of the Range class. public Range() Range(T, T) Initializes a new instance of the Range class with specified minimum and maximum values. public Range(T min, T max) Parameters min T The minimum value max T The maximum value Fields max Max. public T max Field Value T min Min. public T min Field Value T Properties Max Property form of max. public T Max { get; set; } Property Value T Min Property form of min. public T Min { get; set; } Property Value T ReversePole Gets a range with reversed poles (positive infinity to negative infinity). public static Range<double> ReversePole { get; } Property Value Range<double> Methods AtIter(int) Get element by iteration index. public T AtIter(int iter) Parameters iter int iteration index Returns T ref element AtIterRef(int) Get element by iteration index. public ref T AtIterRef(int iter) Parameters iter int iteration index Returns T ref element Equals(Range<T>) Indicates whether the current object is equal to another object of the same type. public bool Equals(Range<T> other) Parameters other Range<T> An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. Expand(Range<double>, double) Expands the range to include the specified value if necessary. public static void Expand(Range<double> range, double v) Parameters range Range<double> The range to expand v double The value to include in the range GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Common.ResourceDefaultMarker.html": {
    "href": "api/Hi.Common.ResourceDefaultMarker.html",
    "title": "Class ResourceDefaultMarker | HiAPI-C# 2025",
    "summary": "Class ResourceDefaultMarker Namespace Hi.Common Assembly HiGeom.dll File-name convention that marks a shipped resource item as a system-owned default: a file carries the token before its final extension (AlTiBN.default.CoatingMaterial), a folder-shaped resource carries it as a folder-name suffix (MachineTool/Table-B1.default/) with the files inside left untouched. public static class ResourceDefaultMarker Inheritance object ResourceDefaultMarker Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Remarks Marked means system territory — the resource seeder may overwrite the item on version updates and delete marked items that are no longer shipped. Unmarked items belong to the user and are never touched. The marker is a declaration, not an enforcement: user edits to a marked file survive until the next shipped-version change overwrites them. Fields Token The marker token. Files embed it before the final extension; folders end with it. public const string Token = \".default\" Field Value string Methods IsMarkedFileName(string) Whether fileName carries the marker (contains .default.). public static bool IsMarkedFileName(string fileName) Parameters fileName string File name without directory. Returns bool IsMarkedFolderName(string) Whether folderName carries the marker (ends with .default). public static bool IsMarkedFolderName(string folderName) Parameters folderName string Folder name without directory. Returns bool StripFileName(string) Removes the marker from a marked file name (X.default.mp → X.mp); an unmarked name passes through. public static string StripFileName(string fileName) Parameters fileName string File name without directory. Returns string StripFolderName(string) Removes the marker from a marked folder name (CT-350.default → CT-350); an unmarked name passes through. public static string StripFolderName(string folderName) Parameters folderName string Folder name without directory. Returns string"
  },
  "api/Hi.Common.ResourceLayout.html": {
    "href": "api/Hi.Common.ResourceLayout.html",
    "title": "Class ResourceLayout | HiAPI-C# 2025",
    "summary": "Class ResourceLayout Namespace Hi.Common Assembly HiNc.dll Provides the relative folder paths that make up the shipped resource tree. public static class ResourceLayout Inheritance object ResourceLayout Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields CoatingMaterialFolder Gets the path to the coating material resource folder. public const string CoatingMaterialFolder = \"Resource/CoatingMaterial\" Field Value string ControllerFolder Gets the path to the CNC controller resource folder, holding the brand SoftNcRunner presets written by ControllerPresetWriter. public const string ControllerFolder = \"Resource/Controller\" Field Value string CutterFolder Gets the path to the cutter resource folder. public const string CutterFolder = \"Resource/Cutter\" Field Value string CuttingParameterFolder Gets the path to the cutting parameter resource folder. public const string CuttingParameterFolder = \"Resource/CuttingParameter\" Field Value string HolderFolder Gets the path to the holder resource folder. public const string HolderFolder = \"Resource/Holder\" Field Value string MachineToolFolder Gets the path to the machine tool resource folder. public const string MachineToolFolder = \"Resource/MachineTool\" Field Value string ResourceFolder Gets the path to the main resource folder. public const string ResourceFolder = \"Resource\" Field Value string SpindleCapabilityFolder Gets the path to the spindle capability resource folder. public const string SpindleCapabilityFolder = \"Resource/SpindleCapability\" Field Value string StructureMaterialFolder Gets the path to the structure material resource folder. public const string StructureMaterialFolder = \"Resource/StructureMaterial\" Field Value string WorkpieceMaterialFolder Gets the path to the workpiece material resource folder. public const string WorkpieceMaterialFolder = \"Resource/WorkpieceMaterial\" Field Value string"
  },
  "api/Hi.Common.ResourceUtil.html": {
    "href": "api/Hi.Common.ResourceUtil.html",
    "title": "Class ResourceUtil | HiAPI-C# 2025",
    "summary": "Class ResourceUtil Namespace Hi.Common Assembly HiGeom.dll Utility class for working with resource managers and localized strings, and the home of the attribute-declared command vocabulary: the CultureTextAttribute declarations of an assembly, exposed as “type/member + culture → text” queries and as ICommandTextSource instances, with GUI-layer overrides layered on top (SetTextOverride(string, string, string)). public static class ResourceUtil Inheritance object ResourceUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GenTextSource(CultureInfo, params Type[]) Generates an ICommandTextSource carrying culture, resolving keys against the CultureTextAttribute declarations of the vocabTypes' assemblies plus the registered overrides — the engine-default localizer a caller injects into title-composing commands. public static ICommandTextSource GenTextSource(CultureInfo culture, params Type[] vocabTypes) Parameters culture CultureInfo Culture the source carries; null takes the current UI culture. vocabTypes Type[] Types anchoring the assemblies whose declarations feed the source. Returns ICommandTextSource The text source. GetStringOrDefault(ResourceManager, string) get string by the name as key from resourceManager The default value is the name itself. public static string GetStringOrDefault(this ResourceManager resourceManager, string name) Parameters resourceManager ResourceManager name string Returns string GetStringOrDefault(ResourceManager, string, CultureInfo) get string by the name as key from resourceManager The default value is the name itself. public static string GetStringOrDefault(this ResourceManager resourceManager, string name, CultureInfo cultureInfo) Parameters resourceManager ResourceManager name string cultureInfo CultureInfo Returns string GetText(MemberInfo, CultureInfo) The text of member's vocabulary key in culture — the “type/member + culture → text” query. Resolution walks the culture's parent chain; on each level a registered override (SetTextOverride(string, string, string)) outranks the member assembly's CultureTextAttribute declaration. With no match the key itself — the English default — is returned. public static string GetText(MemberInfo member, CultureInfo culture) Parameters member MemberInfo The type or member owning the vocabulary key. culture CultureInfo Wanted culture; null takes the current UI culture. Returns string The culture's text, or the key itself. SetTextOverride(string, string, string) Registers a GUI-layer text for a vocabulary key in one culture. An override outranks the assembly's own CultureTextAttribute declaration in that culture, and may add a culture the assembly never declared. Process-level; typically called once at GUI startup. public static void SetTextOverride(string cultureName, string key, string text) Parameters cultureName string Culture name the text is written in (e.g. zh-Hant). key string Vocabulary key — the English default text. text string The overriding text; null removes the override."
  },
  "api/Hi.Common.RoutineBlocker.html": {
    "href": "api/Hi.Common.RoutineBlocker.html",
    "title": "Class RoutineBlocker | HiAPI-C# 2025",
    "summary": "Class RoutineBlocker Namespace Hi.Common Assembly HiGeom.dll Block the thread to the given delay from the previous block. public class RoutineBlocker : IMakeXmlSource, IDisposable Inheritance object RoutineBlocker Implements IMakeXmlSource IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) XmlUtil.MakeXmlSourceToFile(IMakeXmlSource, string, bool) XmlUtil.MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) XmlUtil.SaveToByteArrayAsync(IMakeXmlSource, string) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors RoutineBlocker() Constructor public RoutineBlocker() RoutineBlocker(TimeSpan) Initializes a new instance of the RoutineBlocker class with the specified period. public RoutineBlocker(TimeSpan period) Parameters period TimeSpan The time period between blocks RoutineBlocker(XElement) Initializes a new instance of the RoutineBlocker class from an XML element. public RoutineBlocker(XElement src) Parameters src XElement The XML element containing the blocker configuration Fields XName Gets the XML element name used for serialization. public static string XName Field Value string Properties Period Delay time between each previous Block(). public TimeSpan Period { get; set; } Property Value TimeSpan Methods Block() Delay the thread. The delay time is Period, counted from the previous Block() to the current Block(). The first function call does no delay. If the time between two Block() is over Period, the function call does no delay. public void Block() Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool HasToBlock() If calling Block() make thread delay, return true; otherwise, false. public bool HasToBlock() Returns bool Has to block IsEnabled() Enable the Block() function. public bool IsEnabled() Returns bool MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetDisable() Disables the blocker, canceling any pending operations. public void SetDisable() SetEnable(Action) Enable the Block() function. public void SetEnable(Action disablingCallback = null) Parameters disablingCallback Action"
  },
  "api/Hi.Common.SearchResult.html": {
    "href": "api/Hi.Common.SearchResult.html",
    "title": "Enum SearchResult | HiAPI-C# 2025",
    "summary": "Enum SearchResult Namespace Hi.Common Assembly HiGeom.dll Represents the result of a search operation. public enum SearchResult Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields CriticalFound = 2 Indicates that an exact match was found. FoundCeil = 8 Indicates that a value greater than to the target was found. FoundFloor = 4 Indicates that a value less than to the target was found. NotExisted = 1 Indicates that the target value does not exist in the collection."
  },
  "api/Hi.Common.SeqPair-1.html": {
    "href": "api/Hi.Common.SeqPair-1.html",
    "title": "Class SeqPair<T> | HiAPI-C# 2025",
    "summary": "Class SeqPair<T> Namespace Hi.Common Assembly HiGeom.dll Represents a sequence pair containing previous and current values. Used to track sequential state changes of a value. public class SeqPair<T> : IEquatable<SeqPair<T>>, IWriteBin Type Parameters T The type of values stored in the sequence pair Inheritance object SeqPair<T> Implements IEquatable<SeqPair<T>> IWriteBin Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods BinIoUtil.ToBytes(IWriteBin) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SeqPair() Initializes a new instance of the SeqPair<T> class with default values for previous and current elements. public SeqPair() SeqPair(BinaryReader, Func<BinaryReader, T>) Initializes a new instance of the SeqPair<T> class by deserializing from binary data. public SeqPair(BinaryReader reader, Func<BinaryReader, T> Generator) Parameters reader BinaryReader The binary reader to read data from Generator Func<BinaryReader, T> A function that creates objects of type T from binary data SeqPair(T, T) Initializes a new instance of the SeqPair<T> class with specified previous and current values. public SeqPair(T pre, T cur) Parameters pre T The previous value in the sequence cur T The current value in the sequence Fields cur Gets or sets the current value in the sequence. public T cur Field Value T pre Gets or sets the previous value in the sequence. public T pre Field Value T Methods Equals(SeqPair<T>) Indicates whether the current object is equal to another object of the same type. public bool Equals(SeqPair<T> other) Parameters other SeqPair<T> An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. WriteBin(BinaryWriter) Writes the object's data to a binary stream. public void WriteBin(BinaryWriter writer) Parameters writer BinaryWriter The binary writer to write to"
  },
  "api/Hi.Common.SeqPairUtil.html": {
    "href": "api/Hi.Common.SeqPairUtil.html",
    "title": "Class SeqPairUtil | HiAPI-C# 2025",
    "summary": "Class SeqPairUtil Namespace Hi.Common Assembly HiGeom.dll Utility class for SeqPair operations. public static class SeqPairUtil Inheritance object SeqPairUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods Delta<T>(SeqPair<T>) Calculates the difference between current and previous values in a sequence pair. public static T Delta<T>(this SeqPair<T> seq) where T : ISubtractionOperators<T, T, T> Parameters seq SeqPair<T> The sequence pair to calculate delta for Returns T The difference between current and previous values Type Parameters T Type that supports subtraction operations"
  },
  "api/Hi.Common.ServerFileExplorerConfig.html": {
    "href": "api/Hi.Common.ServerFileExplorerConfig.html",
    "title": "Class ServerFileExplorerConfig | HiAPI-C# 2025",
    "summary": "Class ServerFileExplorerConfig Namespace Hi.Common Assembly HiGeom.dll Configuration for server file explorer functionality. public class ServerFileExplorerConfig : IEquatable<ServerFileExplorerConfig> Inheritance object ServerFileExplorerConfig Implements IEquatable<ServerFileExplorerConfig> Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ServerFileExplorerConfig() Initializes a new instance of the ServerFileExplorerConfig class. public ServerFileExplorerConfig() ServerFileExplorerConfig(ServerFileExplorerConfig) Initializes a new instance of the ServerFileExplorerConfig class by copying another instance. public ServerFileExplorerConfig(ServerFileExplorerConfig src) Parameters src ServerFileExplorerConfig The source configuration to copy from Properties ApplyingPostfix Path Postfix for applying to the selected file path. public string ApplyingPostfix { get; set; } Property Value string DefaultFilterTitle Gets or sets the default filter title to use when no filter is selected. public string DefaultFilterTitle { get; set; } Property Value string ExtendedNamedPath Gets or sets the extended named path for the file explorer. public ExtendedNamedPath ExtendedNamedPath { get; set; } Property Value ExtendedNamedPath ExtendedNamedPathList Gets or sets the list of extended named paths available in the file explorer. public List<ExtendedNamedPath> ExtendedNamedPathList { get; set; } Property Value List<ExtendedNamedPath> ExtensionFilterList Gets or sets the list of file extension filters available in the file explorer. public List<(string FilterTitle, string FileExtension)> ExtensionFilterList { get; set; } Property Value List<(string FilterTitle, string FileExtension)> RelativeDirectory Gets or sets the relative directory path for the file explorer. public string RelativeDirectory { get; set; } Property Value string SelectedFileName Gets or sets the currently selected file name. public string SelectedFileName { get; set; } Property Value string Title Gets or sets the title of the file explorer. public string Title { get; set; } Property Value string Methods Equals(ServerFileExplorerConfig) Indicates whether the current object is equal to another object of the same type. public bool Equals(ServerFileExplorerConfig other) Parameters other ServerFileExplorerConfig An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. Set(ServerFileExplorerConfig) Copy values from src. public ServerFileExplorerConfig Set(ServerFileExplorerConfig src) Parameters src ServerFileExplorerConfig src Returns ServerFileExplorerConfig this Operators operator ==(ServerFileExplorerConfig, ServerFileExplorerConfig) public static bool operator ==(ServerFileExplorerConfig left, ServerFileExplorerConfig right) Parameters left ServerFileExplorerConfig right ServerFileExplorerConfig Returns bool operator !=(ServerFileExplorerConfig, ServerFileExplorerConfig) public static bool operator !=(ServerFileExplorerConfig left, ServerFileExplorerConfig right) Parameters left ServerFileExplorerConfig right ServerFileExplorerConfig Returns bool"
  },
  "api/Hi.Common.StringLocalizer.html": {
    "href": "api/Hi.Common.StringLocalizer.html",
    "title": "Class StringLocalizer | HiAPI-C# 2025",
    "summary": "Class StringLocalizer Namespace Hi.Common Assembly HiGeom.dll Provides localization functionality for strings using resource managers. public class StringLocalizer Inheritance object StringLocalizer Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors StringLocalizer(params Type[]) Initializes a new instance of the StringLocalizer class with the specified types. public StringLocalizer(params Type[] types) Parameters types Type[] The types containing resources to be used for localization. Properties ExtendedTypeList Gets a list of extended types that will be used for localization in addition to the primary types. public static List<Type> ExtendedTypeList { get; } Property Value List<Type> this[string] Gets the localized string for the specified key. public string this[string key] { get; } Parameters key string The key to look up in the resource managers. Property Value string The localized string if found; otherwise, the key itself."
  },
  "api/Hi.Common.StringUtil.html": {
    "href": "api/Hi.Common.StringUtil.html",
    "title": "Class StringUtil | HiAPI-C# 2025",
    "summary": "Class StringUtil Namespace Hi.Common Assembly HiGeom.dll Utility for managing text. public static class StringUtil Inheritance object StringUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods ExtractFullFunctionCall(string, string, out string, int) Extracts a complete function call from a string, including the function name and all parameters. public static int ExtractFullFunctionCall(string input, string functionName, out string funcCall, int beginSearchIndex = 0) Parameters input string The input string to search in. functionName string The name of the function to find. funcCall string When this method returns, contains the extracted function call if found; otherwise, null. beginSearchIndex int The index in the input string to begin the search. Returns int The starting index of the function call if found; otherwise, -1. ExtractFunctionArguments(string, string) Extracts the arguments of a function call from a string. public static string ExtractFunctionArguments(string input, string functionName) Parameters input string The input string containing the function call. functionName string The name of the function whose arguments to extract. Returns string The arguments string if the function call is found; otherwise, null. GetPropertyStringIfToStringNotOverloaded(object, bool, bool) Create string by properties. public static string GetPropertyStringIfToStringNotOverloaded(this object src, bool changeLine = false, bool includeNonPublic = false) Parameters src object src changeLine bool change line includeNonPublic bool include non-public properties Returns string string RemoveWhiteSpaceLines(string) Removes lines that contain only whitespace characters from the input string. public static string RemoveWhiteSpaceLines(this string text) Parameters text string The input string to process. Returns string A new string with whitespace-only lines removed. ToDotSplitedString<T>(IEnumerable<T>) Converts a collection of objects to a comma-separated string. public static string ToDotSplitedString<T>(this IEnumerable<T> objects) Parameters objects IEnumerable<T> The collection of objects to convert. Returns string A comma-separated string representation of the objects. Type Parameters T ToUtf8NullTerminatedBytes(string) Converts a string to a null-terminated UTF-8 byte array for P/Invoke. public static byte[] ToUtf8NullTerminatedBytes(this string str) Parameters str string Returns byte[]"
  },
  "api/Hi.Common.TaskUtil.html": {
    "href": "api/Hi.Common.TaskUtil.html",
    "title": "Class TaskUtil | HiAPI-C# 2025",
    "summary": "Class TaskUtil Namespace Hi.Common Assembly HiGeom.dll Utility class for Task-related operations. public static class TaskUtil Inheritance object TaskUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GenTask<TArg>(Action<TArg>, TArg) Generates a new Task that will execute the specified function with the given argument. public static Task GenTask<TArg>(Action<TArg> func, TArg arg) Parameters func Action<TArg> The function to execute arg TArg The argument to pass to the function Returns Task A new Task Type Parameters TArg The type of the argument GenTask<TArg>(Action<TArg>, TArg, CancellationToken) Generates a new Task that will execute the specified function with the given argument and cancellation token. public static Task GenTask<TArg>(Action<TArg> func, TArg arg, CancellationToken cancellationToken) Parameters func Action<TArg> The function to execute arg TArg The argument to pass to the function cancellationToken CancellationToken The cancellation token Returns Task A new Task Type Parameters TArg The type of the argument GenTask<TArg, TResult>(Func<TArg, TResult>, TArg) Generates a new Task that will execute the specified function with the given argument and return a result. public static Task<TResult> GenTask<TArg, TResult>(Func<TArg, TResult> func, TArg arg) Parameters func Func<TArg, TResult> The function to execute arg TArg The argument to pass to the function Returns Task<TResult> A new Task with a result Type Parameters TArg The type of the argument TResult The type of the result GenTask<TArg, TResult>(Func<TArg, TResult>, TArg, CancellationToken) Generates a new Task that will execute the specified function with the given argument and cancellation token, and return a result. public static Task<TResult> GenTask<TArg, TResult>(Func<TArg, TResult> func, TArg arg, CancellationToken cancellationToken) Parameters func Func<TArg, TResult> The function to execute arg TArg The argument to pass to the function cancellationToken CancellationToken The cancellation token Returns Task<TResult> A new Task with a result Type Parameters TArg The type of the argument TResult The type of the result GetTaskAwaiterResult(ValueTask) Gets the result of a ValueTask by converting it to a Task and getting its awaiter result. public static void GetTaskAwaiterResult(this ValueTask valueTask) Parameters valueTask ValueTask The ValueTask GetTaskAwaiterResult<TResult>(ValueTask<TResult>) Gets the result of a ValueTask with a result by converting it to a Task and getting its awaiter result. public static TResult GetTaskAwaiterResult<TResult>(this ValueTask<TResult> valueTask) Parameters valueTask ValueTask<TResult> The ValueTask with a result Returns TResult The result of the ValueTask Type Parameters TResult The type of the result"
  },
  "api/Hi.Common.TimeCounter.html": {
    "href": "api/Hi.Common.TimeCounter.html",
    "title": "Class TimeCounter | HiAPI-C# 2025",
    "summary": "Class TimeCounter Namespace Hi.Common Assembly HiGeom.dll A utility counts the average/total time consume between the Bound(object) areas. The count of time consume for the given key starts at the first time (and the odd time) calling Bound(object); stops and accumulates at the second time (and the even time). public static class TimeCounter Inheritance object TimeCounter Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods Bound(object) Marks a boundary for time measurement for the specified key. public static void Bound(object key) Parameters key object The key that identifies this particular measurement. Remarks This method alternates between starting and stopping time measurement: First call with a key: Starts the timer Second call with the same key: Stops the timer and records the elapsed time Third call: Starts the timer again And so on… The elapsed time is accumulated and the count is incremented each time a measurement completes. Pass(object) Cancels an active time measurement for the specified key without recording the elapsed time. public static void Pass(object key) Parameters key object The key that identifies the measurement to cancel. Remarks If timing has not been started for the specified key, this method has no effect. This is useful for aborting a measurement without affecting statistics. Reset() Resets all time measurements by clearing all accumulated statistics and counters. public static void Reset() Show() Displays all accumulated time measurements to the console. public static void Show() Remarks For each key, this method outputs: The count of measurements The total accumulated time The average time per measurement The key identifier ShowExt(int) Displays time measurements and resets counters periodically based on call frequency. public static void ShowExt(int gap) Parameters gap int The number of calls to this method before showing results and resetting. Remarks This method increments an internal counter with each call. When the counter reaches the specified gap value, it: Displays all measurements (calls Show()) Resets all counters (calls Reset()) Resets the internal counter to zero This is useful for periodic reporting during long-running operations."
  },
  "api/Hi.Common.XmlUtils.FileRefSource-1.html": {
    "href": "api/Hi.Common.XmlUtils.FileRefSource-1.html",
    "title": "Class FileRefSource<T> | HiAPI-C# 2025",
    "summary": "Class FileRefSource<T> Namespace Hi.Common.XmlUtils Assembly HiGeom.dll A class that combines an XML-serializable data object with its source file path. public class FileRefSource<T> : ISourceFile where T : class, IMakeXmlSource Type Parameters T The type of data object that can be serialized to XML Inheritance object FileRefSource<T> Implements ISourceFile Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FileRefSource() Initializes a new instance of the XmlSource class. public FileRefSource() FileRefSource(string, T) Initializes a new instance of the XmlSource class with data and optional file path. public FileRefSource(string file, T data) Parameters file string Optional path to the XML source file data T The data object to store Properties Data Gets or sets the main data object being stored. public T Data { get; set; } Property Value T SourceFile Gets or sets the path to the source file. public string SourceFile { get; set; } Property Value string Methods MakeXmlSourceToFileRef(string) Creates an XML representation of the data object with the file path rebased to the specified directory. public XElement MakeXmlSourceToFileRef(string baseDirectory) Parameters baseDirectory string The base directory for resolving relative paths Returns XElement An XML element representing the data object's state Set(FileRefSource<T>) Copies data from another XmlSource instance. public void Set(FileRefSource<T> src) Parameters src FileRefSource<T> The source XmlSource to copy from"
  },
  "api/Hi.Common.XmlUtils.IMakeXmlSource.html": {
    "href": "api/Hi.Common.XmlUtils.IMakeXmlSource.html",
    "title": "Interface IMakeXmlSource | HiAPI-C# 2025",
    "summary": "Interface IMakeXmlSource Namespace Hi.Common.XmlUtils Assembly HiGeom.dll Interface for objects that can be serialized to XML format. public interface IMakeXmlSource Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) XmlUtil.MakeXmlSourceToFile(IMakeXmlSource, string, bool) XmlUtil.MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) XmlUtil.SaveToByteArrayAsync(IMakeXmlSource, string) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file."
  },
  "api/Hi.Common.XmlUtils.IToXElement.html": {
    "href": "api/Hi.Common.XmlUtils.IToXElement.html",
    "title": "Interface IToXElement | HiAPI-C# 2025",
    "summary": "Interface IToXElement Namespace Hi.Common.XmlUtils Assembly HiGeom.dll Interface of ToXElement(). Which can be represented by a single XElement. public interface IToXElement Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks Relative to IMakeXmlSource, the IToXElement don't export file. So no directory information is required. A single XElement represent the object. Methods ToXElement() Get the XElement to represent the object. XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.Common.XmlUtils.ProjectApiVersion.html": {
    "href": "api/Hi.Common.XmlUtils.ProjectApiVersion.html",
    "title": "Class ProjectApiVersion | HiAPI-C# 2025",
    "summary": "Class ProjectApiVersion Namespace Hi.Common.XmlUtils Assembly HiGeom.dll Carries the API version read from a project file's XML attribute through the XFactory deserialization pipeline via the object[] res parameter. Consumers retrieve it with res?.OfType<ProjectApiVersion>().FirstOrDefault(). public class ProjectApiVersion Inheritance object ProjectApiVersion Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ProjectApiVersion(Version) Initializes a new instance carrying the specified version. public ProjectApiVersion(Version version) Parameters version Version API version read from the project XML; may be null when the source file did not record a version. Properties Version API version stamped on the source project file at save time. public Version Version { get; } Property Value Version Methods IsOlderThan(Version) Returns true if the source file was saved by an API version older than version. Returns false when the source version is unknown (null) — without the explicit guard, Version's comparison operator ranks a null left operand as OLDEST and every legacy patch would fire on an unversioned file, contradicting this contract that version-gated upgrades rely on. A reader that wants “no stamp anywhere” to mean “older than every gate” says so by constructing a carrier with an explicit floor version (e.g. 0.0) rather than a null one. public bool IsOlderThan(Version version) Parameters version Version Returns bool"
  },
  "api/Hi.Common.XmlUtils.SetFileDelegate.html": {
    "href": "api/Hi.Common.XmlUtils.SetFileDelegate.html",
    "title": "Delegate SetFileDelegate | HiAPI-C# 2025",
    "summary": "Delegate SetFileDelegate Namespace Hi.Common.XmlUtils Assembly HiGeom.dll Delegate for setting the file path during XML operations. public delegate void SetFileDelegate(string file) Parameters file string The file path to set Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Common.XmlUtils.XFactory.XGeneratorDelegate.html": {
    "href": "api/Hi.Common.XmlUtils.XFactory.XGeneratorDelegate.html",
    "title": "Delegate XFactory.XGeneratorDelegate | HiAPI-C# 2025",
    "summary": "Delegate XFactory.XGeneratorDelegate Namespace Hi.Common.XmlUtils Assembly HiGeom.dll Delegate for generating an object from an XML element with relative file path context. public delegate object XFactory.XGeneratorDelegate(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress, object[] res) Parameters src XElement The source XML element. baseDirectory string The base directory for resolving paths. relFile string The relative file path. progress IProgress<IMessage> Progress reporter for the XML parsing chain. res object[] Additional parameters for generation. Returns object The generated object. Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks Separating baseDirectory and relFile keeps data packages relocatable: moving the whole base directory only requires updating the directory string, not every internal path."
  },
  "api/Hi.Common.XmlUtils.XFactory.XmlExceptionDelegate.html": {
    "href": "api/Hi.Common.XmlUtils.XFactory.XmlExceptionDelegate.html",
    "title": "Delegate XFactory.XmlExceptionDelegate | HiAPI-C# 2025",
    "summary": "Delegate XFactory.XmlExceptionDelegate Namespace Hi.Common.XmlUtils Assembly HiGeom.dll Delegate for handling XML exceptions during generation. public delegate void XFactory.XmlExceptionDelegate(string relPath, Exception exception) Parameters relPath string The relative path where the exception occurred. exception Exception The exception that was thrown. Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Common.XmlUtils.XFactory.html": {
    "href": "api/Hi.Common.XmlUtils.XFactory.html",
    "title": "Class XFactory | HiAPI-C# 2025",
    "summary": "Class XFactory Namespace Hi.Common.XmlUtils Assembly HiGeom.dll Factory for generating objects from XML elements using registered generator functions. public class XFactory Inheritance object XFactory Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks Each XFactory instance owns its own Generators registry. A process-wide Default singleton serves the common case (single shared factory across the simulation pipeline); other instances can be created for test isolation or parallel pipelines that need disjoint registries. Types that participate in XML round-trip expose a public static void Reg(XFactory factory = null) method that adds themselves (and chains Reg(factory) on dependents) to the given factory's Generators. Boot roots (e.g. LocalProjectService.Reg()) call the top-level Reg() once at startup with the default factory. The static Gen<T> / GenByChild<T> / GenByFile<T> entry points always read from Default. Callers that need to deserialize from a custom factory's registry must look up the delegate via factory.Generators[xname] directly. Properties Default Process-wide default factory used by the static Gen<T> family. Reg-style methods register here when called with no explicit factory argument. public static XFactory Default { get; } Property Value XFactory Generators XML-name → generator-function map for this factory instance. Populated by each type's Reg(this) call. Concurrent so that parallel Reg calls (e.g. independent test classes each booting the registration graph) can TryAdd without corrupting the map. public ConcurrentDictionary<string, XFactory.XGeneratorDelegate> Generators { get; } Property Value ConcurrentDictionary<string, XFactory.XGeneratorDelegate> Methods GenByChild<T>(XElement, string, IProgress<IMessage>, bool, object[]) Generates an object of type T from the first child element (discards relative file path). public static T GenByChild<T>(XElement src, string baseDirectory, IProgress<IMessage> progress, bool enableRebase = true, object[] res = null) where T : class Parameters src XElement baseDirectory string progress IProgress<IMessage> enableRebase bool res object[] Returns T Type Parameters T GenByChild<T>(XElement, string, out string, IProgress<IMessage>, bool, object[]) Generates an object of type T from the first child element of the provided XML element. public static T GenByChild<T>(XElement src, string baseDirectory, out string relFile, IProgress<IMessage> progress, bool enableRebase = true, object[] res = null) where T : class Parameters src XElement baseDirectory string relFile string progress IProgress<IMessage> enableRebase bool res object[] Returns T Type Parameters T GenByFile<T>(string, string, IProgress<IMessage>, bool, object[]) Generates an object of type T from an XML file. public static T GenByFile<T>(string baseDirectory, string relFile, IProgress<IMessage> progress, bool enableRebase = true, object[] res = null) where T : class Parameters baseDirectory string relFile string progress IProgress<IMessage> enableRebase bool res object[] Returns T Type Parameters T GenFileRefSourceByChild<T>(XElement, string, IProgress<IMessage>, bool, object[]) Generates a FileRefSource<T> from the first child element. public static FileRefSource<T> GenFileRefSourceByChild<T>(XElement src, string baseDirectory, IProgress<IMessage> progress, bool enableRebase = true, object[] res = null) where T : class, IMakeXmlSource Parameters src XElement baseDirectory string progress IProgress<IMessage> enableRebase bool res object[] Returns FileRefSource<T> Type Parameters T GenFileRefSourceByFile<T>(string, string, IProgress<IMessage>, bool, object[]) Generates a FileRefSource<T> from an XML file. public static FileRefSource<T> GenFileRefSourceByFile<T>(string baseDirectory, string relFile, IProgress<IMessage> progress, bool enableRebase = true, object[] res = null) where T : class, IMakeXmlSource Parameters baseDirectory string relFile string progress IProgress<IMessage> enableRebase bool res object[] Returns FileRefSource<T> Type Parameters T GenFileRefSource<T>(XElement, string, IProgress<IMessage>, bool, object[]) Generates a FileRefSource<T> from an XML element. public static FileRefSource<T> GenFileRefSource<T>(XElement src, string baseDirectory, IProgress<IMessage> progress, bool enableRebase = true, object[] res = null) where T : class, IMakeXmlSource Parameters src XElement baseDirectory string progress IProgress<IMessage> enableRebase bool res object[] Returns FileRefSource<T> Type Parameters T GenListSkippingUnloadable<T>(IEnumerable<XElement>, string, IProgress<IMessage>, bool, object[]) Deserializes each element of elements into a T, skipping — instead of throwing on — any element whose XName is not registered (e.g. a renamed or removed component) or whose generator throws. Each skipped element is reported to progress as a Warning. Use when a partially-loadable list (such as a saved pipeline whose schema has drifted while a feature is in development) is preferable to aborting the whole load. public static List<T> GenListSkippingUnloadable<T>(IEnumerable<XElement> elements, string baseDirectory, IProgress<IMessage> progress, bool enableRebase = true, object[] res = null) where T : class Parameters elements IEnumerable<XElement> baseDirectory string progress IProgress<IMessage> enableRebase bool res object[] Returns List<T> Type Parameters T Gen<T>(XElement, string, IProgress<IMessage>, bool, object[]) Generates an object of type T from an XML element (discards relative file path). public static T Gen<T>(XElement src, string baseDirectory, IProgress<IMessage> progress, bool enableRebase = true, object[] res = null) where T : class Parameters src XElement baseDirectory string progress IProgress<IMessage> enableRebase bool res object[] Returns T Type Parameters T Gen<T>(XElement, string, out string, IProgress<IMessage>, bool, object[]) Generates an object of type T from an XML element using Default. public static T Gen<T>(XElement src, string baseDirectory, out string relFile, IProgress<IMessage> progress, bool enableRebase = true, object[] res = null) where T : class Parameters src XElement baseDirectory string relFile string progress IProgress<IMessage> enableRebase bool res object[] Returns T Type Parameters T"
  },
  "api/Hi.Common.XmlUtils.XmlUtil.html": {
    "href": "api/Hi.Common.XmlUtils.XmlUtil.html",
    "title": "Class XmlUtil | HiAPI-C# 2025",
    "summary": "Class XmlUtil Namespace Hi.Common.XmlUtils Assembly HiGeom.dll Utility for managing XML. public static class XmlUtil Inheritance object XmlUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields SelfHostName Constant representing self-hosted XML content. Used for legacy compatibility. public const string SelfHostName = \"SelfHost\" Field Value string XmlFileXName The XML element name used for file references. public const string XmlFileXName = \"XmlSource\" Field Value string Methods GetDictionaryByXmlSource<T>(XElement, string, IProgress<IMessage>, bool) Deserializes a dictionary of objects from an XML element. public static Dictionary<string, T> GetDictionaryByXmlSource<T>(this XElement src, string baseDirectory, IProgress<IMessage> progress, bool enableRebase = true) where T : class Parameters src XElement The source XML element containing the serialized dictionary baseDirectory string The base directory for resolving paths progress IProgress<IMessage> Optional progress reporter for the XML parsing chain enableRebase bool Whether to rebase the directory to the file's location Returns Dictionary<string, T> A dictionary containing the deserialized objects Type Parameters T The type of objects to deserialize into the dictionary GetFirstChildElement(XElement) Gets the first child element of the source XElement. public static XElement GetFirstChildElement(this XElement src) Parameters src XElement The source XElement Returns XElement The first child element, or null if no children exist GetNameNoteXElementList(INameNote) Creates a list of XML elements representing the name and note properties of an INameNote object. public static List<XElement> GetNameNoteXElementList(this INameNote src) Parameters src INameNote The source INameNote object Returns List<XElement> A list of XML elements containing the name and note GetOrDefault<T>(XElement, string, T) If xpath exist, return value by xpath ; Otherwise, return defaultValue. The xpath must indicates solely one XElement. public static T GetOrDefault<T>(this XElement src, string xpath, T defaultValue) where T : IConvertible Parameters src XElement local root element xpath string xpath defaultValue T default value Returns T If xpath exist, return value by xpath ; Otherwise, return defaultValue. Type Parameters T type of defaultValue LoadFromFileRef(XElement, string, out string) Unwraps a file reference XML element to load its actual content. public static XElement LoadFromFileRef(this XElement src, string baseDirectory, out string relFile) Parameters src XElement The source XML element that may be a file reference baseDirectory string The base directory for resolving paths relFile string Output parameter that receives the relative file path if src is a file reference, or null otherwise Returns XElement If src is a file reference element, returns the XML content loaded from the referenced file; otherwise, returns the original element LoadWithFileRefSupport(XElement, string, SetFileDelegate) Unwraps an XML element if it contains a file reference element. public static XElement LoadWithFileRefSupport(this XElement src, string baseDirectory, SetFileDelegate setFileAction) Parameters src XElement The source XML element that may contain a file reference baseDirectory string The base directory for resolving paths setFileAction SetFileDelegate Action to execute with the file path, or null if no file reference is found Returns XElement If the source element contains a file reference, returns the XML content loaded from the referenced file; otherwise, returns the original element MakeXmlSourceToFile(IMakeXmlSource, string, bool) Creates an XML source file from the provided source at the specified file path. public static void MakeXmlSourceToFile(this IMakeXmlSource src, string filePath, bool exhibitionOnly = false) Parameters src IMakeXmlSource The source that implements IMakeXmlSource interface. filePath string The path where the XML file will be created. exhibitionOnly bool See MakeXmlSource(string, string, bool) for parameter description. MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) Creates an XML representation of an object and optionally saves it to a file with path rebasing. public static XElement MakeXmlSourceToFileRef(this IMakeXmlSource src, string baseDirectory, string relFile, bool exhibitionOnly) Parameters src IMakeXmlSource The source object to serialize baseDirectory string The base directory for resolving paths relFile string The relative file path to save the XML to, or null to not save to a file exhibitionOnly bool See MakeXmlSource(string, string, bool) for parameter description. Returns XElement If relFile is null or empty, returns the XML representation of the object; otherwise, saves the XML to the specified file and returns a file reference element MakeXmlSource<T>(IDictionary<string, T>, string, bool) Creates an XML representation of a dictionary of XML-serializable objects. public static XElement MakeXmlSource<T>(this IDictionary<string, T> dictionary, string baseDirectory, bool exhibitionOnly) where T : IMakeXmlSource Parameters dictionary IDictionary<string, T> The dictionary to serialize baseDirectory string The base directory for resolving paths exhibitionOnly bool See MakeXmlSource(string, string, bool) for parameter description. Returns XElement An XML element containing the serialized dictionary Type Parameters T The type of objects in the dictionary, must implement IMakeXmlSource SaveToByteArrayAsync(IMakeXmlSource, string) Asynchronously saves an XML source to a byte array. public static Task<byte[]> SaveToByteArrayAsync(this IMakeXmlSource src, string baseDirectory) Parameters src IMakeXmlSource The XML source to save baseDirectory string The base directory for resolving paths Returns Task<byte[]> A byte array containing the serialized XML data SaveToFileRef(XElement, string, string, bool) Wraps an XML element in a file reference element or returns it as-is. public static XElement SaveToFileRef(this XElement src, string baseDirectory, string sourceFile, bool exhibitionOnly) Parameters src XElement The source XML element to wrap baseDirectory string The base directory for resolving paths sourceFile string The relative file path to save the element to, or null to return the element as-is exhibitionOnly bool See MakeXmlSource(string, string, bool) for parameter description. Returns XElement If sourceFile is null, returns the original element; otherwise, saves the element to the specified file and returns a file reference element SetNameNote(INameNote, XElement) Sets the name and note properties of an INameNote object from an XML element. public static void SetNameNote(this INameNote dst, XElement src) Parameters dst INameNote The destination INameNote object to update src XElement The source XML element containing the name and note values SetOrGenerate<T>(XElement, string, T, string) Sets a value at the specified XPath, creating the path if it doesn't exist. public static void SetOrGenerate<T>(this XElement src, string xpath, T value, string comment = null) where T : IConvertible Parameters src XElement The source XElement xpath string The XPath to set the value at value T The value to set comment string Optional comment to add above the element Type Parameters T The type of value to set"
  },
  "api/Hi.Common.XmlUtils.html": {
    "href": "api/Hi.Common.XmlUtils.html",
    "title": "Namespace Hi.Common.XmlUtils | HiAPI-C# 2025",
    "summary": "Namespace Hi.Common.XmlUtils Classes FileRefSource<T> A class that combines an XML-serializable data object with its source file path. ProjectApiVersion Carries the API version read from a project file's XML attribute through the XFactory deserialization pipeline via the object[] res parameter. Consumers retrieve it with res?.OfType<ProjectApiVersion>().FirstOrDefault(). XFactory Factory for generating objects from XML elements using registered generator functions. XmlUtil Utility for managing XML. Interfaces IMakeXmlSource Interface for objects that can be serialized to XML format. IToXElement Interface of ToXElement(). Which can be represented by a single XElement. Delegates SetFileDelegate Delegate for setting the file path during XML operations. XFactory.XGeneratorDelegate Delegate for generating an object from an XML element with relative file path context. XFactory.XmlExceptionDelegate Delegate for handling XML exceptions during generation."
  },
  "api/Hi.Common.html": {
    "href": "api/Hi.Common.html",
    "title": "Namespace Hi.Common | HiAPI-C# 2025",
    "summary": "Namespace Hi.Common Classes BinIoUtil Utility class for binary I/O operations. BitUtil Utility for bit control for integer. BlockingTimer Timer use one task and delay each event call. The delay time is Period, counted from the previous trigger to the nest trigger. The first function call does no intending delay. If the execution time is over the Period, no delay between the triggers. BytesUtil Utility class for byte array operations and memory size conversions. ConcurrentTimeCounter Thread-safe utility for measuring and tracking execution time across multiple tasks. ConsoleUtil Utility class for console window operations. CppLogUtil Internal Use Only. CultureTextAttribute Declares one culture's text for one vocabulary key on the member carrying the attribute — the static wording of command titles and labels, owned by the declaring library as a DEFAULT: a GUI layer may override it or add cultures the library never declared (see SetTextOverride(string, string, string)), and a culture left undeclared is not an error — lookups fall back toward the English key. The key defaults to the member's own display name: its DisplayNameAttribute value when present, otherwise the member name spaced into words (SpacePascalWords(string)). Set Key to declare a word the member does not itself name (a shared switch word, a mode label). Apply the attribute once per culture. CultureUtil The English culture the engine formats and parses with, and the one call that pins a thread to it. DuplicateUtil Utility methods for duplication operations. EnumUtil Utility class for enum operations. EnumerablePlayer Run enumerable with Pause(), Resume() and etc. functions. IndexSegment Represents a segment of indices with a beginning (inclusive) and ending (exclusive> point. Used for defining segment of data in collections or arrays. IntegerKeyDictionaryConverter Converts dictionaries with string keys to dictionaries with integer keys for more efficient storage and lookup. IntegerKeyDictionaryConverter<TValue> Generic version of IntegerKeyDictionaryConverter that works with a specific value type. InternalException Exception that represents an internal error that should never occur during normal operation. Used to indicate programming errors or unexpected states that require developer attention. InvokeUtil Utility class for method invocation operations. JsonUtil Helper utilities for reading and writing JSON files. LooseRunner Provides a mechanism for running actions asynchronously in a loose manner. Only the most recent action is executed and previous pending actions are discarded. ManualUtil Utility class for handling manual and documentation files with culture support. MaskUtil Utility for bits masking. NameUtil Utility class for handling object names and display names. PacePlayee Represents an entity that can be controlled by the pace player. PacePlayer Controls the pace execution of a task. Pair<TA, TB> Editable pair values. ProgressFraction Represents a progress report implementation. Also exposes an IMessage view (explicitly implemented) so a progress fraction can ride the unified message channel uniformly alongside SimpleMessage / NcDiagnostic: Progress + System, with Msg as the notification and Detail as the detail payload. Range<T> Range from Min to Max. ResourceDefaultMarker File-name convention that marks a shipped resource item as a system-owned default: a file carries the token before its final extension (AlTiBN.default.CoatingMaterial), a folder-shaped resource carries it as a folder-name suffix (MachineTool/Table-B1.default/) with the files inside left untouched. ResourceLayout Provides the relative folder paths that make up the shipped resource tree. ResourceUtil Utility class for working with resource managers and localized strings, and the home of the attribute-declared command vocabulary: the CultureTextAttribute declarations of an assembly, exposed as “type/member + culture → text” queries and as ICommandTextSource instances, with GUI-layer overrides layered on top (SetTextOverride(string, string, string)). RoutineBlocker Block the thread to the given delay from the previous block. SeqPairUtil Utility class for SeqPair operations. SeqPair<T> Represents a sequence pair containing previous and current values. Used to track sequential state changes of a value. ServerFileExplorerConfig Configuration for server file explorer functionality. StringLocalizer Provides localization functionality for strings using resource managers. StringUtil Utility for managing text. TaskUtil Utility class for Task-related operations. TimeCounter A utility counts the average/total time consume between the Bound(object) areas. The count of time consume for the given key starts at the first time (and the odd time) calling Bound(object); stops and accumulates at the second time (and the even time). Interfaces IAbstractNote Interface for objects that provide an abstract description or note. IBinaryIo Interface for binary input/output operations. Extends IWriteBin to provide both read and write capabilities. IClearCache Interface for objects that can clear their internal cache. ICommandTextSource A culture-bearing vocabulary commands compose their titles and labels from: it maps a vocabulary key — the English default text — onto that culture's text. The CALLER picks the source, so the presentation layer owns the language (no thread culture involved); the command keeps its composition and degradation rules. Presentation layers can implement their own source or take the engine-default one from GenTextSource(CultureInfo, params Type[]) ([CultureText] declarations overlaid by SetTextOverride(string, string, string) registrations). IDuplicate Interface for objects that support deep cloning/duplication. IGetQuantityByKey Interface for retrieving a quantity value using a string key. IGetSelectionName Interface for objects that can provide a name for selection purposes. INameNote Interface for objects that have a name and note property. IPreferredFileName Interface for objects that can specify a preferred file name. Generally used to suggest a name when generating or saving files. IProgressFraction Interface for progress reporting functionality. ISourceFile Interface for objects that have a source file. IToPresentDto Interface for converting objects to presentation DTOs (Data Transfer Objects) for JSON serialization. IUpdateByContent Interface for objects that can update themselves based on their content. IUriGetter Interface for retrieving a URI string. IWriteBin Interface for writing binary data. Enums SearchResult Represents the result of a search operation. Delegates CppLogUtil.LogDelegate Internal Use Only. LooseRunner.MergedCancellationTokenRun Delegate for actions that accept a merged cancellation token. The merged token combines the runner's disposal token with an optional external cancellation token."
  },
  "api/Hi.CutterLocations.ClPath.ClCircleArc.html": {
    "href": "api/Hi.CutterLocations.ClPath.ClCircleArc.html",
    "title": "Class ClCircleArc | HiAPI-C# 2025",
    "summary": "Class ClCircleArc Namespace Hi.CutterLocations.ClPath Assembly HiMech.dll Cutter location path of circle arc. public class ClCircleArc : IClPath Inheritance object ClCircleArc Implements IClPath Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ClCircleArc(DVec3d, DVec3d, DVec3d, int) Initializes a new instance of the ClCircleArc class. public ClCircleArc(DVec3d circleCenterAxis, DVec3d begin, DVec3d end, int circleNum = 1) Parameters circleCenterAxis DVec3d The axis of the circle arc. begin DVec3d The starting point and direction. end DVec3d The ending point and direction. circleNum int Circle num which include an arc. The default is 1. Properties AngleOnAxialTilt Gets the angle of axial tilt. public double AngleOnAxialTilt { get; } Property Value double AngleOnProj Gets the angle of projection. public double AngleOnProj { get; } Property Value double AxialMove Gets the movement along the axis. public Vec3d AxialMove { get; } Property Value Vec3d AxialTiltAxis Gets the axis of axial tilt. public Vec3d AxialTiltAxis { get; } Property Value Vec3d Begin Gets the starting point and direction. public DVec3d Begin { get; } Property Value DVec3d CircleCenterAxis Gets the axis of the circle arc. public DVec3d CircleCenterAxis { get; } Property Value DVec3d CircleNum Gets the number of complete circles included in the arc. public int CircleNum { get; } Property Value int CurveLength Gets the approximate length of the curve. public double CurveLength { get; } Property Value double End Gets the ending point and direction. public DVec3d End { get; } Property Value DVec3d Length public double Length { get; } Property Value double RadiusBegin Gets the radius at the beginning of the arc. public double RadiusBegin { get; } Property Value double RadiusEnd Gets the radius at the end of the arc. public double RadiusEnd { get; } Property Value double Methods At(double) NP (Normal and Point) at the given ratio (0~1). public DVec3d At(double ratio) Parameters ratio double ratio of the path (0~1) Returns DVec3d NP (Normal and Point) GetBegin() Path begin. public DVec3d GetBegin() Returns DVec3d path begin GetEnd() Path end. public DVec3d GetEnd() Returns DVec3d path end ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.CutterLocations.ClPath.ClLinear.html": {
    "href": "api/Hi.CutterLocations.ClPath.ClLinear.html",
    "title": "Class ClLinear | HiAPI-C# 2025",
    "summary": "Class ClLinear Namespace Hi.CutterLocations.ClPath Assembly HiMech.dll Cutter location path by linear interpolation. public class ClLinear : IClPath Inheritance object ClLinear Implements IClPath Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ClLinear(DVec3d, DVec3d) Initializes a new instance of the ClLinear class with specified begin and end points. public ClLinear(DVec3d begin, DVec3d end) Parameters begin DVec3d The beginning point and normal vector. end DVec3d The ending point and normal vector. Properties Arrow Arrow from being.p to end.p. public Vec3d Arrow { get; } Property Value Vec3d Begin Begin of the path. public DVec3d Begin { get; set; } Property Value DVec3d End End of the path. public DVec3d End { get; set; } Property Value DVec3d Length Length of the Arrow. public double Length { get; } Property Value double NormalAxisDelta The axis-angle representation of the normal vector change from begin to end. public AxisAngle4d NormalAxisDelta { get; } Property Value AxisAngle4d Methods At(double) Gets the interpolated point and normal vector at the specified ratio along the path. public DVec3d At(double ratio) Parameters ratio double The interpolation ratio between 0 and 1. Returns DVec3d The interpolated point and normal vector. GetBegin() Gets the beginning point and normal vector of the path. public DVec3d GetBegin() Returns DVec3d The beginning point and normal vector. GetEnd() Gets the ending point and normal vector of the path. public DVec3d GetEnd() Returns DVec3d The ending point and normal vector. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.CutterLocations.ClPath.IClPath.html": {
    "href": "api/Hi.CutterLocations.ClPath.IClPath.html",
    "title": "Interface IClPath | HiAPI-C# 2025",
    "summary": "Interface IClPath Namespace Hi.CutterLocations.ClPath Assembly HiMech.dll Cutter location path. public interface IClPath Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods At(double) NP (Normal and Point) at the given ratio (0~1). DVec3d At(double ratio) Parameters ratio double ratio of the path (0~1) Returns DVec3d NP (Normal and Point) GetBegin() Path begin. DVec3d GetBegin() Returns DVec3d path begin GetEnd() Path end. DVec3d GetEnd() Returns DVec3d path end"
  },
  "api/Hi.CutterLocations.ClPath.html": {
    "href": "api/Hi.CutterLocations.ClPath.html",
    "title": "Namespace Hi.CutterLocations.ClPath | HiAPI-C# 2025",
    "summary": "Namespace Hi.CutterLocations.ClPath Classes ClCircleArc Cutter location path of circle arc. ClLinear Cutter location path by linear interpolation. Interfaces IClPath Cutter location path."
  },
  "api/Hi.CutterLocations.ClStrips.ClStrip.html": {
    "href": "api/Hi.CutterLocations.ClStrips.ClStrip.html",
    "title": "Class ClStrip | HiAPI-C# 2025",
    "summary": "Class ClStrip Namespace Hi.CutterLocations.ClStrips Assembly HiMech.dll Represents a CL (Cutter Location) strip for 3D display. This class manages the display and interaction of cutter location points and lines. public class ClStrip : IDisplayee, IExpandToBox3d, IDisposable Inheritance object ClStrip Implements IDisplayee IExpandToBox3d IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) BoundSelectorUtil.GetStepRange(ClStrip, BoundSelectorPair) DispUtil.Display(IDisplayee, Bind, Mat4d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ClStrip(int) Initializes a new instance of the ClStrip class. public ClStrip(int cap = 2048) Parameters cap int The initial capacity of the strip Fields InternalMachiningStepSelected Host wiring hook invoked when a strip position selects a machining step (low-level; prefer MachiningStepSelected for UI). public Action<MachiningStep> InternalMachiningStepSelected Field Value Action<MachiningStep> slice_distance The distance between slices for efficient rendering. public const int slice_distance = 8192 Field Value int Properties AbsDispEnd Gets the absolute display end position. If the display end is set to -1, returns the total number of positions. public int AbsDispEnd { get; } Property Value int CallRefreshDrawing internal use public bool CallRefreshDrawing { get; } Property Value bool ChartRange Synchoronized Chart Time Range. Always not null. The members' value is possible to be null for the un-available status. public Range<TimeSpan?> ChartRange { get; } Property Value Range<TimeSpan?> IsKeepingDispAlive Keep the disp range to at least two dots while the stripe length enough. public bool IsKeepingDispAlive { get; set; } Property Value bool IsShowDot Gets or sets whether to display dots at each position. public bool IsShowDot { get; set; } Property Value bool LastRefreshHadUncoveredRecolor True when the last RefreshDrawingInRendering(bool) re-stamped at least one position whose attachment is not covered by the native color table. Only then do stale colors remain baked in the workpiece display caches, so the whole-tree clean after the re-stamp is still required; covered recolors reach the screen through the table without any clean. public bool LastRefreshHadUncoveredRecolor { get; } Property Value bool StripPoses Gets the list of strip positions. Do not add or remove elements directly. public SynList<ClStripPos> StripPoses { get; } Property Value SynList<ClStripPos> StripPosesClearLock Gets the lock for thread-safe operations on strip positions. public ReaderWriterLockSlim StripPosesClearLock { get; } Property Value ReaderWriterLockSlim StripPosesCount Gets the thread-safe count of strip positions. public int StripPosesCount { get; } Property Value int StripPosesRetirer Optional sink for retiring abandoned ClStripPos when the strip is cleared. Injected by the owner (MachiningActRunner) to route through WorkpieceService.RetireAttachments — detach the poses from the live runtime tree under its render barrier, then free them in the background. When null, the poses are freed directly on CubeTree's background chain. public Action<IReadOnlyList<ClStripPos>> StripPosesRetirer { get; set; } Property Value Action<IReadOnlyList<ClStripPos>> Methods Add(object, DVec3d) Adds a new position to the strip. public ClStripPos Add(object state, DVec3d programCl) Parameters state object The state object associated with the position programCl DVec3d The cutter location Returns ClStripPos The newly created strip position Clear(object) Clears all strip positions and resets the display state. public void Clear(object sender) Parameters sender object The object that initiated this clear operation Display(Bind) Displays the strip. public void Display(Bind bind) Parameters bind Bind The binding context for display Dispose() Disposes of the resources used by this strip. public void Dispose() Dispose(bool) Disposes of the resources used by this strip. protected virtual void Dispose(bool disposing) Parameters disposing bool Whether this is being called from Dispose ExpandToBox3d(Box3d) Expands the given box to include all strip positions. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d The box to expand GetDispBegin() Gets the current display begin position. public int GetDispBegin() Returns int The display begin position GetDispEnd() Gets the current display end position. A value of -1 indicates that the display should follow the end of the strip. public int GetDispEnd() Returns int The display end position GetEnteredPos() Gets the currently entered position. public ClStripPos GetEnteredPos() Returns ClStripPos The entered position GetFittingView(Mat4d, Mat4d) Gets a scaled fitting view based on the strip display range. public Mat4d GetFittingView(Mat4d sketchView, Mat4d clStripZeroToRoot = null) Parameters sketchView Mat4d The sketch view matrix clStripZeroToRoot Mat4d The transformation from strip zero to root Returns Mat4d The scaled fitting view matrix GetSelectedPos() Gets the currently selected position. public ClStripPos GetSelectedPos() Returns ClStripPos The selected position GetStripPos(int, bool) Gets a strip position by index. public ClStripPos GetStripPos(int index, bool isLocked = false) Parameters index int The index of the position isLocked bool Whether the strip positions are already locked Returns ClStripPos The strip position at the specified index LimitChartRange(bool) Limits the chart range based on the time range of the strip positions. public void LimitChartRange(bool isLocked) Parameters isLocked bool Whether the strip positions are locked. RefreshDrawing() Marks the drawing for refresh. public void RefreshDrawing() RefreshDrawingInRendering(bool) internal use public void RefreshDrawingInRendering(bool isLocked) Parameters isLocked bool SetDispBegin(int, object) Sets the display begin position. public void SetDispBegin(int value, object caller) Parameters value int The new display begin position caller object The object that initiated this change SetDispEnd(int, object) Sets the display end position. A value of -1 indicates that the display should follow the end of the strip. public void SetDispEnd(int value, object caller) Parameters value int The new display end position caller object The object that initiated this change SetDispSegment(int, int, object) Sets the display range for the cutter location strip. This method sets both the beginning and ending positions of the display range. public void SetDispSegment(int beginIndex, int endIndex, object caller) Parameters beginIndex int The beginning index of the display range. Will be clamped to [0, StripPoses.Count - 1]. endIndex int The ending index of the display range. A value of -1 indicates that the display should follow the end of the strip. Values greater than or equal to StripPoses.Count will be converted to -1. Will be clamped to [-1, StripPoses.Count]. caller object The caller object that requests the display range change. Used for event notifications. SetEnteredPos(ClStripPos, object) Sets the currently entered position. public void SetEnteredPos(ClStripPos value, object sender) Parameters value ClStripPos The new entered position sender object The object that initiated this change SetSelectedPos(ClStripPos, object) Sets the currently selected position. public void SetSelectedPos(ClStripPos value, object sender) Parameters value ClStripPos The new selected position sender object The object that initiated this change ShrinkAttachmentMemory(CancellationToken?) Shrinks the attachment memory for all positions. public void ShrinkAttachmentMemory(CancellationToken? cancellationToken = null) Parameters cancellationToken CancellationToken? StripPosesThreadSafeSelect<T>(Func<ClStripPos, T>) Thread-safe selection of strip positions. public List<T> StripPosesThreadSafeSelect<T>(Func<ClStripPos, T> func) Parameters func Func<ClStripPos, T> The function to transform each strip position Returns List<T> A list of transformed strip positions Type Parameters T The type of the selected data UpdateDispSegmentByChartRange(object) Updates the display segment based on the current chart range. public void UpdateDispSegmentByChartRange(object caller) Parameters caller object The caller object that triggered the update. Events AbsDispEndChanged Event raised when the absolute display end position changes. public event EventHandler AbsDispEndChanged Event Type EventHandler Cleared Event raised after Clear(object) has emptied StripPoses, so list-style consumers (e.g. a step table) can reset without polling. public event Action Cleared Event Type Action DispBeginChanged Event raised when the display begin position changes. public event EventHandler DispBeginChanged Event Type EventHandler DispEndChanged Event raised when the display end position changes. public event EventHandler DispEndChanged Event Type EventHandler DrawingRefreshed Event raised after the strip drawing has been refreshed — pos colors re-stamped from their states and the drawing slices rebuilt (see RefreshDrawingInRendering(bool)). Subscribers that cache colors baked from the strip attachments (e.g. a meshed workpiece's display cache) should invalidate on this event. public event EventHandler DrawingRefreshed Event Type EventHandler MachiningStepSelected The same effecting position as PosSelected but with more convenient arguments for the end-user. public event Action<MachiningStep> MachiningStepSelected Event Type Action<MachiningStep> PosAdded Event raised when a new position is added to the strip. public event Action<ClStripPos> PosAdded Event Type Action<ClStripPos> PosEntered Event raised when the mouse enters a position. public event EventHandler<ClStripPos> PosEntered Event Type EventHandler<ClStripPos> PosSelected Event raised when a position is selected. public event EventHandler<ClStripPos> PosSelected Event Type EventHandler<ClStripPos> StaticPosSelected Static event raised when any position is selected. public static event EventHandler<ClStripPos> StaticPosSelected Event Type EventHandler<ClStripPos>"
  },
  "api/Hi.CutterLocations.ClStrips.ClStripPos.html": {
    "href": "api/Hi.CutterLocations.ClStrips.ClStripPos.html",
    "title": "Class ClStripPos | HiAPI-C# 2025",
    "summary": "Class ClStripPos Namespace Hi.CutterLocations.ClStrips Assembly HiMech.dll Represents a position in a cutter location strip, containing program coordinates and state information. public class ClStripPos : CbtrPickable, IGetPickable, IDisposable, IGetProgramCl, IMotionStepIndex Inheritance object Pickable CbtrPickable ClStripPos Implements IGetPickable IDisposable IGetProgramCl IMotionStepIndex Inherited Members CbtrPickable.Rgb CbtrPickable.IsColorTableCovered CbtrPickable.AttachmentPriority CbtrPickable.Highlight(bool) CbtrPickable.CleanAttachedCbtrNodesDrawingCache() CbtrPickable.ShrinkToFitNodeMap() Pickable.Pickables Pickable.mark Pickable.PickingID Pickable.GetPickable() Pickable.Dispose() object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Index Gets the index of this position in the strip. This is also the step's execution-order ordinal — exposed via StepIndex. public int Index { get; } Property Value int MachiningStep Gets or sets the milling step associated with this position. This is a convenience property that casts the State to MachiningStep. public MachiningStep MachiningStep { get; set; } Property Value MachiningStep ProgramCl Gets the program coordinates of this position. public DVec3d ProgramCl { get; } Property Value DVec3d State Gets or sets the state object associated with this position. When the state changes, the color is automatically refreshed. public object State { get; set; } Property Value object Methods Display(Bind) public void Display(Bind bind) Parameters bind Bind Dispose(bool) protected override void Dispose(bool disposing) Parameters disposing bool GetLastTime(bool) If time is not set, return the time from the last setted step. public TimeSpan? GetLastTime(bool isLocked = false) Parameters isLocked bool Returns TimeSpan? GetProgramCl() Get CL (Cutter Location). Where Point is tool tip position; Normal is tool orientation. public DVec3d GetProgramCl() Returns DVec3d CL OnKeyDown(key_event_t, DispEngine) Behavior on key down. public override void OnKeyDown(key_event_t e, DispEngine dispEngine) Parameters e key_event_t event dispEngine DispEngine display engine OnKeyUp(key_event_t, DispEngine) Behavior on key up public override void OnKeyUp(key_event_t e, DispEngine dispEngine) Parameters e key_event_t event dispEngine DispEngine display engine OnMouseDown(mouse_button_event_t, DispEngine) Behavior on mouse down public override void OnMouseDown(mouse_button_event_t e, DispEngine dispEngine) Parameters e mouse_button_event_t event dispEngine DispEngine display engine OnMouseEnter(ui_event_type, DispEngine) Behavior on mouse enter public override void OnMouseEnter(ui_event_type e, DispEngine dispEngine) Parameters e ui_event_type event type dispEngine DispEngine display engine OnMouseLeave(ui_event_type, DispEngine) Behavior on mouse leave public override void OnMouseLeave(ui_event_type e, DispEngine dispEngine) Parameters e ui_event_type event type dispEngine DispEngine display engine OnMouseMove(mouse_move_event_t, DispEngine) Behavior on mouse move public override void OnMouseMove(mouse_move_event_t e, DispEngine dispEngine) Parameters e mouse_move_event_t event dispEngine DispEngine display engine OnMouseUp(mouse_button_event_t, DispEngine) Behavior on mouse up public override void OnMouseUp(mouse_button_event_t e, DispEngine dispEngine) Parameters e mouse_button_event_t event dispEngine DispEngine display engine OnMouseWheel(mouse_wheel_event_t, DispEngine) Behavior on mouse wheel public override void OnMouseWheel(mouse_wheel_event_t e, DispEngine dispEngine) Parameters e mouse_wheel_event_t event dispEngine DispEngine display engine ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.CutterLocations.ClStrips.RgbFunc.html": {
    "href": "api/Hi.CutterLocations.ClStrips.RgbFunc.html",
    "title": "Delegate RgbFunc | HiAPI-C# 2025",
    "summary": "Delegate RgbFunc Namespace Hi.CutterLocations.ClStrips Assembly HiMech.dll Delegate for getting RGB color from a source object. public delegate Vec3d RgbFunc(object src) Parameters src object The source object to get RGB from Returns Vec3d RGB color vector Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.CutterLocations.ClStrips.html": {
    "href": "api/Hi.CutterLocations.ClStrips.html",
    "title": "Namespace Hi.CutterLocations.ClStrips | HiAPI-C# 2025",
    "summary": "Namespace Hi.CutterLocations.ClStrips Classes ClStrip Represents a CL (Cutter Location) strip for 3D display. This class manages the display and interaction of cutter location points and lines. ClStripPos Represents a position in a cutter location strip, containing program coordinates and state information. Delegates RgbFunc Delegate for getting RGB color from a source object."
  },
  "api/Hi.CutterLocations.IGetProgramCl.html": {
    "href": "api/Hi.CutterLocations.IGetProgramCl.html",
    "title": "Interface IGetProgramCl | HiAPI-C# 2025",
    "summary": "Interface IGetProgramCl Namespace Hi.CutterLocations Assembly HiMech.dll Interface of get CL (Cutter Location). public interface IGetProgramCl Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetProgramCl() Get CL (Cutter Location). Where Point is tool tip position; Normal is tool orientation. DVec3d GetProgramCl() Returns DVec3d CL"
  },
  "api/Hi.CutterLocations.SimpleCl.html": {
    "href": "api/Hi.CutterLocations.SimpleCl.html",
    "title": "Class SimpleCl | HiAPI-C# 2025",
    "summary": "Class SimpleCl Namespace Hi.CutterLocations Assembly HiMech.dll Represents a simple cutter location with position and normal vector. public class SimpleCl : IGetProgramCl Inheritance object SimpleCl Implements IGetProgramCl Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SimpleCl() Initializes a new instance of the SimpleCl class. public SimpleCl() SimpleCl(SimpleCl) Initializes a new instance of the SimpleCl class by copying from another instance. public SimpleCl(SimpleCl src) Parameters src SimpleCl The source SimpleCl instance to copy from. SimpleCl(DVec3d) Initializes a new instance of the SimpleCl class with the specified cutter location vector. public SimpleCl(DVec3d cl) Parameters cl DVec3d The cutter location vector containing position and normal. Properties Cl Gets or sets the cutter location vector containing position and normal. public DVec3d Cl { get; set; } Property Value DVec3d Methods GetProgramCl() Get CL (Cutter Location). Where Point is tool tip position; Normal is tool orientation. public DVec3d GetProgramCl() Returns DVec3d CL ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.CutterLocations.html": {
    "href": "api/Hi.CutterLocations.html",
    "title": "Namespace Hi.CutterLocations | HiAPI-C# 2025",
    "summary": "Namespace Hi.CutterLocations Classes SimpleCl Represents a simple cutter location with position and normal vector. Interfaces IGetProgramCl Interface of get CL (Cutter Location)."
  },
  "api/Hi.Disp.Bind.html": {
    "href": "api/Hi.Disp.Bind.html",
    "title": "Class Bind | HiAPI-C# 2025",
    "summary": "Class Bind Namespace Hi.Disp Assembly HiDisp.dll Runtime rendering data for each iteration in rendering loop. It manipulates geometry transformation, such as moving, rotatingand scaling. It also deal with color and picking. A bind_t object is generated by rendering in the every beginning of each rendering iteration. public class Bind : IDisposable Inheritance object Bind Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields bind Internal use. public bind_t* bind Field Value bind_t* Properties CanvasHeight DispEngine height. public int CanvasHeight { get; } Property Value int CanvasWidth DispEngine width. public int CanvasWidth { get; } Property Value int IsPickingMode Is current display loop in pick mode. public bool IsPickingMode { get; } Property Value bool ModelMatStack Stack-based Model matrix in MVP convention. public MatStack ModelMatStack { get; } Property Value MatStack PickID ID of picking event. public int PickID { get; set; } Property Value int PixelProjMat Pixel part of Projection matrix in MVP convention. public Mat4d PixelProjMat { get; } Property Value Mat4d See Also ProjMat PixelWidthOnModel Pixel width on model layer. public double PixelWidthOnModel { get; } Property Value double ProjMat Projection matrix in MVP convention. Projection matrix = ScaleProjMat * PixelProjMat. public Mat4d ProjMat { get; } Property Value Mat4d Reciprocal_vs_scale Cached reciprocal value of the scale of ViewMat * ScaleProjMat. public double Reciprocal_vs_scale { get; } Property Value double Rgb External RGB Color for the Drawing which the KeyStamp does not contains C. public Vec3d Rgb { get; set; } Property Value Vec3d ScaleProjMat Scale part of Projection matrix in MVP convention. public Mat4d ScaleProjMat { get; } Property Value Mat4d See Also ProjMat SparkleRate Gets or sets the sparkle rate for rendering effects. public float SparkleRate { get; set; } Property Value float ViewMat View matrix in MVP convention. public Mat4d ViewMat { get; } Property Value Mat4d Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ~Bind() protected ~Bind() GetMvpBoxRelation(Vec3d, double) get relation between mvpBox and a AABB (bounding with a sphere) public MvpBoxRelation GetMvpBoxRelation(Vec3d center, double r) Parameters center Vec3d center r double radius Returns MvpBoxRelation 0 if no overlap; 1 if partial overlap; 2 if B in A PopColor() Pop the color after using PushColor() and etc.. public void PopColor() See Also PushColor() PushColorByRgb(Vec3d) PopLineWidth() Pop the line width from the stack. And then set the poped line width to current line width. public void PopLineWidth() PopPointSize() Pop the stored point size from the stack. And then set the stored point size to current point size. public void PopPointSize() See Also PushPointSize() PushPointSize(double) PushColor() Push current color to stack. After PopColor(), the pushed color will be restored. public void PushColor() PushColorByHsl(Vec3d) Pushes a color onto the color stack using HSL values. public void PushColorByHsl(Vec3d hsl) Parameters hsl Vec3d The HSL color vector. PushColorByHsl(double, double, double) Pushes a color onto the color stack using HSL values. public void PushColorByHsl(double hue, double saturation, double light) Parameters hue double The hue component (0.0 to 1.0). saturation double The saturation component (0.0 to 1.0). light double The lightness component (0.0 to 1.0). PushColorByHslOffset(Vec3d) Pushes a color onto the color stack by applying HSL offsets to the current color. public void PushColorByHslOffset(Vec3d hslOffset) Parameters hslOffset Vec3d The HSL offset vector to apply. PushColorByHslOffset(double, double, double) Pushes a color onto the color stack by applying HSL offsets to the current color. public void PushColorByHslOffset(double hueOffset, double saturationOffset, double lightOffset) Parameters hueOffset double The hue offset to apply. saturationOffset double The saturation offset to apply. lightOffset double The lightness offset to apply. PushColorByRgb(Vec3d) Push current color to stack then set the color to given rgb. After PopColor(), the pushed color will be restored. If rgb is null, ignore the rgb and push. public void PushColorByRgb(Vec3d rgb) Parameters rgb Vec3d RGB color PushColorByRgb(double, double, double) Pushes a color onto the color stack using RGB values. public void PushColorByRgb(double r, double g, double b) Parameters r double The red component value (0.0 to 1.0). g double The green component value (0.0 to 1.0). b double The blue component value (0.0 to 1.0). PushColorByRgbOffset(Vec3d) Pushes a color onto the color stack by applying an RGB offset to the current color. Ensures the resulting color stays within [0,1] by shifting or normalizing when needed. public void PushColorByRgbOffset(Vec3d rgbOffset) Parameters rgbOffset Vec3d The RGB offset to add to the current color. PushColorByRgbOffset(double, double, double) Pushes a color onto the color stack by applying per-channel RGB offsets to the current color. public void PushColorByRgbOffset(double rOffset, double gOffset, double bOffset) Parameters rOffset double Offset applied to the red channel. gOffset double Offset applied to the green channel. bOffset double Offset applied to the blue channel. PushCoveringPixelMode() Push covering-pixel-mode matrix to ModelMatStack to make the display in pixel scale. Call ModelMatStack.Pop() to end the mode. public void PushCoveringPixelMode() PushLineWidth() Push current line width into stack. public void PushLineWidth() See Also PopLineWidth() PushLineWidth(double) Push current line width into stack. And then set lineWidth to the current line width. public void PushLineWidth(double lineWidth) Parameters lineWidth double line width See Also PopLineWidth() PushNoRotationPixelMode() Push no-rotation-pixel-mode matrix to ModelMatStack to make the display in pixel scale. Call ModelMatStack.Pop() to end the mode. public void PushNoRotationPixelMode() PushPixelMode() Push pixel mode matrix to ModelMatStack to make the display in pixel scale. Call ModelMatStack.Pop() to end the mode. public void PushPixelMode() PushPointSize() Push current point size to the stack. public void PushPointSize() See Also PopPointSize() PushPointSize(double) Push current point size to the stack. And then set the pointSize to current point size. public void PushPointSize(double pointSize) Parameters pointSize double point size See Also PopPointSize() PushPointSize(float) Push current point size to the stack. And then set the pointSize to current point size. public void PushPointSize(float pointSize) Parameters pointSize float point size See Also PopPointSize() ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Disp.Box3dDispUtil.BoxableExpandToBox3dDel.html": {
    "href": "api/Hi.Disp.Box3dDispUtil.BoxableExpandToBox3dDel.html",
    "title": "Delegate Box3dDispUtil.BoxableExpandToBox3dDel | HiAPI-C# 2025",
    "summary": "Delegate Box3dDispUtil.BoxableExpandToBox3dDel Namespace Hi.Disp Assembly HiDisp.dll Delegate for expanding a native boxable object to a box3d. public delegate void Box3dDispUtil.BoxableExpandToBox3dDel(nint boxablePtr, ref box3d box) Parameters boxablePtr nint Pointer to the boxable object. box box3d Reference to the box to expand. Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Disp.Box3dDispUtil.html": {
    "href": "api/Hi.Disp.Box3dDispUtil.html",
    "title": "Class Box3dDispUtil | HiAPI-C# 2025",
    "summary": "Class Box3dDispUtil Namespace Hi.Disp Assembly HiDisp.dll Utility and Extension of Box3d. public static class Box3dDispUtil Inheritance object Box3dDispUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods Display(Box3d, Bind) Call DisplayLine(Box3d, Bind). public static void Display(this Box3d src, Bind bind) Parameters src Box3d src bind Bind bind DisplayFace(Box3d, Bind) Display faces of the src. public static void DisplayFace(this Box3d src, Bind bind) Parameters src Box3d src bind Bind bind DisplayLine(Box3d, Bind) Display edges of the src. public static void DisplayLine(this Box3d src, Bind bind) Parameters src Box3d src bind Bind bind ExpandToBox3d(nint, BoxableExpandToBox3dDel, Box3d) Expands a destination Box3d to include the bounds of a native boxable object. public static void ExpandToBox3d(nint boxablePtr, Box3dDispUtil.BoxableExpandToBox3dDel boxableExpandToBox3dDel, Box3d dst) Parameters boxablePtr nint Pointer to the boxable object. boxableExpandToBox3dDel Box3dDispUtil.BoxableExpandToBox3dDel Delegate to expand the boxable to a box3d. dst Box3d The destination Box3d to expand. GetBox(nint, BoxableExpandToBox3dDel) Gets a Box3d from a native boxable pointer using the provided delegate. public static Box3d GetBox(nint boxablePtr, Box3dDispUtil.BoxableExpandToBox3dDel boxableExpandToBox3dDel) Parameters boxablePtr nint Pointer to the boxable object. boxableExpandToBox3dDel Box3dDispUtil.BoxableExpandToBox3dDel Delegate to expand the boxable to a box3d. Returns Box3d A Box3d representing the bounds of the boxable object. ToDraw(Box3d) Equivalent to ToDraw_Face(Box3d) public static Drawing ToDraw(this Box3d src) Parameters src Box3d src Returns Drawing Drawing ToDraw_Face(Box3d) To Face Drawing. public static Drawing ToDraw_Face(this Box3d src) Parameters src Box3d src Returns Drawing Face Drawing ToDraw_Line(Box3d) To Line Drawing. public static Drawing ToDraw_Line(this Box3d src) Parameters src Box3d src Returns Drawing Line Drawing ToFaceDraw(IEnumerable<Box3d>) Get faces Drawing. public static Drawing ToFaceDraw(this IEnumerable<Box3d> boxs) Parameters boxs IEnumerable<Box3d> boxes Returns Drawing a draw with face ToLineBuf(Box3d, double[], ref int) Put the edges' data to dst, totally 72 double. The data is used according to GL_LINES. public static int ToLineBuf(this Box3d src, double[] dst, ref int p) Parameters src Box3d src dst double[] dstination buffer p int current position of the buffer Returns int The p increment: 72 ToLineDraw(IEnumerable<Box3d>) Get the edges Drawing of boxs. public static Drawing ToLineDraw(this IEnumerable<Box3d> boxs) Parameters boxs IEnumerable<Box3d> boxs Returns Drawing The Drawing"
  },
  "api/Hi.Disp.DelegateFuncDisplayee.html": {
    "href": "api/Hi.Disp.DelegateFuncDisplayee.html",
    "title": "Class DelegateFuncDisplayee | HiAPI-C# 2025",
    "summary": "Class DelegateFuncDisplayee Namespace Hi.Disp Assembly HiDisp.dll A displayee implementation that delegates display functionality to a function. public class DelegateFuncDisplayee : IDisplayee, IExpandToBox3d Inheritance object DelegateFuncDisplayee Implements IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) DispUtil.Display(IDisplayee, Bind, Mat4d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors DelegateFuncDisplayee(Func<IDisplayee>) Initializes a new instance of the DelegateFuncDisplayee class. public DelegateFuncDisplayee(Func<IDisplayee> func) Parameters func Func<IDisplayee> The function that returns an IDisplayee instance. Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box"
  },
  "api/Hi.Disp.DispEngine.ImageRequestedDelegate.html": {
    "href": "api/Hi.Disp.DispEngine.ImageRequestedDelegate.html",
    "title": "Delegate DispEngine.ImageRequestedDelegate | HiAPI-C# 2025",
    "summary": "Delegate DispEngine.ImageRequestedDelegate Namespace Hi.Disp Assembly HiDisp.dll For ImageRequestAfterBufferSwapped. public delegate void DispEngine.ImageRequestedDelegate(byte* bgra_unsignedbyte_pixels, int w, int h) Parameters bgra_unsignedbyte_pixels byte* BGRA convention pixels in unsigned bytes. The size is wh4. w int width h int height Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Disp.DispEngine.html": {
    "href": "api/Hi.Disp.DispEngine.html",
    "title": "Class DispEngine | HiAPI-C# 2025",
    "summary": "Class DispEngine Namespace Hi.Disp Assembly HiDisp.dll HiAPI display engine. public class DispEngine : IDisposable, IGetDispEngine Inheritance object DispEngine Implements IDisposable IGetDispEngine Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks The DispEngine is the core rendering and interaction engine for HiAPI applications. Related Documentation Using RenderingCanvas with DispEngine Building Your Own Rendering Canvas The DispEngine provides a unified API for handling rendering, user interaction, and touch gestures across different UI frameworks. Constructors DispEngine(IDisplayee) Ctor. The SetViewToHomeView() is called in this function. public DispEngine(IDisplayee displayee) Parameters displayee IDisplayee The displayee to render. DispEngine(params IDisplayee[]) Ctor. public DispEngine(params IDisplayee[] displayees) Parameters displayees IDisplayee[] displayees to render. Fields CoreDll Core dll path. public const string CoreDll = \"core.dll\" Field Value string defaultFontFile Sentinel selecting the embedded default font (Noto Sans CJK TC, SIL Open Font License 1.1). Passing this value (or null) to Init(string) loads the embedded font from memory without writing any file to disk. This is not a path; no file of this name is looked up or created. public const string defaultFontFile = \"(embedded)\" Field Value string Properties BackgroundColor Background color public Vec3d BackgroundColor { get; set; } Property Value Vec3d BackgroundOpacity Background opacity. Range is from 0 to 1. public double BackgroundOpacity { get; set; } Property Value double ContextProjDepth Gets the projection depth of the current context. public static double ContextProjDepth { get; } Property Value double CursorOffsetX Internal Use. public int CursorOffsetX { get; } Property Value int CursorOffsetY Internal Use. public int CursorOffsetY { get; } Property Value int CursorX Internal Use. public int CursorX { get; set; } Property Value int CursorY Internal Use. public int CursorY { get; set; } Property Value int Displayee Displayee to be rendered in the rendering loop. The SetViewToHomeView() is called in this function. public IDisplayee Displayee { get; set; } Property Value IDisplayee EnableSuppressDefaultLogo Get or Set to Enable Suppress Default Logo. public static bool EnableSuppressDefaultLogo { get; set; } Property Value bool Exceptions InvalidOperationException Thrown when SuppressDefaultLogo license is not logged in. FontFile Font file. Null while the embedded default font (loaded from memory) is in use. public static string FontFile { get; set; } Property Value string IdleBackoffHeartbeat Idle backoff heartbeat. While the rendered image stays identical, no input arrives and progressive refinement has converged, the engine re-renders only once per this interval instead of every RefreshingPeriod. Zero (the default) disables the backoff. Any input, scene invalidation or an explicit ClearCache() restores the full refresh rate immediately. public TimeSpan IdleBackoffHeartbeat { set; } Property Value TimeSpan IsDisposed Gets a value indicating whether this engine has been disposed. All native-backed members become no-ops afterwards (value getters return neutral defaults). public bool IsDisposed { get; } Property Value bool IsOnDispThread Gets a value indicating whether the current thread is the display thread. public static bool IsOnDispThread { get; } Property Value bool IsVisible The anime stop running if the value is false; otherwise, the anime starts or keeps running. public bool IsVisible { get; set; } Property Value bool Model public Mat4d Model { get; set; } Property Value Mat4d Model matrix in MVP convention. This Model matrix is the first matrix in Hi.Disp.Bind.modelMatStack. PixelProj public Mat4d PixelProj { get; set; } Property Value Mat4d Pixel part of Projection matrix in MVP convention. Projection matrix = ScaleProj * PixelProj; PreCursorX Internal Use. public int PreCursorX { get; set; } Property Value int PreCursorY Internal Use. public int PreCursorY { get; set; } Property Value int PrincipleView public Mat4d PrincipleView { get; set; } Property Value Mat4d view = PrincipleView * SketchView. Where view matrix is in MVP convention. Remarks The default value is new Mat4d(new Vec3d(1, 0, 0), -Math.PI / 2). This make the 2D plane from xy plane to xz plane. The xz plane is much suit for 3D engineering display. RefreshingPeriod Image refreshing period. public TimeSpan RefreshingPeriod { get; set; } Property Value TimeSpan ScaleProj public Mat4d ScaleProj { get; set; } Property Value Mat4d Scale part of Projection matrix in MVP convention. Projection matrix = ScaleProj * PixelProj; SketchView view = PrincipleView * SketchView. Where view matrix is in MVP convention. public Mat4d SketchView { get; set; } Property Value Mat4d SuppressHoverPickWhileDragging When true, mouse moves with a button held do not trigger the hover pick pass (which re-renders the whole scene in picking mode). Enable this for hosts whose drags are pure camera transforms; keep the default (false) when API users drag a picked object via Pickable events. public bool SuppressHoverPickWhileDragging { set; } Property Value bool Methods ClearCache() Clears the display engine cache. public void ClearCache() DeleteDispContext() Deletes the current display context. public static void DeleteDispContext() Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool EnqueueDispose(IDisposable) Enqueues a disposable object to be disposed on the display thread. public static Task EnqueueDispose(IDisposable disposable) Parameters disposable IDisposable The disposable object to be disposed Returns Task A task representing the disposal operation EnqueueTask(Task) Enqueues a task to be executed on the display thread. public static Task EnqueueTask(Task task) Parameters task Task The task to be executed Returns Task The enqueued task EnqueueTask<T>(Task<T>) Enqueues a task to be executed on the display thread. public static Task<T> EnqueueTask<T>(Task<T> task) Parameters task Task<T> The task to be executed Returns Task<T> The enqueued task Type Parameters T The type of the task result ~DispEngine() protected ~DispEngine() FinishDisp() Elegantly end the rendering core. Probably not essential. public static void FinishDisp() GetDispEngine() Get DispEngine. public DispEngine GetDispEngine() Returns DispEngine DispEngine Init(string) Initializes the display engine system. public static void Init(string fontFile = null) Parameters fontFile string The font file to use. If null, the embedded default font is loaded from memory and no file is written to disk. IsKeyPressed(string) Checks if a specific keyboard key is currently pressed. Delegates to IsKeyPressed(string). public bool IsKeyPressed(string key) Parameters key string Key string (W3C KeyboardEvent.key value, e.g. “Alt”, “ArrowLeft”). Returns bool True if the specified key is pressed; otherwise, false. IsMouseButtonPressed(long) Checks if a specific mouse button is currently pressed. Delegates to IsMouseButtonPressed(long). public bool IsMouseButtonPressed(long mouseButton) Parameters mouseButton long The mouse button to check, typically a value from the HiMouseButton enumeration. Returns bool True if the specified mouse button is pressed; otherwise, false. KeyDown(string) Key down. This function is typically called in the GUI implementation for keyboard interaction. public void KeyDown(string key) Parameters key string Key string (W3C KeyboardEvent.key value, e.g. “Alt”, “ArrowLeft”, “a”). KeyDownTransform(string, key_table__transform_view_by_key_pressing_t) Transform SketchView by key. Home, F1, F2, F3, F4 call SetViewToHomeView(), SetViewToFrontView(), SetViewToRightView(), SetViewToTopView(), SetViewToIsometricView() respectively. PageDown and PageUp scale the SketchView. Left, Right, Down, Up translate the SketchView; Press Shift make these keys to rotate the SketchView. public void KeyDownTransform(string key, key_table__transform_view_by_key_pressing_t table) Parameters key string The key that was pressed, typically a value from the HiKey enumeration. table key_table__transform_view_by_key_pressing_t A table defining which keys trigger different transformation operations. Remarks This method is typically called from key down event handlers in the GUI implementation. KeyUp(string) Key up. This function is typically called in the GUI implementation for keyboard interaction. public void KeyUp(string key) Parameters key string Key string (W3C KeyboardEvent.key value). LockGlContext() Lock a opengl context. The function is only used for native OpenGL rendering. After lock the gl context, It should be unlock by UnlockGlContext(nint). public static nint LockGlContext() Returns nint Remarks If any other lock requires LockGlContext, the lock should better set inside LockGlContext. or it is easy to occur race condition. see design pattern of “Solid” class for reference. MouseButtonDown(long) Mouse button down. This function is typically called in the GUI implementation for mouse interaction. public void MouseButtonDown(long button) Parameters button long button MouseButtonUp(long) Mouse button up. This function is typically called in the GUI implementation for mouse interaction. public void MouseButtonUp(long button) Parameters button long button MouseDragTransform(int, int, mouse_button_table__transform_view_by_mouse_drag_t) Transform the view by mouse drag. If drag by left mouse button, Translate(double, double) is performed; If drag by right mouse button, Rotate(double, double) is performed. public void MouseDragTransform(int x, int y, mouse_button_table__transform_view_by_mouse_drag_t mouse_button_table) Parameters x int The current x-coordinate of the mouse cursor. y int The current y-coordinate of the mouse cursor. mouse_button_table mouse_button_table__transform_view_by_mouse_drag_t A table defining which mouse buttons trigger different transformation operations. Remarks The mouse_button_table__transform_view_by_mouse_drag_t structure allows you to configure which mouse buttons perform which transformations: var buttonTable = new mouse_button_table__transform_view_by_mouse_drag_t { LEFT_BUTTON = (long)HiMouseButton.Left, // For translation RIGHT_BUTTON = (long)HiMouseButton.Right // For rotation }; This method is typically called from mouse move event handlers when buttons are pressed. MouseMove(int, int) Mouse move. This function is typically called in the GUI implementation for mouse interaction. public void MouseMove(int x, int y) Parameters x int cursor X position y int cursor Y position MouseWheel(int, int) Mouse wheel move. This function is typically called in the GUI implementation for mouse interaction. public void MouseWheel(int deltaX, int deltaY) Parameters deltaX int mouse wheel delta X deltaY int mouse wheel delta Y. The traditional mouse wheel. MouseWheelTransform(int, int, double) Scale SketchView by mouse wheel. public void MouseWheelTransform(int deltaX, int deltaY, double zooming_ratio = 0.2) Parameters deltaX int mouse wheel delta X deltaY int mouse wheel delta Y. The traditional mouse wheel. zooming_ratio double The ratio used for zooming. Default is 0.2. Resize(int, int) Resize the opengl context. public void Resize(int w, int h) Parameters w int width of the viewport h int height of the viewport Rotate(double, double) Rotate the SketchView. Usually used by mouse drag on window. The rotation axis is along (delta_y, 0, delta_x). The rotation rad is 5 * Math.Sqrt(delta_y * delta_y + delta_x * delta_x) / window_height. public void Rotate(double delta_x, double delta_y) Parameters delta_x double delta x in window coordinate delta_y double delta y in window coordinate RotateAndScaleByTouchPad(Vec2d, Vec2d, Vec2d, Vec2d) Rotate and scale the SketchView based on touch pad gestures. public void RotateAndScaleByTouchPad(Vec2d prePosA, Vec2d curPosA, Vec2d prePosB, Vec2d curPosB) Parameters prePosA Vec2d The previous position of the first touch point. curPosA Vec2d The current position of the first touch point. prePosB Vec2d The previous position of the second touch point. curPosB Vec2d The current position of the second touch point. Remarks The method detects two types of gestures: Pinch gesture: When the distance between touch points changes, it triggers zooming via MouseWheelTransform(int, int, double) Rotation/Pan gesture: When touch points move together, it triggers rotation via Rotate(double, double) This method is typically used to implement touchpad or multi-touch gestures in custom UI implementations. RotateWithoutHeightAdjustment(double, double) Rotate the SketchView. Usually used by keyboard command. The rotation axis is along (delta_y, 0, delta_x). The rotation rad is Math.ToRad(Math.Sqrt(delta_y * delta_y + delta_x * delta_x)). public void RotateWithoutHeightAdjustment(double delta_x, double delta_y) Parameters delta_x double delta x in window coordinate delta_y double delta y in window coordinate SetViewToFrontView() Set the SketchView to front view. public void SetViewToFrontView() SetViewToHomeView() Set the SketchView to home view(front view). This is the same as SetViewToFrontView(). public void SetViewToHomeView() SetViewToIsometricView() Set the SketchView to isometric view. public void SetViewToIsometricView() SetViewToRightView() Set the SketchView to side view. public void SetViewToRightView() SetViewToTopView() Set the SketchView to top view. public void SetViewToTopView() Snapshot(string) Snapshot to BMP file with current canvas size. public void Snapshot(string filePath) Parameters filePath string Snapshot(string, int, int) Snapshot to BMP file. public void Snapshot(string filePath, int panelWidth, int panelHeight) Parameters filePath string panelWidth int panelHeight int Start(int, int) Start a thread of keeping Swapping buffers of OpenGL context. If the thread has running, this function does nothing. public void Start(int panelWidth, int panelHeight) Parameters panelWidth int panel width panelHeight int panel height Terminate() Terminate the opengl context swapping buffers thread from Start(int, int). If the thread has not running, this function does nothing. public void Terminate() TouchDown(int, int, int) Tracks a new touch point in the DispEngine's touch gesture system. public void TouchDown(int touchId, int x, int y) Parameters touchId int A unique identifier for the touch point. x int The x-coordinate of the touch point in screen coordinates. y int The y-coordinate of the touch point in screen coordinates. Remarks When a touch point is added, the method: Stores the touch point in the internal tracking dictionary If this is the first touch point, simulates a mouse move and left button press TouchMove(int, int, int) Updates the position of an existing touch point. public void TouchMove(int touchId, int x, int y) Parameters touchId int The unique identifier of the touch point to update. x int The new x-coordinate of the touch point in screen coordinates. y int The new y-coordinate of the touch point in screen coordinates. Remarks The method handles different gestures based on the number of active touch points: Single touch: Performs panning (translation) like mouse dragging Two touches: Performs pinch-to-zoom and rotation gestures TouchUp(int) Removes a touch point from tracking when the touch is released. public void TouchUp(int touchId) Parameters touchId int The unique identifier of the touch point to remove. Remarks When a touch point is released, the method: Removes the touch point from internal tracking dictionaries If all touch points are released, simulates a mouse button release If transitioning from multi-touch to single-touch, updates the mouse position to prevent “teleportation” Translate(double, double) Translate the SketchView. Usually used by mouse drag on window. The translation is (delta_x * 2.0 / h, 0, -delta_y* 2.0 / h). Where h is window height. public void Translate(double delta_x, double delta_y) Parameters delta_x double delta x in window coordinate delta_y double delta y in window coordinate TurnBackView() Rotate view 180 degrees around Z axis to switch to back view. public void TurnBackView() UnlockGlContext(nint) Unlock opengl context. The function is only used for native OpenGL rendering. The function unlock the opengl context for LockGlContext(). public static void UnlockGlContext(nint disp_torch_p) Parameters disp_torch_p nint Events FinishingDisp Event at the begining of FinishDisp() public static event Action FinishingDisp Event Type Action ImageRequestAfterBufferSwapped Triggered after swap buffer of gl context. public event DispEngine.ImageRequestedDelegate ImageRequestAfterBufferSwapped Event Type DispEngine.ImageRequestedDelegate"
  },
  "api/Hi.Disp.DispEngineConfig.html": {
    "href": "api/Hi.Disp.DispEngineConfig.html",
    "title": "Class DispEngineConfig | HiAPI-C# 2025",
    "summary": "Class DispEngineConfig Namespace Hi.Disp Assembly HiDisp.dll Configuration class for display engine. public class DispEngineConfig Inheritance object DispEngineConfig Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors DispEngineConfig() Initializes a new instance of the DispEngineConfig class. public DispEngineConfig() DispEngineConfig(IDisplayee) Initializes a new instance of the DispEngineConfig class with a displayee. public DispEngineConfig(IDisplayee displayee) Parameters displayee IDisplayee The displayee object to be rendered. DispEngineConfig(IDisplayee, Mat4d) Initializes a new instance of the DispEngineConfig class with a displayee and sketch view. public DispEngineConfig(IDisplayee displayee, Mat4d sketchView) Parameters displayee IDisplayee The displayee object to be rendered. sketchView Mat4d The sketch view transformation matrix. Properties Displayee Gets or sets the displayee object to be rendered. public IDisplayee Displayee { get; set; } Property Value IDisplayee SketchView Gets or sets the sketch view transformation matrix. public Mat4d SketchView { get; set; } Property Value Mat4d"
  },
  "api/Hi.Disp.DispFrameUtil.html": {
    "href": "api/Hi.Disp.DispFrameUtil.html",
    "title": "Class DispFrameUtil | HiAPI-C# 2025",
    "summary": "Class DispFrameUtil Namespace Hi.Disp Assembly HiDisp.dll Utility class for display frame management. public static class DispFrameUtil Inheritance object DispFrameUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Properties KeyToDispEngineConfigDictionary Internal Use Only. public static ConcurrentDictionary<object, DispEngineConfig> KeyToDispEngineConfigDictionary { get; } Property Value ConcurrentDictionary<object, DispEngineConfig> UpdateByDispEngineConfigFunc Gets or sets the function to update display engine. public static Action<string, DispEngineConfig> UpdateByDispEngineConfigFunc { get; set; } Property Value Action<string, DispEngineConfig> Methods Call(string, params IDisplayee[]) Configures the display engine with the specified displayees. public static DispEngineConfig Call(string key, params IDisplayee[] displayees) Parameters key string The key to identify the display engine configuration. displayees IDisplayee[] The displayees to be configured. Returns DispEngineConfig The display engine configuration. ClearCache() Clears the cache of display engine configurations. public static void ClearCache() UpdateFrame(string) Internal Use Only. public static void UpdateFrame(string key) Parameters key string The key to identify the display engine configuration."
  },
  "api/Hi.Disp.DispList.html": {
    "href": "api/Hi.Disp.DispList.html",
    "title": "Class DispList | HiAPI-C# 2025",
    "summary": "Class DispList Namespace Hi.Disp Assembly HiDisp.dll A combination of IDisplayee and SynList<T>. public class DispList : SynList<IDisplayee>, IList<IDisplayee>, ICollection<IDisplayee>, IEnumerable<IDisplayee>, IEnumerable, IDisplayee, IExpandToBox3d Inheritance object SynList<IDisplayee> DispList Implements IList<IDisplayee> ICollection<IDisplayee> IEnumerable<IDisplayee> IEnumerable IDisplayee IExpandToBox3d Inherited Members SynList<IDisplayee>.Lock SynList<IDisplayee>.this[int] SynList<IDisplayee>.Count SynList<IDisplayee>.IsReadOnly SynList<IDisplayee>.Data SynList<IDisplayee>.Add(IDisplayee) SynList<IDisplayee>.AddAndGetIndex(IDisplayee) SynList<IDisplayee>.Clear() SynList<IDisplayee>.Contains(IDisplayee) SynList<IDisplayee>.CopyTo(IDisplayee[], int) SynList<IDisplayee>.GetEnumerator() SynList<IDisplayee>.IndexOf(IDisplayee) SynList<IDisplayee>.Insert(int, IDisplayee) SynList<IDisplayee>.Remove(IDisplayee) SynList<IDisplayee>.RemoveAt(int) SynList<IDisplayee>.ToList() object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) DispUtil.Display(IDisplayee, Bind, Mat4d) StringUtil.ToDotSplitedString<T>(IEnumerable<T>) ListUtil.GetCeilBySeek<TItem, TKey>(IList<TItem>, TKey, Func<TItem, TKey>, out TItem, out int, int, SeekDirection) ListUtil.GetCeilIndexBySeek<TItem, TKey>(IList<TItem>, TKey, Func<TItem, TKey>, out int, int, SeekDirection) ListUtil.GetCeilIndex<Item, ItemKey>(IList<Item>, ItemKey, Func<Item, ItemKey, int>, out int) ListUtil.GetCeilIndex<TKey, Item>(IList<Item>, TKey, Func<Item, TKey>, out int) ListUtil.GetCeil<TKey, Item>(IList<Item>, TKey, Func<Item, TKey>, out Item) ListUtil.GetFloorBySeek<TItem, TKey>(IList<TItem>, TKey, Func<TItem, TKey>, out TItem, out int, int, SeekDirection) ListUtil.GetFloorIndexBySeek<TItem, TKey>(IList<TItem>, TKey, Func<TItem, TKey>, out int, int, SeekDirection) ListUtil.GetFloorIndex<Item, ItemKey>(IList<Item>, ItemKey, Func<Item, ItemKey, int>, out int) ListUtil.GetFloorIndex<TKey, Item>(IList<Item>, TKey, Func<Item, TKey>, out int) ListUtil.GetFloor<TKey, Item>(IList<Item>, TKey, Func<Item, TKey>, out Item) ListUtil.GetIndexBasedEnumerable<TItem>(IList<TItem>) ListUtil.GetIndexBasedEnumerable<TItem>(IList<TItem>, int, int) ListUtil.GetIndexByBinarySearch<TItem>(IList<TItem>, TItem) ListUtil.GetIndexByBinarySearch<TItem>(IList<TItem>, TItem, IComparer<TItem>) ListUtil.GetIndexByBinarySearch<TItem, TSearch>(IList<TItem>, TSearch, Func<TSearch, TItem, int>) ListUtil.GetNearestIndex<TItem, TItemKey>(IList<TItem>, TItemKey, Func<TItem, TItemKey, double>, out int) ListUtil.GetNearestIndex<TItem, TItemKey>(IList<TItem>, TItemKey, Func<TItem, TItemKey, int>, Func<TItem, TItemKey, double>, out int) ListUtil.GetSubList<TItem>(IList<TItem>, int, int) ListUtil.Swap<TItem>(IList<TItem>, int, int) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors DispList(DispList) public DispList(DispList src) Parameters src DispList DispList(params IDisplayee[]) public DispList(params IDisplayee[] displayees) Parameters displayees IDisplayee[] DispList(IEnumerable<IDisplayee>) public DispList(IEnumerable<IDisplayee> src) Parameters src IEnumerable<IDisplayee> DispList(int) public DispList(int cap = 8) Parameters cap int Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box"
  },
  "api/Hi.Disp.DispUtil.html": {
    "href": "api/Hi.Disp.DispUtil.html",
    "title": "Class DispUtil | HiAPI-C# 2025",
    "summary": "Class DispUtil Namespace Hi.Disp Assembly HiDisp.dll Display Utility public static class DispUtil Inheritance object DispUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods Display(IDisplayee, Bind, Mat4d) Displays the given displayee with an additional model transform. Internally pushes the transform to the model matrix stack, calls Display, then pops it. public static void Display(this IDisplayee displayee, Bind bind, Mat4d mat) Parameters displayee IDisplayee The displayee to render. bind Bind Rendering bind context. mat Mat4d The model transform to apply. Display(nint, Bind) Display function for native object. public static void Display(nint displayeePtr, Bind bind) Parameters displayeePtr nint natvie object pointer bind Bind bind"
  },
  "api/Hi.Disp.Drawing.html": {
    "href": "api/Hi.Disp.Drawing.html",
    "title": "Class Drawing | HiAPI-C# 2025",
    "summary": "Class Drawing Namespace Hi.Disp Assembly HiDisp.dll The most efficient elemental 3D rendering unit. public class Drawing : IDisplayee, IExpandToBox3d, IDisposable Inheritance object Drawing Implements IDisplayee IExpandToBox3d IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) DispUtil.Display(IDisplayee, Bind, Mat4d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Drawing(double[], Stamp, int) Construct a Drawing. public Drawing(double[] src, Stamp stamp, int glPrimitive) Parameters src double[] src stamp Stamp stamp glPrimitive int gl primitive Properties GlPrimitive OpenGL Primitive. public int GlPrimitive { get; set; } Property Value int KeyStamp The only Stamp of this public Stamp KeyStamp { get; } Property Value Stamp Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. Display(Bind, double[], Stamp, int) Display by the given parameter. public static void Display(Bind bind, double[] src, Stamp stamp, int glPrimitive) Parameters bind Bind bind src double[] src stamp Stamp stamp glPrimitive int gl primitive Display(Bind, int) Display(Bind) with the forced gl primitive. Thread safe for Display(Bind), Display(Bind, int), ExpandToBox3d(Box3d) and Dispose(). public void Display(Bind bind, int forceGlPrimitive) Parameters bind Bind bind forceGlPrimitive int forced gl primitive Dispose() Dispose. Thread safe for Display(Bind), Display(Bind, int), ExpandToBox3d(Box3d) and Dispose(). public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToBox3d(Box3d) Expand to Box. Thread safe for Display(Bind), Display(Bind, int), ExpandToBox3d(Box3d) and Dispose(). public void ExpandToBox3d(Box3d dst) Parameters dst Box3d ~Drawing() protected ~Drawing()"
  },
  "api/Hi.Disp.Flag.ColorScaleBar.html": {
    "href": "api/Hi.Disp.Flag.ColorScaleBar.html",
    "title": "Class ColorScaleBar | HiAPI-C# 2025",
    "summary": "Class ColorScaleBar Namespace Hi.Disp.Flag Assembly HiDisp.dll ColorScaleBar. For Covering mode. public class ColorScaleBar : IDisplayee, IExpandToBox3d Inheritance object ColorScaleBar Implements IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) DispUtil.Display(IDisplayee, Bind, Mat4d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ColorScaleBar(double, double, Func<double, Vec3d>, string, string) Initializes a new instance of the ColorScaleBar class. public ColorScaleBar(double floor, double ceiling, Func<double, Vec3d> rgbFunc, string tag, string unit) Parameters floor double The minimum value for the color scale. ceiling double The maximum value for the color scale. rgbFunc Func<double, Vec3d> The function that converts a value to an RGB color. tag string The tag text for the color scale bar. unit string The unit text for the color scale values. Properties Ceiling Gets or sets the maximum value for the color scale. public double Ceiling { get; set; } Property Value double Floor Gets or sets the minimum value for the color scale. public double Floor { get; set; } Property Value double LengthW Gets the width length of the color scale bar. public static int LengthW { get; } Property Value int OffsetH Gets the vertical offset of the color scale bar. public static double OffsetH { get; } Property Value double OffsetW Gets the horizontal offset of the color scale bar. public static double OffsetW { get; } Property Value double RgbFunc Gets or sets the function that converts a value to an RGB color. public Func<double, Vec3d> RgbFunc { get; set; } Property Value Func<double, Vec3d> Tag Gets or sets the tag text for the color scale bar. public string Tag { get; set; } Property Value string Unit Gets or sets the unit text for the color scale values. public string Unit { get; set; } Property Value string Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. Display(Bind, double, double, Func<double, Vec3d>, string, string) Displays the color scale bar on the specified binding context. public static void Display(Bind bind, double floor, double ceiling, Func<double, Vec3d> rgbFunc, string tag, string unit) Parameters bind Bind The binding context to display on. floor double The minimum value for the color scale. ceiling double The maximum value for the color scale. rgbFunc Func<double, Vec3d> The function that converts a value to an RGB color. tag string The tag text for the color scale bar. unit string The unit text for the color scale values. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box"
  },
  "api/Hi.Disp.Flag.CoordinateDrawing.html": {
    "href": "api/Hi.Disp.Flag.CoordinateDrawing.html",
    "title": "Class CoordinateDrawing | HiAPI-C# 2025",
    "summary": "Class CoordinateDrawing Namespace Hi.Disp.Flag Assembly HiDisp.dll Draw a Cartesian Coordinate. public class CoordinateDrawing : IDisplayee, IExpandToBox3d, IDisposable, IMakeXmlSource Inheritance object CoordinateDrawing Implements IDisplayee IExpandToBox3d IDisposable IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) DispUtil.Display(IDisplayee, Bind, Mat4d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CoordinateDrawing() Ctor. public CoordinateDrawing() CoordinateDrawing(string) Ctor with setter of TextAtOrigin. public CoordinateDrawing(string textAtOrigin) Parameters textAtOrigin string text at origin CoordinateDrawing(XElement) Ctor. public CoordinateDrawing(XElement src) Parameters src XElement XML Properties DimensionInPixels public double DimensionInPixels { get; set; } Property Value double Edge length in pixels. HslOffset public static Vec3d HslOffset { get; set; } Property Value Vec3d HSL offset for coloring this. TextAtOrigin public string TextAtOrigin { get; set; } Property Value string Text displays at the origin of this coordinate. XName Name for XML IO. public static string XName { get; } Property Value string Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. Display(Bind, string) Displays a coordinate drawing with the specified binding context and tag. public static void Display(Bind bind, string tag) Parameters bind Bind The binding context to display on. tag string The tag text to display at the origin. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Disp.Flag.CubicalFlagDrawing.html": {
    "href": "api/Hi.Disp.Flag.CubicalFlagDrawing.html",
    "title": "Class CubicalFlagDrawing | HiAPI-C# 2025",
    "summary": "Class CubicalFlagDrawing Namespace Hi.Disp.Flag Assembly HiDisp.dll A drawing class for cubical flag visualization. public class CubicalFlagDrawing : IDisplayee, IExpandToBox3d Inheritance object CubicalFlagDrawing Implements IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) DispUtil.Display(IDisplayee, Bind, Mat4d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CubicalFlagDrawing(double) Initializes a new instance of the CubicalFlagDrawing class. public CubicalFlagDrawing(double planDim = 16) Parameters planDim double The dimension of the plan. Fields planDim Gets or sets the dimension of the plan. public double planDim Field Value double Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box StaticDisplay(Bind, double) Displays the cubical flag with the specified binding context. public static void StaticDisplay(Bind bind, double planDim = 16) Parameters bind Bind The binding context to display on. planDim double The dimension of the plan."
  },
  "api/Hi.Disp.Flag.DimensionBar.html": {
    "href": "api/Hi.Disp.Flag.DimensionBar.html",
    "title": "Class DimensionBar | HiAPI-C# 2025",
    "summary": "Class DimensionBar Namespace Hi.Disp.Flag Assembly HiDisp.dll DimensionBar. For Covering mode. public class DimensionBar : IDisplayee, IExpandToBox3d Inheritance object DimensionBar Implements IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) DispUtil.Display(IDisplayee, Bind, Mat4d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties OffsetH Gets the vertical offset of the dimension bar. public static double OffsetH { get; } Property Value double Unit Gets or sets the unit of measurement to display. public string Unit { get; set; } Property Value string Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. Display(Bind, string) Displays the dimension bar on the specified binding context. public static void Display(Bind bind, string unit) Parameters bind Bind The binding context to display on. unit string The unit of measurement to display. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box"
  },
  "api/Hi.Disp.Flag.DispCoverUtil.html": {
    "href": "api/Hi.Disp.Flag.DispCoverUtil.html",
    "title": "Class DispCoverUtil | HiAPI-C# 2025",
    "summary": "Class DispCoverUtil Namespace Hi.Disp.Flag Assembly HiDisp.dll Utility class for display covering functionality. public static class DispCoverUtil Inheritance object DispCoverUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields BarGap The gap size between bars in display covering. public const double BarGap = 20 Field Value double BarLineWidth The line width for bars in display covering. public const double BarLineWidth = 2 Field Value double BarPointSize The point size for markers in display covering. public const double BarPointSize = 4 Field Value double"
  },
  "api/Hi.Disp.Flag.html": {
    "href": "api/Hi.Disp.Flag.html",
    "title": "Namespace Hi.Disp.Flag | HiAPI-C# 2025",
    "summary": "Namespace Hi.Disp.Flag Classes ColorScaleBar ColorScaleBar. For Covering mode. CoordinateDrawing Draw a Cartesian Coordinate. CubicalFlagDrawing A drawing class for cubical flag visualization. DimensionBar DimensionBar. For Covering mode. DispCoverUtil Utility class for display covering functionality."
  },
  "api/Hi.Disp.FuncDisplayee.html": {
    "href": "api/Hi.Disp.FuncDisplayee.html",
    "title": "Class FuncDisplayee | HiAPI-C# 2025",
    "summary": "Class FuncDisplayee Namespace Hi.Disp Assembly HiDisp.dll A displayee implementation that delegates display functionality to function delegates. public class FuncDisplayee : IDisplayee, IExpandToBox3d Inheritance object FuncDisplayee Implements IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) DispUtil.Display(IDisplayee, Bind, Mat4d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FuncDisplayee() Initializes a new instance of the FuncDisplayee class. public FuncDisplayee() FuncDisplayee(Action<Bind>, Action<Box3d>) Initializes a new instance of the FuncDisplayee class with display and expand delegates. public FuncDisplayee(Action<Bind> displayDelegate, Action<Box3d> expandToBox3dDelegate) Parameters displayDelegate Action<Bind> The delegate for the Display method. expandToBox3dDelegate Action<Box3d> The delegate for the ExpandToBox3d method. Properties DisplayDelegate Gets or sets the delegate for the Display method. public Action<Bind> DisplayDelegate { get; set; } Property Value Action<Bind> ExpandToBox3dDelegate Gets or sets the delegate for the ExpandToBox3d method. public Action<Box3d> ExpandToBox3dDelegate { get; set; } Property Value Action<Box3d> Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box"
  },
  "api/Hi.Disp.GL.html": {
    "href": "api/Hi.Disp.GL.html",
    "title": "Class GL | HiAPI-C# 2025",
    "summary": "Class GL Namespace Hi.Disp Assembly HiDisp.dll Native opengl functions wrapper. public static class GL Inheritance object GL Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields GL_ACTIVE_ATTRIBUTES public const int GL_ACTIVE_ATTRIBUTES = 35721 Field Value int GL_ACTIVE_ATTRIBUTE_MAX_LENGTH public const int GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = 35722 Field Value int GL_ACTIVE_TEXTURE public const int GL_ACTIVE_TEXTURE = 34016 Field Value int GL_ACTIVE_UNIFORMS public const int GL_ACTIVE_UNIFORMS = 35718 Field Value int GL_ACTIVE_UNIFORM_BLOCKS public const int GL_ACTIVE_UNIFORM_BLOCKS = 35382 Field Value int GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH public const int GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 35381 Field Value int GL_ACTIVE_UNIFORM_MAX_LENGTH public const int GL_ACTIVE_UNIFORM_MAX_LENGTH = 35719 Field Value int GL_ALIASED_LINE_WIDTH_RANGE public const int GL_ALIASED_LINE_WIDTH_RANGE = 33902 Field Value int GL_ALPHA public const int GL_ALPHA = 6406 Field Value int GL_ALREADY_SIGNALED public const int GL_ALREADY_SIGNALED = 37146 Field Value int GL_ALWAYS public const int GL_ALWAYS = 519 Field Value int GL_AND public const int GL_AND = 5377 Field Value int GL_AND_INVERTED public const int GL_AND_INVERTED = 5380 Field Value int GL_AND_REVERSE public const int GL_AND_REVERSE = 5378 Field Value int GL_ANY_SAMPLES_PASSED public const int GL_ANY_SAMPLES_PASSED = 35887 Field Value int GL_ARRAY_BUFFER public const int GL_ARRAY_BUFFER = 34962 Field Value int GL_ARRAY_BUFFER_BINDING public const int GL_ARRAY_BUFFER_BINDING = 34964 Field Value int GL_ATTACHED_SHADERS public const int GL_ATTACHED_SHADERS = 35717 Field Value int GL_BACK public const int GL_BACK = 1029 Field Value int GL_BACK_LEFT public const int GL_BACK_LEFT = 1026 Field Value int GL_BACK_RIGHT public const int GL_BACK_RIGHT = 1027 Field Value int GL_BGR public const int GL_BGR = 32992 Field Value int GL_BGRA public const int GL_BGRA = 32993 Field Value int GL_BGRA_INTEGER public const int GL_BGRA_INTEGER = 36251 Field Value int GL_BGR_INTEGER public const int GL_BGR_INTEGER = 36250 Field Value int GL_BLEND public const int GL_BLEND = 3042 Field Value int GL_BLEND_COLOR public const int GL_BLEND_COLOR = 32773 Field Value int GL_BLEND_DST public const int GL_BLEND_DST = 3040 Field Value int GL_BLEND_DST_ALPHA public const int GL_BLEND_DST_ALPHA = 32970 Field Value int GL_BLEND_DST_RGB public const int GL_BLEND_DST_RGB = 32968 Field Value int GL_BLEND_EQUATION public const int GL_BLEND_EQUATION = 32777 Field Value int GL_BLEND_EQUATION_ALPHA public const int GL_BLEND_EQUATION_ALPHA = 34877 Field Value int GL_BLEND_EQUATION_RGB public const int GL_BLEND_EQUATION_RGB = 32777 Field Value int GL_BLEND_SRC public const int GL_BLEND_SRC = 3041 Field Value int GL_BLEND_SRC_ALPHA public const int GL_BLEND_SRC_ALPHA = 32971 Field Value int GL_BLEND_SRC_RGB public const int GL_BLEND_SRC_RGB = 32969 Field Value int GL_BLUE public const int GL_BLUE = 6405 Field Value int GL_BLUE_INTEGER public const int GL_BLUE_INTEGER = 36246 Field Value int GL_BOOL public const int GL_BOOL = 35670 Field Value int GL_BOOL_VEC2 public const int GL_BOOL_VEC2 = 35671 Field Value int GL_BOOL_VEC3 public const int GL_BOOL_VEC3 = 35672 Field Value int GL_BOOL_VEC4 public const int GL_BOOL_VEC4 = 35673 Field Value int GL_BUFFER_ACCESS public const int GL_BUFFER_ACCESS = 35003 Field Value int GL_BUFFER_ACCESS_FLAGS public const int GL_BUFFER_ACCESS_FLAGS = 37151 Field Value int GL_BUFFER_MAPPED public const int GL_BUFFER_MAPPED = 35004 Field Value int GL_BUFFER_MAP_LENGTH public const int GL_BUFFER_MAP_LENGTH = 37152 Field Value int GL_BUFFER_MAP_OFFSET public const int GL_BUFFER_MAP_OFFSET = 37153 Field Value int GL_BUFFER_MAP_POINTER public const int GL_BUFFER_MAP_POINTER = 35005 Field Value int GL_BUFFER_SIZE public const int GL_BUFFER_SIZE = 34660 Field Value int GL_BUFFER_USAGE public const int GL_BUFFER_USAGE = 34661 Field Value int GL_BYTE public const int GL_BYTE = 5120 Field Value int GL_CCW public const int GL_CCW = 2305 Field Value int GL_CLAMP_READ_COLOR public const int GL_CLAMP_READ_COLOR = 35100 Field Value int GL_CLAMP_TO_BORDER public const int GL_CLAMP_TO_BORDER = 33069 Field Value int GL_CLAMP_TO_EDGE public const int GL_CLAMP_TO_EDGE = 33071 Field Value int GL_CLEAR public const int GL_CLEAR = 5376 Field Value int GL_CLIP_DISTANCE0 public const int GL_CLIP_DISTANCE0 = 12288 Field Value int GL_CLIP_DISTANCE1 public const int GL_CLIP_DISTANCE1 = 12289 Field Value int GL_CLIP_DISTANCE2 public const int GL_CLIP_DISTANCE2 = 12290 Field Value int GL_CLIP_DISTANCE3 public const int GL_CLIP_DISTANCE3 = 12291 Field Value int GL_CLIP_DISTANCE4 public const int GL_CLIP_DISTANCE4 = 12292 Field Value int GL_CLIP_DISTANCE5 public const int GL_CLIP_DISTANCE5 = 12293 Field Value int GL_CLIP_DISTANCE6 public const int GL_CLIP_DISTANCE6 = 12294 Field Value int GL_CLIP_DISTANCE7 public const int GL_CLIP_DISTANCE7 = 12295 Field Value int GL_COLOR public const int GL_COLOR = 6144 Field Value int GL_COLOR_ATTACHMENT0 public const int GL_COLOR_ATTACHMENT0 = 36064 Field Value int GL_COLOR_ATTACHMENT1 public const int GL_COLOR_ATTACHMENT1 = 36065 Field Value int GL_COLOR_ATTACHMENT10 public const int GL_COLOR_ATTACHMENT10 = 36074 Field Value int GL_COLOR_ATTACHMENT11 public const int GL_COLOR_ATTACHMENT11 = 36075 Field Value int GL_COLOR_ATTACHMENT12 public const int GL_COLOR_ATTACHMENT12 = 36076 Field Value int GL_COLOR_ATTACHMENT13 public const int GL_COLOR_ATTACHMENT13 = 36077 Field Value int GL_COLOR_ATTACHMENT14 public const int GL_COLOR_ATTACHMENT14 = 36078 Field Value int GL_COLOR_ATTACHMENT15 public const int GL_COLOR_ATTACHMENT15 = 36079 Field Value int GL_COLOR_ATTACHMENT16 public const int GL_COLOR_ATTACHMENT16 = 36080 Field Value int GL_COLOR_ATTACHMENT17 public const int GL_COLOR_ATTACHMENT17 = 36081 Field Value int GL_COLOR_ATTACHMENT18 public const int GL_COLOR_ATTACHMENT18 = 36082 Field Value int GL_COLOR_ATTACHMENT19 public const int GL_COLOR_ATTACHMENT19 = 36083 Field Value int GL_COLOR_ATTACHMENT2 public const int GL_COLOR_ATTACHMENT2 = 36066 Field Value int GL_COLOR_ATTACHMENT20 public const int GL_COLOR_ATTACHMENT20 = 36084 Field Value int GL_COLOR_ATTACHMENT21 public const int GL_COLOR_ATTACHMENT21 = 36085 Field Value int GL_COLOR_ATTACHMENT22 public const int GL_COLOR_ATTACHMENT22 = 36086 Field Value int GL_COLOR_ATTACHMENT23 public const int GL_COLOR_ATTACHMENT23 = 36087 Field Value int GL_COLOR_ATTACHMENT24 public const int GL_COLOR_ATTACHMENT24 = 36088 Field Value int GL_COLOR_ATTACHMENT25 public const int GL_COLOR_ATTACHMENT25 = 36089 Field Value int GL_COLOR_ATTACHMENT26 public const int GL_COLOR_ATTACHMENT26 = 36090 Field Value int GL_COLOR_ATTACHMENT27 public const int GL_COLOR_ATTACHMENT27 = 36091 Field Value int GL_COLOR_ATTACHMENT28 public const int GL_COLOR_ATTACHMENT28 = 36092 Field Value int GL_COLOR_ATTACHMENT29 public const int GL_COLOR_ATTACHMENT29 = 36093 Field Value int GL_COLOR_ATTACHMENT3 public const int GL_COLOR_ATTACHMENT3 = 36067 Field Value int GL_COLOR_ATTACHMENT30 public const int GL_COLOR_ATTACHMENT30 = 36094 Field Value int GL_COLOR_ATTACHMENT31 public const int GL_COLOR_ATTACHMENT31 = 36095 Field Value int GL_COLOR_ATTACHMENT4 public const int GL_COLOR_ATTACHMENT4 = 36068 Field Value int GL_COLOR_ATTACHMENT5 public const int GL_COLOR_ATTACHMENT5 = 36069 Field Value int GL_COLOR_ATTACHMENT6 public const int GL_COLOR_ATTACHMENT6 = 36070 Field Value int GL_COLOR_ATTACHMENT7 public const int GL_COLOR_ATTACHMENT7 = 36071 Field Value int GL_COLOR_ATTACHMENT8 public const int GL_COLOR_ATTACHMENT8 = 36072 Field Value int GL_COLOR_ATTACHMENT9 public const int GL_COLOR_ATTACHMENT9 = 36073 Field Value int GL_COLOR_BUFFER_BIT public const int GL_COLOR_BUFFER_BIT = 16384 Field Value int GL_COLOR_CLEAR_VALUE public const int GL_COLOR_CLEAR_VALUE = 3106 Field Value int GL_COLOR_LOGIC_OP public const int GL_COLOR_LOGIC_OP = 3058 Field Value int GL_COLOR_WRITEMASK public const int GL_COLOR_WRITEMASK = 3107 Field Value int GL_COMPARE_REF_TO_TEXTURE public const int GL_COMPARE_REF_TO_TEXTURE = 34894 Field Value int GL_COMPILE_STATUS public const int GL_COMPILE_STATUS = 35713 Field Value int GL_COMPRESSED_RED public const int GL_COMPRESSED_RED = 33317 Field Value int GL_COMPRESSED_RED_RGTC1 public const int GL_COMPRESSED_RED_RGTC1 = 36283 Field Value int GL_COMPRESSED_RG public const int GL_COMPRESSED_RG = 33318 Field Value int GL_COMPRESSED_RGB public const int GL_COMPRESSED_RGB = 34029 Field Value int GL_COMPRESSED_RGBA public const int GL_COMPRESSED_RGBA = 34030 Field Value int GL_COMPRESSED_RG_RGTC2 public const int GL_COMPRESSED_RG_RGTC2 = 36285 Field Value int GL_COMPRESSED_SIGNED_RED_RGTC1 public const int GL_COMPRESSED_SIGNED_RED_RGTC1 = 36284 Field Value int GL_COMPRESSED_SIGNED_RG_RGTC2 public const int GL_COMPRESSED_SIGNED_RG_RGTC2 = 36286 Field Value int GL_COMPRESSED_SRGB public const int GL_COMPRESSED_SRGB = 35912 Field Value int GL_COMPRESSED_SRGB_ALPHA public const int GL_COMPRESSED_SRGB_ALPHA = 35913 Field Value int GL_COMPRESSED_TEXTURE_FORMATS public const int GL_COMPRESSED_TEXTURE_FORMATS = 34467 Field Value int GL_CONDITION_SATISFIED public const int GL_CONDITION_SATISFIED = 37148 Field Value int GL_CONSTANT_ALPHA public const int GL_CONSTANT_ALPHA = 32771 Field Value int GL_CONSTANT_COLOR public const int GL_CONSTANT_COLOR = 32769 Field Value int GL_CONTEXT_COMPATIBILITY_PROFILE_BIT public const int GL_CONTEXT_COMPATIBILITY_PROFILE_BIT = 2 Field Value int GL_CONTEXT_CORE_PROFILE_BIT public const int GL_CONTEXT_CORE_PROFILE_BIT = 1 Field Value int GL_CONTEXT_FLAGS public const int GL_CONTEXT_FLAGS = 33310 Field Value int GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT public const int GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 1 Field Value int GL_CONTEXT_PROFILE_MASK public const int GL_CONTEXT_PROFILE_MASK = 37158 Field Value int GL_COPY public const int GL_COPY = 5379 Field Value int GL_COPY_INVERTED public const int GL_COPY_INVERTED = 5388 Field Value int GL_COPY_READ_BUFFER public const int GL_COPY_READ_BUFFER = 36662 Field Value int GL_COPY_WRITE_BUFFER public const int GL_COPY_WRITE_BUFFER = 36663 Field Value int GL_CULL_FACE public const int GL_CULL_FACE = 2884 Field Value int GL_CULL_FACE_MODE public const int GL_CULL_FACE_MODE = 2885 Field Value int GL_CURRENT_PROGRAM public const int GL_CURRENT_PROGRAM = 35725 Field Value int GL_CURRENT_QUERY public const int GL_CURRENT_QUERY = 34917 Field Value int GL_CURRENT_VERTEX_ATTRIB public const int GL_CURRENT_VERTEX_ATTRIB = 34342 Field Value int GL_CW public const int GL_CW = 2304 Field Value int GL_DECR public const int GL_DECR = 7683 Field Value int GL_DECR_WRAP public const int GL_DECR_WRAP = 34056 Field Value int GL_DELETE_STATUS public const int GL_DELETE_STATUS = 35712 Field Value int GL_DEPTH public const int GL_DEPTH = 6145 Field Value int GL_DEPTH24_STENCIL8 public const int GL_DEPTH24_STENCIL8 = 35056 Field Value int GL_DEPTH32F_STENCIL8 public const int GL_DEPTH32F_STENCIL8 = 36013 Field Value int GL_DEPTH_ATTACHMENT public const int GL_DEPTH_ATTACHMENT = 36096 Field Value int GL_DEPTH_BUFFER_BIT public const int GL_DEPTH_BUFFER_BIT = 256 Field Value int GL_DEPTH_CLAMP public const int GL_DEPTH_CLAMP = 34383 Field Value int GL_DEPTH_CLEAR_VALUE public const int GL_DEPTH_CLEAR_VALUE = 2931 Field Value int GL_DEPTH_COMPONENT public const int GL_DEPTH_COMPONENT = 6402 Field Value int GL_DEPTH_COMPONENT16 public const int GL_DEPTH_COMPONENT16 = 33189 Field Value int GL_DEPTH_COMPONENT24 public const int GL_DEPTH_COMPONENT24 = 33190 Field Value int GL_DEPTH_COMPONENT32 public const int GL_DEPTH_COMPONENT32 = 33191 Field Value int GL_DEPTH_COMPONENT32F public const int GL_DEPTH_COMPONENT32F = 36012 Field Value int GL_DEPTH_FUNC public const int GL_DEPTH_FUNC = 2932 Field Value int GL_DEPTH_RANGE public const int GL_DEPTH_RANGE = 2928 Field Value int GL_DEPTH_STENCIL public const int GL_DEPTH_STENCIL = 34041 Field Value int GL_DEPTH_STENCIL_ATTACHMENT public const int GL_DEPTH_STENCIL_ATTACHMENT = 33306 Field Value int GL_DEPTH_TEST public const int GL_DEPTH_TEST = 2929 Field Value int GL_DEPTH_WRITEMASK public const int GL_DEPTH_WRITEMASK = 2930 Field Value int GL_DITHER public const int GL_DITHER = 3024 Field Value int GL_DONT_CARE public const int GL_DONT_CARE = 4352 Field Value int GL_DOUBLE public const int GL_DOUBLE = 5130 Field Value int GL_DOUBLEBUFFER public const int GL_DOUBLEBUFFER = 3122 Field Value int GL_DRAW_BUFFER public const int GL_DRAW_BUFFER = 3073 Field Value int GL_DRAW_BUFFER0 public const int GL_DRAW_BUFFER0 = 34853 Field Value int GL_DRAW_BUFFER1 public const int GL_DRAW_BUFFER1 = 34854 Field Value int GL_DRAW_BUFFER10 public const int GL_DRAW_BUFFER10 = 34863 Field Value int GL_DRAW_BUFFER11 public const int GL_DRAW_BUFFER11 = 34864 Field Value int GL_DRAW_BUFFER12 public const int GL_DRAW_BUFFER12 = 34865 Field Value int GL_DRAW_BUFFER13 public const int GL_DRAW_BUFFER13 = 34866 Field Value int GL_DRAW_BUFFER14 public const int GL_DRAW_BUFFER14 = 34867 Field Value int GL_DRAW_BUFFER15 public const int GL_DRAW_BUFFER15 = 34868 Field Value int GL_DRAW_BUFFER2 public const int GL_DRAW_BUFFER2 = 34855 Field Value int GL_DRAW_BUFFER3 public const int GL_DRAW_BUFFER3 = 34856 Field Value int GL_DRAW_BUFFER4 public const int GL_DRAW_BUFFER4 = 34857 Field Value int GL_DRAW_BUFFER5 public const int GL_DRAW_BUFFER5 = 34858 Field Value int GL_DRAW_BUFFER6 public const int GL_DRAW_BUFFER6 = 34859 Field Value int GL_DRAW_BUFFER7 public const int GL_DRAW_BUFFER7 = 34860 Field Value int GL_DRAW_BUFFER8 public const int GL_DRAW_BUFFER8 = 34861 Field Value int GL_DRAW_BUFFER9 public const int GL_DRAW_BUFFER9 = 34862 Field Value int GL_DRAW_FRAMEBUFFER public const int GL_DRAW_FRAMEBUFFER = 36009 Field Value int GL_DRAW_FRAMEBUFFER_BINDING public const int GL_DRAW_FRAMEBUFFER_BINDING = 36006 Field Value int GL_DST_ALPHA public const int GL_DST_ALPHA = 772 Field Value int GL_DST_COLOR public const int GL_DST_COLOR = 774 Field Value int GL_DYNAMIC_COPY public const int GL_DYNAMIC_COPY = 35050 Field Value int GL_DYNAMIC_DRAW public const int GL_DYNAMIC_DRAW = 35048 Field Value int GL_DYNAMIC_READ public const int GL_DYNAMIC_READ = 35049 Field Value int GL_ELEMENT_ARRAY_BUFFER public const int GL_ELEMENT_ARRAY_BUFFER = 34963 Field Value int GL_ELEMENT_ARRAY_BUFFER_BINDING public const int GL_ELEMENT_ARRAY_BUFFER_BINDING = 34965 Field Value int GL_EQUAL public const int GL_EQUAL = 514 Field Value int GL_EQUIV public const int GL_EQUIV = 5385 Field Value int GL_EXTENSIONS public const int GL_EXTENSIONS = 7939 Field Value int GL_FALSE public const int GL_FALSE = 0 Field Value int GL_FASTEST public const int GL_FASTEST = 4353 Field Value int GL_FILL public const int GL_FILL = 6914 Field Value int GL_FIRST_VERTEX_CONVENTION public const int GL_FIRST_VERTEX_CONVENTION = 36429 Field Value int GL_FIXED_ONLY public const int GL_FIXED_ONLY = 35101 Field Value int GL_FLOAT public const int GL_FLOAT = 5126 Field Value int GL_FLOAT_32_UNSIGNED_INT_24_8_REV public const int GL_FLOAT_32_UNSIGNED_INT_24_8_REV = 36269 Field Value int GL_FLOAT_MAT2 public const int GL_FLOAT_MAT2 = 35674 Field Value int GL_FLOAT_MAT2x3 public const int GL_FLOAT_MAT2x3 = 35685 Field Value int GL_FLOAT_MAT2x4 public const int GL_FLOAT_MAT2x4 = 35686 Field Value int GL_FLOAT_MAT3 public const int GL_FLOAT_MAT3 = 35675 Field Value int GL_FLOAT_MAT3x2 public const int GL_FLOAT_MAT3x2 = 35687 Field Value int GL_FLOAT_MAT3x4 public const int GL_FLOAT_MAT3x4 = 35688 Field Value int GL_FLOAT_MAT4 public const int GL_FLOAT_MAT4 = 35676 Field Value int GL_FLOAT_MAT4x2 public const int GL_FLOAT_MAT4x2 = 35689 Field Value int GL_FLOAT_MAT4x3 public const int GL_FLOAT_MAT4x3 = 35690 Field Value int GL_FLOAT_VEC2 public const int GL_FLOAT_VEC2 = 35664 Field Value int GL_FLOAT_VEC3 public const int GL_FLOAT_VEC3 = 35665 Field Value int GL_FLOAT_VEC4 public const int GL_FLOAT_VEC4 = 35666 Field Value int GL_FRAGMENT_SHADER public const int GL_FRAGMENT_SHADER = 35632 Field Value int GL_FRAGMENT_SHADER_DERIVATIVE_HINT public const int GL_FRAGMENT_SHADER_DERIVATIVE_HINT = 35723 Field Value int GL_FRAMEBUFFER public const int GL_FRAMEBUFFER = 36160 Field Value int GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE public const int GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 33301 Field Value int GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE public const int GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 33300 Field Value int GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING public const int GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 33296 Field Value int GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE public const int GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 33297 Field Value int GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE public const int GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 33302 Field Value int GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE public const int GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 33299 Field Value int GL_FRAMEBUFFER_ATTACHMENT_LAYERED public const int GL_FRAMEBUFFER_ATTACHMENT_LAYERED = 36263 Field Value int GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME public const int GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 36049 Field Value int GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE public const int GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 36048 Field Value int GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE public const int GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE = 33298 Field Value int GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE public const int GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 33303 Field Value int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE public const int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 36051 Field Value int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER public const int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 36052 Field Value int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL public const int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 36050 Field Value int GL_FRAMEBUFFER_BINDING public const int GL_FRAMEBUFFER_BINDING = 36006 Field Value int GL_FRAMEBUFFER_COMPLETE public const int GL_FRAMEBUFFER_COMPLETE = 36053 Field Value int GL_FRAMEBUFFER_DEFAULT public const int GL_FRAMEBUFFER_DEFAULT = 33304 Field Value int GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT public const int GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 36054 Field Value int GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER public const int GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 36059 Field Value int GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS public const int GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 36264 Field Value int GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT public const int GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 36055 Field Value int GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE public const int GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 36182 Field Value int GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER public const int GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 36060 Field Value int GL_FRAMEBUFFER_SRGB public const int GL_FRAMEBUFFER_SRGB = 36281 Field Value int GL_FRAMEBUFFER_UNDEFINED public const int GL_FRAMEBUFFER_UNDEFINED = 33305 Field Value int GL_FRAMEBUFFER_UNSUPPORTED public const int GL_FRAMEBUFFER_UNSUPPORTED = 36061 Field Value int GL_FRONT public const int GL_FRONT = 1028 Field Value int GL_FRONT_AND_BACK public const int GL_FRONT_AND_BACK = 1032 Field Value int GL_FRONT_FACE public const int GL_FRONT_FACE = 2886 Field Value int GL_FRONT_LEFT public const int GL_FRONT_LEFT = 1024 Field Value int GL_FRONT_RIGHT public const int GL_FRONT_RIGHT = 1025 Field Value int GL_FUNC_ADD public const int GL_FUNC_ADD = 32774 Field Value int GL_FUNC_REVERSE_SUBTRACT public const int GL_FUNC_REVERSE_SUBTRACT = 32779 Field Value int GL_FUNC_SUBTRACT public const int GL_FUNC_SUBTRACT = 32778 Field Value int GL_GEOMETRY_INPUT_TYPE public const int GL_GEOMETRY_INPUT_TYPE = 35095 Field Value int GL_GEOMETRY_OUTPUT_TYPE public const int GL_GEOMETRY_OUTPUT_TYPE = 35096 Field Value int GL_GEOMETRY_SHADER public const int GL_GEOMETRY_SHADER = 36313 Field Value int GL_GEOMETRY_VERTICES_OUT public const int GL_GEOMETRY_VERTICES_OUT = 35094 Field Value int GL_GEQUAL public const int GL_GEQUAL = 518 Field Value int GL_GREATER public const int GL_GREATER = 516 Field Value int GL_GREEN public const int GL_GREEN = 6404 Field Value int GL_GREEN_INTEGER public const int GL_GREEN_INTEGER = 36245 Field Value int GL_INCR public const int GL_INCR = 7682 Field Value int GL_INCR_WRAP public const int GL_INCR_WRAP = 34055 Field Value int GL_INFO_LOG_LENGTH public const int GL_INFO_LOG_LENGTH = 35716 Field Value int GL_INT public const int GL_INT = 5124 Field Value int GL_INTERLEAVED_ATTRIBS public const int GL_INTERLEAVED_ATTRIBS = 35980 Field Value int GL_INT_2_10_10_10_REV public const int GL_INT_2_10_10_10_REV = 36255 Field Value int GL_INT_SAMPLER_1D public const int GL_INT_SAMPLER_1D = 36297 Field Value int GL_INT_SAMPLER_1D_ARRAY public const int GL_INT_SAMPLER_1D_ARRAY = 36302 Field Value int GL_INT_SAMPLER_2D public const int GL_INT_SAMPLER_2D = 36298 Field Value int GL_INT_SAMPLER_2D_ARRAY public const int GL_INT_SAMPLER_2D_ARRAY = 36303 Field Value int GL_INT_SAMPLER_2D_MULTISAMPLE public const int GL_INT_SAMPLER_2D_MULTISAMPLE = 37129 Field Value int GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY public const int GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 37132 Field Value int GL_INT_SAMPLER_2D_RECT public const int GL_INT_SAMPLER_2D_RECT = 36301 Field Value int GL_INT_SAMPLER_3D public const int GL_INT_SAMPLER_3D = 36299 Field Value int GL_INT_SAMPLER_BUFFER public const int GL_INT_SAMPLER_BUFFER = 36304 Field Value int GL_INT_SAMPLER_CUBE public const int GL_INT_SAMPLER_CUBE = 36300 Field Value int GL_INT_VEC2 public const int GL_INT_VEC2 = 35667 Field Value int GL_INT_VEC3 public const int GL_INT_VEC3 = 35668 Field Value int GL_INT_VEC4 public const int GL_INT_VEC4 = 35669 Field Value int GL_INVALID_ENUM public const int GL_INVALID_ENUM = 1280 Field Value int GL_INVALID_FRAMEBUFFER_OPERATION public const int GL_INVALID_FRAMEBUFFER_OPERATION = 1286 Field Value int GL_INVALID_INDEX public const uint GL_INVALID_INDEX = 4294967295 Field Value uint GL_INVALID_OPERATION public const int GL_INVALID_OPERATION = 1282 Field Value int GL_INVALID_VALUE public const int GL_INVALID_VALUE = 1281 Field Value int GL_INVERT public const int GL_INVERT = 5386 Field Value int GL_KEEP public const int GL_KEEP = 7680 Field Value int GL_LAST_VERTEX_CONVENTION public const int GL_LAST_VERTEX_CONVENTION = 36430 Field Value int GL_LEFT public const int GL_LEFT = 1030 Field Value int GL_LEQUAL public const int GL_LEQUAL = 515 Field Value int GL_LESS public const int GL_LESS = 513 Field Value int GL_LINE public const int GL_LINE = 6913 Field Value int GL_LINEAR public const int GL_LINEAR = 9729 Field Value int GL_LINEAR_MIPMAP_LINEAR public const int GL_LINEAR_MIPMAP_LINEAR = 9987 Field Value int GL_LINEAR_MIPMAP_NEAREST public const int GL_LINEAR_MIPMAP_NEAREST = 9985 Field Value int GL_LINES public const int GL_LINES = 1 Field Value int GL_LINES_ADJACENCY public const int GL_LINES_ADJACENCY = 10 Field Value int GL_LINE_LOOP public const int GL_LINE_LOOP = 2 Field Value int GL_LINE_SMOOTH public const int GL_LINE_SMOOTH = 2848 Field Value int GL_LINE_SMOOTH_HINT public const int GL_LINE_SMOOTH_HINT = 3154 Field Value int GL_LINE_STRIP public const int GL_LINE_STRIP = 3 Field Value int GL_LINE_STRIP_ADJACENCY public const int GL_LINE_STRIP_ADJACENCY = 11 Field Value int GL_LINE_WIDTH public const int GL_LINE_WIDTH = 2849 Field Value int GL_LINE_WIDTH_GRANULARITY public const int GL_LINE_WIDTH_GRANULARITY = 2851 Field Value int GL_LINE_WIDTH_RANGE public const int GL_LINE_WIDTH_RANGE = 2850 Field Value int GL_LINK_STATUS public const int GL_LINK_STATUS = 35714 Field Value int GL_LOGIC_OP_MODE public const int GL_LOGIC_OP_MODE = 3056 Field Value int GL_LOWER_LEFT public const int GL_LOWER_LEFT = 36001 Field Value int GL_MAJOR_VERSION public const int GL_MAJOR_VERSION = 33307 Field Value int GL_MAP_FLUSH_EXPLICIT_BIT public const int GL_MAP_FLUSH_EXPLICIT_BIT = 16 Field Value int GL_MAP_INVALIDATE_BUFFER_BIT public const int GL_MAP_INVALIDATE_BUFFER_BIT = 8 Field Value int GL_MAP_INVALIDATE_RANGE_BIT public const int GL_MAP_INVALIDATE_RANGE_BIT = 4 Field Value int GL_MAP_READ_BIT public const int GL_MAP_READ_BIT = 1 Field Value int GL_MAP_UNSYNCHRONIZED_BIT public const int GL_MAP_UNSYNCHRONIZED_BIT = 32 Field Value int GL_MAP_WRITE_BIT public const int GL_MAP_WRITE_BIT = 2 Field Value int GL_MAX public const int GL_MAX = 32776 Field Value int GL_MAX_3D_TEXTURE_SIZE public const int GL_MAX_3D_TEXTURE_SIZE = 32883 Field Value int GL_MAX_ARRAY_TEXTURE_LAYERS public const int GL_MAX_ARRAY_TEXTURE_LAYERS = 35071 Field Value int GL_MAX_CLIP_DISTANCES public const int GL_MAX_CLIP_DISTANCES = 3378 Field Value int GL_MAX_COLOR_ATTACHMENTS public const int GL_MAX_COLOR_ATTACHMENTS = 36063 Field Value int GL_MAX_COLOR_TEXTURE_SAMPLES public const int GL_MAX_COLOR_TEXTURE_SAMPLES = 37134 Field Value int GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS public const int GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 35379 Field Value int GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS public const int GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 35378 Field Value int GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS public const int GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = 35661 Field Value int GL_MAX_COMBINED_UNIFORM_BLOCKS public const int GL_MAX_COMBINED_UNIFORM_BLOCKS = 35374 Field Value int GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS public const int GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 35377 Field Value int GL_MAX_CUBE_MAP_TEXTURE_SIZE public const int GL_MAX_CUBE_MAP_TEXTURE_SIZE = 34076 Field Value int GL_MAX_DEPTH_TEXTURE_SAMPLES public const int GL_MAX_DEPTH_TEXTURE_SAMPLES = 37135 Field Value int GL_MAX_DRAW_BUFFERS public const int GL_MAX_DRAW_BUFFERS = 34852 Field Value int GL_MAX_DUAL_SOURCE_DRAW_BUFFERS public const int GL_MAX_DUAL_SOURCE_DRAW_BUFFERS = 35068 Field Value int GL_MAX_ELEMENTS_INDICES public const int GL_MAX_ELEMENTS_INDICES = 33001 Field Value int GL_MAX_ELEMENTS_VERTICES public const int GL_MAX_ELEMENTS_VERTICES = 33000 Field Value int GL_MAX_FRAGMENT_INPUT_COMPONENTS public const int GL_MAX_FRAGMENT_INPUT_COMPONENTS = 37157 Field Value int GL_MAX_FRAGMENT_UNIFORM_BLOCKS public const int GL_MAX_FRAGMENT_UNIFORM_BLOCKS = 35373 Field Value int GL_MAX_FRAGMENT_UNIFORM_COMPONENTS public const int GL_MAX_FRAGMENT_UNIFORM_COMPONENTS = 35657 Field Value int GL_MAX_GEOMETRY_INPUT_COMPONENTS public const int GL_MAX_GEOMETRY_INPUT_COMPONENTS = 37155 Field Value int GL_MAX_GEOMETRY_OUTPUT_COMPONENTS public const int GL_MAX_GEOMETRY_OUTPUT_COMPONENTS = 37156 Field Value int GL_MAX_GEOMETRY_OUTPUT_VERTICES public const int GL_MAX_GEOMETRY_OUTPUT_VERTICES = 36320 Field Value int GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS public const int GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 35881 Field Value int GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS public const int GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 36321 Field Value int GL_MAX_GEOMETRY_UNIFORM_BLOCKS public const int GL_MAX_GEOMETRY_UNIFORM_BLOCKS = 35372 Field Value int GL_MAX_GEOMETRY_UNIFORM_COMPONENTS public const int GL_MAX_GEOMETRY_UNIFORM_COMPONENTS = 36319 Field Value int GL_MAX_INTEGER_SAMPLES public const int GL_MAX_INTEGER_SAMPLES = 37136 Field Value int GL_MAX_PROGRAM_TEXEL_OFFSET public const int GL_MAX_PROGRAM_TEXEL_OFFSET = 35077 Field Value int GL_MAX_RECTANGLE_TEXTURE_SIZE public const int GL_MAX_RECTANGLE_TEXTURE_SIZE = 34040 Field Value int GL_MAX_RENDERBUFFER_SIZE public const int GL_MAX_RENDERBUFFER_SIZE = 34024 Field Value int GL_MAX_SAMPLES public const int GL_MAX_SAMPLES = 36183 Field Value int GL_MAX_SAMPLE_MASK_WORDS public const int GL_MAX_SAMPLE_MASK_WORDS = 36441 Field Value int GL_MAX_SERVER_WAIT_TIMEOUT public const int GL_MAX_SERVER_WAIT_TIMEOUT = 37137 Field Value int GL_MAX_TEXTURE_BUFFER_SIZE public const int GL_MAX_TEXTURE_BUFFER_SIZE = 35883 Field Value int GL_MAX_TEXTURE_IMAGE_UNITS public const int GL_MAX_TEXTURE_IMAGE_UNITS = 34930 Field Value int GL_MAX_TEXTURE_LOD_BIAS public const int GL_MAX_TEXTURE_LOD_BIAS = 34045 Field Value int GL_MAX_TEXTURE_SIZE public const int GL_MAX_TEXTURE_SIZE = 3379 Field Value int GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS public const int GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 35978 Field Value int GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS public const int GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 35979 Field Value int GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS public const int GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 35968 Field Value int GL_MAX_UNIFORM_BLOCK_SIZE public const int GL_MAX_UNIFORM_BLOCK_SIZE = 35376 Field Value int GL_MAX_UNIFORM_BUFFER_BINDINGS public const int GL_MAX_UNIFORM_BUFFER_BINDINGS = 35375 Field Value int GL_MAX_VARYING_COMPONENTS public const int GL_MAX_VARYING_COMPONENTS = 35659 Field Value int GL_MAX_VARYING_FLOATS public const int GL_MAX_VARYING_FLOATS = 35659 Field Value int GL_MAX_VERTEX_ATTRIBS public const int GL_MAX_VERTEX_ATTRIBS = 34921 Field Value int GL_MAX_VERTEX_OUTPUT_COMPONENTS public const int GL_MAX_VERTEX_OUTPUT_COMPONENTS = 37154 Field Value int GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS public const int GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = 35660 Field Value int GL_MAX_VERTEX_UNIFORM_BLOCKS public const int GL_MAX_VERTEX_UNIFORM_BLOCKS = 35371 Field Value int GL_MAX_VERTEX_UNIFORM_COMPONENTS public const int GL_MAX_VERTEX_UNIFORM_COMPONENTS = 35658 Field Value int GL_MAX_VIEWPORT_DIMS public const int GL_MAX_VIEWPORT_DIMS = 3386 Field Value int GL_MIN public const int GL_MIN = 32775 Field Value int GL_MINOR_VERSION public const int GL_MINOR_VERSION = 33308 Field Value int GL_MIN_PROGRAM_TEXEL_OFFSET public const int GL_MIN_PROGRAM_TEXEL_OFFSET = 35076 Field Value int GL_MIRRORED_REPEAT public const int GL_MIRRORED_REPEAT = 33648 Field Value int GL_MULTISAMPLE public const int GL_MULTISAMPLE = 32925 Field Value int GL_NAND public const int GL_NAND = 5390 Field Value int GL_NEAREST public const int GL_NEAREST = 9728 Field Value int GL_NEAREST_MIPMAP_LINEAR public const int GL_NEAREST_MIPMAP_LINEAR = 9986 Field Value int GL_NEAREST_MIPMAP_NEAREST public const int GL_NEAREST_MIPMAP_NEAREST = 9984 Field Value int GL_NEVER public const int GL_NEVER = 512 Field Value int GL_NICEST public const int GL_NICEST = 4354 Field Value int GL_NONE public const int GL_NONE = 0 Field Value int GL_NOOP public const int GL_NOOP = 5381 Field Value int GL_NOR public const int GL_NOR = 5384 Field Value int GL_NOTEQUAL public const int GL_NOTEQUAL = 517 Field Value int GL_NO_ERROR public const int GL_NO_ERROR = 0 Field Value int GL_NUM_COMPRESSED_TEXTURE_FORMATS public const int GL_NUM_COMPRESSED_TEXTURE_FORMATS = 34466 Field Value int GL_NUM_EXTENSIONS public const int GL_NUM_EXTENSIONS = 33309 Field Value int GL_OBJECT_TYPE public const int GL_OBJECT_TYPE = 37138 Field Value int GL_ONE public const int GL_ONE = 1 Field Value int GL_ONE_MINUS_CONSTANT_ALPHA public const int GL_ONE_MINUS_CONSTANT_ALPHA = 32772 Field Value int GL_ONE_MINUS_CONSTANT_COLOR public const int GL_ONE_MINUS_CONSTANT_COLOR = 32770 Field Value int GL_ONE_MINUS_DST_ALPHA public const int GL_ONE_MINUS_DST_ALPHA = 773 Field Value int GL_ONE_MINUS_DST_COLOR public const int GL_ONE_MINUS_DST_COLOR = 775 Field Value int GL_ONE_MINUS_SRC1_ALPHA public const int GL_ONE_MINUS_SRC1_ALPHA = 35067 Field Value int GL_ONE_MINUS_SRC1_COLOR public const int GL_ONE_MINUS_SRC1_COLOR = 35066 Field Value int GL_ONE_MINUS_SRC_ALPHA public const int GL_ONE_MINUS_SRC_ALPHA = 771 Field Value int GL_ONE_MINUS_SRC_COLOR public const int GL_ONE_MINUS_SRC_COLOR = 769 Field Value int GL_OR public const int GL_OR = 5383 Field Value int GL_OR_INVERTED public const int GL_OR_INVERTED = 5389 Field Value int GL_OR_REVERSE public const int GL_OR_REVERSE = 5387 Field Value int GL_OUT_OF_MEMORY public const int GL_OUT_OF_MEMORY = 1285 Field Value int GL_PACK_ALIGNMENT public const int GL_PACK_ALIGNMENT = 3333 Field Value int GL_PACK_IMAGE_HEIGHT public const int GL_PACK_IMAGE_HEIGHT = 32876 Field Value int GL_PACK_LSB_FIRST public const int GL_PACK_LSB_FIRST = 3329 Field Value int GL_PACK_ROW_LENGTH public const int GL_PACK_ROW_LENGTH = 3330 Field Value int GL_PACK_SKIP_IMAGES public const int GL_PACK_SKIP_IMAGES = 32875 Field Value int GL_PACK_SKIP_PIXELS public const int GL_PACK_SKIP_PIXELS = 3332 Field Value int GL_PACK_SKIP_ROWS public const int GL_PACK_SKIP_ROWS = 3331 Field Value int GL_PACK_SWAP_BYTES public const int GL_PACK_SWAP_BYTES = 3328 Field Value int GL_PIXEL_PACK_BUFFER public const int GL_PIXEL_PACK_BUFFER = 35051 Field Value int GL_PIXEL_PACK_BUFFER_BINDING public const int GL_PIXEL_PACK_BUFFER_BINDING = 35053 Field Value int GL_PIXEL_UNPACK_BUFFER public const int GL_PIXEL_UNPACK_BUFFER = 35052 Field Value int GL_PIXEL_UNPACK_BUFFER_BINDING public const int GL_PIXEL_UNPACK_BUFFER_BINDING = 35055 Field Value int GL_POINT public const int GL_POINT = 6912 Field Value int GL_POINTS public const int GL_POINTS = 0 Field Value int GL_POINT_FADE_THRESHOLD_SIZE public const int GL_POINT_FADE_THRESHOLD_SIZE = 33064 Field Value int GL_POINT_SIZE public const int GL_POINT_SIZE = 2833 Field Value int GL_POINT_SIZE_GRANULARITY public const int GL_POINT_SIZE_GRANULARITY = 2835 Field Value int GL_POINT_SIZE_RANGE public const int GL_POINT_SIZE_RANGE = 2834 Field Value int GL_POINT_SPRITE_COORD_ORIGIN public const int GL_POINT_SPRITE_COORD_ORIGIN = 36000 Field Value int GL_POLYGON_MODE public const int GL_POLYGON_MODE = 2880 Field Value int GL_POLYGON_OFFSET_FACTOR public const int GL_POLYGON_OFFSET_FACTOR = 32824 Field Value int GL_POLYGON_OFFSET_FILL public const int GL_POLYGON_OFFSET_FILL = 32823 Field Value int GL_POLYGON_OFFSET_LINE public const int GL_POLYGON_OFFSET_LINE = 10754 Field Value int GL_POLYGON_OFFSET_POINT public const int GL_POLYGON_OFFSET_POINT = 10753 Field Value int GL_POLYGON_OFFSET_UNITS public const int GL_POLYGON_OFFSET_UNITS = 10752 Field Value int GL_POLYGON_SMOOTH public const int GL_POLYGON_SMOOTH = 2881 Field Value int GL_POLYGON_SMOOTH_HINT public const int GL_POLYGON_SMOOTH_HINT = 3155 Field Value int GL_PRIMITIVES_GENERATED public const int GL_PRIMITIVES_GENERATED = 35975 Field Value int GL_PRIMITIVE_RESTART public const int GL_PRIMITIVE_RESTART = 36765 Field Value int GL_PRIMITIVE_RESTART_INDEX public const int GL_PRIMITIVE_RESTART_INDEX = 36766 Field Value int GL_PROGRAM_POINT_SIZE public const int GL_PROGRAM_POINT_SIZE = 34370 Field Value int GL_PROVOKING_VERTEX public const int GL_PROVOKING_VERTEX = 36431 Field Value int GL_PROXY_TEXTURE_1D public const int GL_PROXY_TEXTURE_1D = 32867 Field Value int GL_PROXY_TEXTURE_1D_ARRAY public const int GL_PROXY_TEXTURE_1D_ARRAY = 35865 Field Value int GL_PROXY_TEXTURE_2D public const int GL_PROXY_TEXTURE_2D = 32868 Field Value int GL_PROXY_TEXTURE_2D_ARRAY public const int GL_PROXY_TEXTURE_2D_ARRAY = 35867 Field Value int GL_PROXY_TEXTURE_2D_MULTISAMPLE public const int GL_PROXY_TEXTURE_2D_MULTISAMPLE = 37121 Field Value int GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY public const int GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 37123 Field Value int GL_PROXY_TEXTURE_3D public const int GL_PROXY_TEXTURE_3D = 32880 Field Value int GL_PROXY_TEXTURE_CUBE_MAP public const int GL_PROXY_TEXTURE_CUBE_MAP = 34075 Field Value int GL_PROXY_TEXTURE_RECTANGLE public const int GL_PROXY_TEXTURE_RECTANGLE = 34039 Field Value int GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION public const int GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 36428 Field Value int GL_QUERY_BY_REGION_NO_WAIT public const int GL_QUERY_BY_REGION_NO_WAIT = 36374 Field Value int GL_QUERY_BY_REGION_WAIT public const int GL_QUERY_BY_REGION_WAIT = 36373 Field Value int GL_QUERY_COUNTER_BITS public const int GL_QUERY_COUNTER_BITS = 34916 Field Value int GL_QUERY_NO_WAIT public const int GL_QUERY_NO_WAIT = 36372 Field Value int GL_QUERY_RESULT public const int GL_QUERY_RESULT = 34918 Field Value int GL_QUERY_RESULT_AVAILABLE public const int GL_QUERY_RESULT_AVAILABLE = 34919 Field Value int GL_QUERY_WAIT public const int GL_QUERY_WAIT = 36371 Field Value int GL_R11F_G11F_B10F public const int GL_R11F_G11F_B10F = 35898 Field Value int GL_R16 public const int GL_R16 = 33322 Field Value int GL_R16F public const int GL_R16F = 33325 Field Value int GL_R16I public const int GL_R16I = 33331 Field Value int GL_R16UI public const int GL_R16UI = 33332 Field Value int GL_R16_SNORM public const int GL_R16_SNORM = 36760 Field Value int GL_R32F public const int GL_R32F = 33326 Field Value int GL_R32I public const int GL_R32I = 33333 Field Value int GL_R32UI public const int GL_R32UI = 33334 Field Value int GL_R3_G3_B2 public const int GL_R3_G3_B2 = 10768 Field Value int GL_R8 public const int GL_R8 = 33321 Field Value int GL_R8I public const int GL_R8I = 33329 Field Value int GL_R8UI public const int GL_R8UI = 33330 Field Value int GL_R8_SNORM public const int GL_R8_SNORM = 36756 Field Value int GL_RASTERIZER_DISCARD public const int GL_RASTERIZER_DISCARD = 35977 Field Value int GL_READ_BUFFER public const int GL_READ_BUFFER = 3074 Field Value int GL_READ_FRAMEBUFFER public const int GL_READ_FRAMEBUFFER = 36008 Field Value int GL_READ_FRAMEBUFFER_BINDING public const int GL_READ_FRAMEBUFFER_BINDING = 36010 Field Value int GL_READ_ONLY public const int GL_READ_ONLY = 35000 Field Value int GL_READ_WRITE public const int GL_READ_WRITE = 35002 Field Value int GL_RED public const int GL_RED = 6403 Field Value int GL_RED_INTEGER public const int GL_RED_INTEGER = 36244 Field Value int GL_RENDERBUFFER public const int GL_RENDERBUFFER = 36161 Field Value int GL_RENDERBUFFER_ALPHA_SIZE public const int GL_RENDERBUFFER_ALPHA_SIZE = 36179 Field Value int GL_RENDERBUFFER_BINDING public const int GL_RENDERBUFFER_BINDING = 36007 Field Value int GL_RENDERBUFFER_BLUE_SIZE public const int GL_RENDERBUFFER_BLUE_SIZE = 36178 Field Value int GL_RENDERBUFFER_DEPTH_SIZE public const int GL_RENDERBUFFER_DEPTH_SIZE = 36180 Field Value int GL_RENDERBUFFER_GREEN_SIZE public const int GL_RENDERBUFFER_GREEN_SIZE = 36177 Field Value int GL_RENDERBUFFER_HEIGHT public const int GL_RENDERBUFFER_HEIGHT = 36163 Field Value int GL_RENDERBUFFER_INTERNAL_FORMAT public const int GL_RENDERBUFFER_INTERNAL_FORMAT = 36164 Field Value int GL_RENDERBUFFER_RED_SIZE public const int GL_RENDERBUFFER_RED_SIZE = 36176 Field Value int GL_RENDERBUFFER_SAMPLES public const int GL_RENDERBUFFER_SAMPLES = 36011 Field Value int GL_RENDERBUFFER_STENCIL_SIZE public const int GL_RENDERBUFFER_STENCIL_SIZE = 36181 Field Value int GL_RENDERBUFFER_WIDTH public const int GL_RENDERBUFFER_WIDTH = 36162 Field Value int GL_RENDERER public const int GL_RENDERER = 7937 Field Value int GL_REPEAT public const int GL_REPEAT = 10497 Field Value int GL_REPLACE public const int GL_REPLACE = 7681 Field Value int GL_RG public const int GL_RG = 33319 Field Value int GL_RG16 public const int GL_RG16 = 33324 Field Value int GL_RG16F public const int GL_RG16F = 33327 Field Value int GL_RG16I public const int GL_RG16I = 33337 Field Value int GL_RG16UI public const int GL_RG16UI = 33338 Field Value int GL_RG16_SNORM public const int GL_RG16_SNORM = 36761 Field Value int GL_RG32F public const int GL_RG32F = 33328 Field Value int GL_RG32I public const int GL_RG32I = 33339 Field Value int GL_RG32UI public const int GL_RG32UI = 33340 Field Value int GL_RG8 public const int GL_RG8 = 33323 Field Value int GL_RG8I public const int GL_RG8I = 33335 Field Value int GL_RG8UI public const int GL_RG8UI = 33336 Field Value int GL_RG8_SNORM public const int GL_RG8_SNORM = 36757 Field Value int GL_RGB public const int GL_RGB = 6407 Field Value int GL_RGB10 public const int GL_RGB10 = 32850 Field Value int GL_RGB10_A2 public const int GL_RGB10_A2 = 32857 Field Value int GL_RGB10_A2UI public const int GL_RGB10_A2UI = 36975 Field Value int GL_RGB12 public const int GL_RGB12 = 32851 Field Value int GL_RGB16 public const int GL_RGB16 = 32852 Field Value int GL_RGB16F public const int GL_RGB16F = 34843 Field Value int GL_RGB16I public const int GL_RGB16I = 36233 Field Value int GL_RGB16UI public const int GL_RGB16UI = 36215 Field Value int GL_RGB16_SNORM public const int GL_RGB16_SNORM = 36762 Field Value int GL_RGB32F public const int GL_RGB32F = 34837 Field Value int GL_RGB32I public const int GL_RGB32I = 36227 Field Value int GL_RGB32UI public const int GL_RGB32UI = 36209 Field Value int GL_RGB4 public const int GL_RGB4 = 32847 Field Value int GL_RGB5 public const int GL_RGB5 = 32848 Field Value int GL_RGB5_A1 public const int GL_RGB5_A1 = 32855 Field Value int GL_RGB8 public const int GL_RGB8 = 32849 Field Value int GL_RGB8I public const int GL_RGB8I = 36239 Field Value int GL_RGB8UI public const int GL_RGB8UI = 36221 Field Value int GL_RGB8_SNORM public const int GL_RGB8_SNORM = 36758 Field Value int GL_RGB9_E5 public const int GL_RGB9_E5 = 35901 Field Value int GL_RGBA public const int GL_RGBA = 6408 Field Value int GL_RGBA12 public const int GL_RGBA12 = 32858 Field Value int GL_RGBA16 public const int GL_RGBA16 = 32859 Field Value int GL_RGBA16F public const int GL_RGBA16F = 34842 Field Value int GL_RGBA16I public const int GL_RGBA16I = 36232 Field Value int GL_RGBA16UI public const int GL_RGBA16UI = 36214 Field Value int GL_RGBA16_SNORM public const int GL_RGBA16_SNORM = 36763 Field Value int GL_RGBA2 public const int GL_RGBA2 = 32853 Field Value int GL_RGBA32F public const int GL_RGBA32F = 34836 Field Value int GL_RGBA32I public const int GL_RGBA32I = 36226 Field Value int GL_RGBA32UI public const int GL_RGBA32UI = 36208 Field Value int GL_RGBA4 public const int GL_RGBA4 = 32854 Field Value int GL_RGBA8 public const int GL_RGBA8 = 32856 Field Value int GL_RGBA8I public const int GL_RGBA8I = 36238 Field Value int GL_RGBA8UI public const int GL_RGBA8UI = 36220 Field Value int GL_RGBA8_SNORM public const int GL_RGBA8_SNORM = 36759 Field Value int GL_RGBA_INTEGER public const int GL_RGBA_INTEGER = 36249 Field Value int GL_RGB_INTEGER public const int GL_RGB_INTEGER = 36248 Field Value int GL_RG_INTEGER public const int GL_RG_INTEGER = 33320 Field Value int GL_RIGHT public const int GL_RIGHT = 1031 Field Value int GL_SAMPLER_1D public const int GL_SAMPLER_1D = 35677 Field Value int GL_SAMPLER_1D_ARRAY public const int GL_SAMPLER_1D_ARRAY = 36288 Field Value int GL_SAMPLER_1D_ARRAY_SHADOW public const int GL_SAMPLER_1D_ARRAY_SHADOW = 36291 Field Value int GL_SAMPLER_1D_SHADOW public const int GL_SAMPLER_1D_SHADOW = 35681 Field Value int GL_SAMPLER_2D public const int GL_SAMPLER_2D = 35678 Field Value int GL_SAMPLER_2D_ARRAY public const int GL_SAMPLER_2D_ARRAY = 36289 Field Value int GL_SAMPLER_2D_ARRAY_SHADOW public const int GL_SAMPLER_2D_ARRAY_SHADOW = 36292 Field Value int GL_SAMPLER_2D_MULTISAMPLE public const int GL_SAMPLER_2D_MULTISAMPLE = 37128 Field Value int GL_SAMPLER_2D_MULTISAMPLE_ARRAY public const int GL_SAMPLER_2D_MULTISAMPLE_ARRAY = 37131 Field Value int GL_SAMPLER_2D_RECT public const int GL_SAMPLER_2D_RECT = 35683 Field Value int GL_SAMPLER_2D_RECT_SHADOW public const int GL_SAMPLER_2D_RECT_SHADOW = 35684 Field Value int GL_SAMPLER_2D_SHADOW public const int GL_SAMPLER_2D_SHADOW = 35682 Field Value int GL_SAMPLER_3D public const int GL_SAMPLER_3D = 35679 Field Value int GL_SAMPLER_BINDING public const int GL_SAMPLER_BINDING = 35097 Field Value int GL_SAMPLER_BUFFER public const int GL_SAMPLER_BUFFER = 36290 Field Value int GL_SAMPLER_CUBE public const int GL_SAMPLER_CUBE = 35680 Field Value int GL_SAMPLER_CUBE_SHADOW public const int GL_SAMPLER_CUBE_SHADOW = 36293 Field Value int GL_SAMPLES public const int GL_SAMPLES = 32937 Field Value int GL_SAMPLES_PASSED public const int GL_SAMPLES_PASSED = 35092 Field Value int GL_SAMPLE_ALPHA_TO_COVERAGE public const int GL_SAMPLE_ALPHA_TO_COVERAGE = 32926 Field Value int GL_SAMPLE_ALPHA_TO_ONE public const int GL_SAMPLE_ALPHA_TO_ONE = 32927 Field Value int GL_SAMPLE_BUFFERS public const int GL_SAMPLE_BUFFERS = 32936 Field Value int GL_SAMPLE_COVERAGE public const int GL_SAMPLE_COVERAGE = 32928 Field Value int GL_SAMPLE_COVERAGE_INVERT public const int GL_SAMPLE_COVERAGE_INVERT = 32939 Field Value int GL_SAMPLE_COVERAGE_VALUE public const int GL_SAMPLE_COVERAGE_VALUE = 32938 Field Value int GL_SAMPLE_MASK public const int GL_SAMPLE_MASK = 36433 Field Value int GL_SAMPLE_MASK_VALUE public const int GL_SAMPLE_MASK_VALUE = 36434 Field Value int GL_SAMPLE_POSITION public const int GL_SAMPLE_POSITION = 36432 Field Value int GL_SCISSOR_BOX public const int GL_SCISSOR_BOX = 3088 Field Value int GL_SCISSOR_TEST public const int GL_SCISSOR_TEST = 3089 Field Value int GL_SEPARATE_ATTRIBS public const int GL_SEPARATE_ATTRIBS = 35981 Field Value int GL_SET public const int GL_SET = 5391 Field Value int GL_SHADER_SOURCE_LENGTH public const int GL_SHADER_SOURCE_LENGTH = 35720 Field Value int GL_SHADER_TYPE public const int GL_SHADER_TYPE = 35663 Field Value int GL_SHADING_LANGUAGE_VERSION public const int GL_SHADING_LANGUAGE_VERSION = 35724 Field Value int GL_SHORT public const int GL_SHORT = 5122 Field Value int GL_SIGNALED public const int GL_SIGNALED = 37145 Field Value int GL_SIGNED_NORMALIZED public const int GL_SIGNED_NORMALIZED = 36764 Field Value int GL_SMOOTH_LINE_WIDTH_GRANULARITY public const int GL_SMOOTH_LINE_WIDTH_GRANULARITY = 2851 Field Value int GL_SMOOTH_LINE_WIDTH_RANGE public const int GL_SMOOTH_LINE_WIDTH_RANGE = 2850 Field Value int GL_SMOOTH_POINT_SIZE_GRANULARITY public const int GL_SMOOTH_POINT_SIZE_GRANULARITY = 2835 Field Value int GL_SMOOTH_POINT_SIZE_RANGE public const int GL_SMOOTH_POINT_SIZE_RANGE = 2834 Field Value int GL_SRC1_ALPHA public const int GL_SRC1_ALPHA = 34185 Field Value int GL_SRC1_COLOR public const int GL_SRC1_COLOR = 35065 Field Value int GL_SRC_ALPHA public const int GL_SRC_ALPHA = 770 Field Value int GL_SRC_ALPHA_SATURATE public const int GL_SRC_ALPHA_SATURATE = 776 Field Value int GL_SRC_COLOR public const int GL_SRC_COLOR = 768 Field Value int GL_SRGB public const int GL_SRGB = 35904 Field Value int GL_SRGB8 public const int GL_SRGB8 = 35905 Field Value int GL_SRGB8_ALPHA8 public const int GL_SRGB8_ALPHA8 = 35907 Field Value int GL_SRGB_ALPHA public const int GL_SRGB_ALPHA = 35906 Field Value int GL_STATIC_COPY public const int GL_STATIC_COPY = 35046 Field Value int GL_STATIC_DRAW public const int GL_STATIC_DRAW = 35044 Field Value int GL_STATIC_READ public const int GL_STATIC_READ = 35045 Field Value int GL_STENCIL public const int GL_STENCIL = 6146 Field Value int GL_STENCIL_ATTACHMENT public const int GL_STENCIL_ATTACHMENT = 36128 Field Value int GL_STENCIL_BACK_FAIL public const int GL_STENCIL_BACK_FAIL = 34817 Field Value int GL_STENCIL_BACK_FUNC public const int GL_STENCIL_BACK_FUNC = 34816 Field Value int GL_STENCIL_BACK_PASS_DEPTH_FAIL public const int GL_STENCIL_BACK_PASS_DEPTH_FAIL = 34818 Field Value int GL_STENCIL_BACK_PASS_DEPTH_PASS public const int GL_STENCIL_BACK_PASS_DEPTH_PASS = 34819 Field Value int GL_STENCIL_BACK_REF public const int GL_STENCIL_BACK_REF = 36003 Field Value int GL_STENCIL_BACK_VALUE_MASK public const int GL_STENCIL_BACK_VALUE_MASK = 36004 Field Value int GL_STENCIL_BACK_WRITEMASK public const int GL_STENCIL_BACK_WRITEMASK = 36005 Field Value int GL_STENCIL_BUFFER_BIT public const int GL_STENCIL_BUFFER_BIT = 1024 Field Value int GL_STENCIL_CLEAR_VALUE public const int GL_STENCIL_CLEAR_VALUE = 2961 Field Value int GL_STENCIL_FAIL public const int GL_STENCIL_FAIL = 2964 Field Value int GL_STENCIL_FUNC public const int GL_STENCIL_FUNC = 2962 Field Value int GL_STENCIL_INDEX public const int GL_STENCIL_INDEX = 6401 Field Value int GL_STENCIL_INDEX1 public const int GL_STENCIL_INDEX1 = 36166 Field Value int GL_STENCIL_INDEX16 public const int GL_STENCIL_INDEX16 = 36169 Field Value int GL_STENCIL_INDEX4 public const int GL_STENCIL_INDEX4 = 36167 Field Value int GL_STENCIL_INDEX8 public const int GL_STENCIL_INDEX8 = 36168 Field Value int GL_STENCIL_PASS_DEPTH_FAIL public const int GL_STENCIL_PASS_DEPTH_FAIL = 2965 Field Value int GL_STENCIL_PASS_DEPTH_PASS public const int GL_STENCIL_PASS_DEPTH_PASS = 2966 Field Value int GL_STENCIL_REF public const int GL_STENCIL_REF = 2967 Field Value int GL_STENCIL_TEST public const int GL_STENCIL_TEST = 2960 Field Value int GL_STENCIL_VALUE_MASK public const int GL_STENCIL_VALUE_MASK = 2963 Field Value int GL_STENCIL_WRITEMASK public const int GL_STENCIL_WRITEMASK = 2968 Field Value int GL_STEREO public const int GL_STEREO = 3123 Field Value int GL_STREAM_COPY public const int GL_STREAM_COPY = 35042 Field Value int GL_STREAM_DRAW public const int GL_STREAM_DRAW = 35040 Field Value int GL_STREAM_READ public const int GL_STREAM_READ = 35041 Field Value int GL_SUBPIXEL_BITS public const int GL_SUBPIXEL_BITS = 3408 Field Value int GL_SYNC_CONDITION public const int GL_SYNC_CONDITION = 37139 Field Value int GL_SYNC_FENCE public const int GL_SYNC_FENCE = 37142 Field Value int GL_SYNC_FLAGS public const int GL_SYNC_FLAGS = 37141 Field Value int GL_SYNC_FLUSH_COMMANDS_BIT public const int GL_SYNC_FLUSH_COMMANDS_BIT = 1 Field Value int GL_SYNC_GPU_COMMANDS_COMPLETE public const int GL_SYNC_GPU_COMMANDS_COMPLETE = 37143 Field Value int GL_SYNC_STATUS public const int GL_SYNC_STATUS = 37140 Field Value int GL_TEXTURE public const int GL_TEXTURE = 5890 Field Value int GL_TEXTURE0 public const int GL_TEXTURE0 = 33984 Field Value int GL_TEXTURE1 public const int GL_TEXTURE1 = 33985 Field Value int GL_TEXTURE10 public const int GL_TEXTURE10 = 33994 Field Value int GL_TEXTURE11 public const int GL_TEXTURE11 = 33995 Field Value int GL_TEXTURE12 public const int GL_TEXTURE12 = 33996 Field Value int GL_TEXTURE13 public const int GL_TEXTURE13 = 33997 Field Value int GL_TEXTURE14 public const int GL_TEXTURE14 = 33998 Field Value int GL_TEXTURE15 public const int GL_TEXTURE15 = 33999 Field Value int GL_TEXTURE16 public const int GL_TEXTURE16 = 34000 Field Value int GL_TEXTURE17 public const int GL_TEXTURE17 = 34001 Field Value int GL_TEXTURE18 public const int GL_TEXTURE18 = 34002 Field Value int GL_TEXTURE19 public const int GL_TEXTURE19 = 34003 Field Value int GL_TEXTURE2 public const int GL_TEXTURE2 = 33986 Field Value int GL_TEXTURE20 public const int GL_TEXTURE20 = 34004 Field Value int GL_TEXTURE21 public const int GL_TEXTURE21 = 34005 Field Value int GL_TEXTURE22 public const int GL_TEXTURE22 = 34006 Field Value int GL_TEXTURE23 public const int GL_TEXTURE23 = 34007 Field Value int GL_TEXTURE24 public const int GL_TEXTURE24 = 34008 Field Value int GL_TEXTURE25 public const int GL_TEXTURE25 = 34009 Field Value int GL_TEXTURE26 public const int GL_TEXTURE26 = 34010 Field Value int GL_TEXTURE27 public const int GL_TEXTURE27 = 34011 Field Value int GL_TEXTURE28 public const int GL_TEXTURE28 = 34012 Field Value int GL_TEXTURE29 public const int GL_TEXTURE29 = 34013 Field Value int GL_TEXTURE3 public const int GL_TEXTURE3 = 33987 Field Value int GL_TEXTURE30 public const int GL_TEXTURE30 = 34014 Field Value int GL_TEXTURE31 public const int GL_TEXTURE31 = 34015 Field Value int GL_TEXTURE4 public const int GL_TEXTURE4 = 33988 Field Value int GL_TEXTURE5 public const int GL_TEXTURE5 = 33989 Field Value int GL_TEXTURE6 public const int GL_TEXTURE6 = 33990 Field Value int GL_TEXTURE7 public const int GL_TEXTURE7 = 33991 Field Value int GL_TEXTURE8 public const int GL_TEXTURE8 = 33992 Field Value int GL_TEXTURE9 public const int GL_TEXTURE9 = 33993 Field Value int GL_TEXTURE_1D public const int GL_TEXTURE_1D = 3552 Field Value int GL_TEXTURE_1D_ARRAY public const int GL_TEXTURE_1D_ARRAY = 35864 Field Value int GL_TEXTURE_2D public const int GL_TEXTURE_2D = 3553 Field Value int GL_TEXTURE_2D_ARRAY public const int GL_TEXTURE_2D_ARRAY = 35866 Field Value int GL_TEXTURE_2D_MULTISAMPLE public const int GL_TEXTURE_2D_MULTISAMPLE = 37120 Field Value int GL_TEXTURE_2D_MULTISAMPLE_ARRAY public const int GL_TEXTURE_2D_MULTISAMPLE_ARRAY = 37122 Field Value int GL_TEXTURE_3D public const int GL_TEXTURE_3D = 32879 Field Value int GL_TEXTURE_ALPHA_SIZE public const int GL_TEXTURE_ALPHA_SIZE = 32863 Field Value int GL_TEXTURE_ALPHA_TYPE public const int GL_TEXTURE_ALPHA_TYPE = 35859 Field Value int GL_TEXTURE_BASE_LEVEL public const int GL_TEXTURE_BASE_LEVEL = 33084 Field Value int GL_TEXTURE_BINDING_1D public const int GL_TEXTURE_BINDING_1D = 32872 Field Value int GL_TEXTURE_BINDING_1D_ARRAY public const int GL_TEXTURE_BINDING_1D_ARRAY = 35868 Field Value int GL_TEXTURE_BINDING_2D public const int GL_TEXTURE_BINDING_2D = 32873 Field Value int GL_TEXTURE_BINDING_2D_ARRAY public const int GL_TEXTURE_BINDING_2D_ARRAY = 35869 Field Value int GL_TEXTURE_BINDING_2D_MULTISAMPLE public const int GL_TEXTURE_BINDING_2D_MULTISAMPLE = 37124 Field Value int GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY public const int GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 37125 Field Value int GL_TEXTURE_BINDING_3D public const int GL_TEXTURE_BINDING_3D = 32874 Field Value int GL_TEXTURE_BINDING_BUFFER public const int GL_TEXTURE_BINDING_BUFFER = 35884 Field Value int GL_TEXTURE_BINDING_CUBE_MAP public const int GL_TEXTURE_BINDING_CUBE_MAP = 34068 Field Value int GL_TEXTURE_BINDING_RECTANGLE public const int GL_TEXTURE_BINDING_RECTANGLE = 34038 Field Value int GL_TEXTURE_BLUE_SIZE public const int GL_TEXTURE_BLUE_SIZE = 32862 Field Value int GL_TEXTURE_BLUE_TYPE public const int GL_TEXTURE_BLUE_TYPE = 35858 Field Value int GL_TEXTURE_BORDER_COLOR public const int GL_TEXTURE_BORDER_COLOR = 4100 Field Value int GL_TEXTURE_BUFFER public const int GL_TEXTURE_BUFFER = 35882 Field Value int GL_TEXTURE_BUFFER_DATA_STORE_BINDING public const int GL_TEXTURE_BUFFER_DATA_STORE_BINDING = 35885 Field Value int GL_TEXTURE_COMPARE_FUNC public const int GL_TEXTURE_COMPARE_FUNC = 34893 Field Value int GL_TEXTURE_COMPARE_MODE public const int GL_TEXTURE_COMPARE_MODE = 34892 Field Value int GL_TEXTURE_COMPRESSED public const int GL_TEXTURE_COMPRESSED = 34465 Field Value int GL_TEXTURE_COMPRESSED_IMAGE_SIZE public const int GL_TEXTURE_COMPRESSED_IMAGE_SIZE = 34464 Field Value int GL_TEXTURE_COMPRESSION_HINT public const int GL_TEXTURE_COMPRESSION_HINT = 34031 Field Value int GL_TEXTURE_CUBE_MAP public const int GL_TEXTURE_CUBE_MAP = 34067 Field Value int GL_TEXTURE_CUBE_MAP_NEGATIVE_X public const int GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 34070 Field Value int GL_TEXTURE_CUBE_MAP_NEGATIVE_Y public const int GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 34072 Field Value int GL_TEXTURE_CUBE_MAP_NEGATIVE_Z public const int GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 34074 Field Value int GL_TEXTURE_CUBE_MAP_POSITIVE_X public const int GL_TEXTURE_CUBE_MAP_POSITIVE_X = 34069 Field Value int GL_TEXTURE_CUBE_MAP_POSITIVE_Y public const int GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 34071 Field Value int GL_TEXTURE_CUBE_MAP_POSITIVE_Z public const int GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 34073 Field Value int GL_TEXTURE_CUBE_MAP_SEAMLESS public const int GL_TEXTURE_CUBE_MAP_SEAMLESS = 34895 Field Value int GL_TEXTURE_DEPTH public const int GL_TEXTURE_DEPTH = 32881 Field Value int GL_TEXTURE_DEPTH_SIZE public const int GL_TEXTURE_DEPTH_SIZE = 34890 Field Value int GL_TEXTURE_DEPTH_TYPE public const int GL_TEXTURE_DEPTH_TYPE = 35862 Field Value int GL_TEXTURE_FIXED_SAMPLE_LOCATIONS public const int GL_TEXTURE_FIXED_SAMPLE_LOCATIONS = 37127 Field Value int GL_TEXTURE_GREEN_SIZE public const int GL_TEXTURE_GREEN_SIZE = 32861 Field Value int GL_TEXTURE_GREEN_TYPE public const int GL_TEXTURE_GREEN_TYPE = 35857 Field Value int GL_TEXTURE_HEIGHT public const int GL_TEXTURE_HEIGHT = 4097 Field Value int GL_TEXTURE_INTERNAL_FORMAT public const int GL_TEXTURE_INTERNAL_FORMAT = 4099 Field Value int GL_TEXTURE_LOD_BIAS public const int GL_TEXTURE_LOD_BIAS = 34049 Field Value int GL_TEXTURE_MAG_FILTER public const int GL_TEXTURE_MAG_FILTER = 10240 Field Value int GL_TEXTURE_MAX_LEVEL public const int GL_TEXTURE_MAX_LEVEL = 33085 Field Value int GL_TEXTURE_MAX_LOD public const int GL_TEXTURE_MAX_LOD = 33083 Field Value int GL_TEXTURE_MIN_FILTER public const int GL_TEXTURE_MIN_FILTER = 10241 Field Value int GL_TEXTURE_MIN_LOD public const int GL_TEXTURE_MIN_LOD = 33082 Field Value int GL_TEXTURE_RECTANGLE public const int GL_TEXTURE_RECTANGLE = 34037 Field Value int GL_TEXTURE_RED_SIZE public const int GL_TEXTURE_RED_SIZE = 32860 Field Value int GL_TEXTURE_RED_TYPE public const int GL_TEXTURE_RED_TYPE = 35856 Field Value int GL_TEXTURE_SAMPLES public const int GL_TEXTURE_SAMPLES = 37126 Field Value int GL_TEXTURE_SHARED_SIZE public const int GL_TEXTURE_SHARED_SIZE = 35903 Field Value int GL_TEXTURE_STENCIL_SIZE public const int GL_TEXTURE_STENCIL_SIZE = 35057 Field Value int GL_TEXTURE_SWIZZLE_A public const int GL_TEXTURE_SWIZZLE_A = 36421 Field Value int GL_TEXTURE_SWIZZLE_B public const int GL_TEXTURE_SWIZZLE_B = 36420 Field Value int GL_TEXTURE_SWIZZLE_G public const int GL_TEXTURE_SWIZZLE_G = 36419 Field Value int GL_TEXTURE_SWIZZLE_R public const int GL_TEXTURE_SWIZZLE_R = 36418 Field Value int GL_TEXTURE_SWIZZLE_RGBA public const int GL_TEXTURE_SWIZZLE_RGBA = 36422 Field Value int GL_TEXTURE_WIDTH public const int GL_TEXTURE_WIDTH = 4096 Field Value int GL_TEXTURE_WRAP_R public const int GL_TEXTURE_WRAP_R = 32882 Field Value int GL_TEXTURE_WRAP_S public const int GL_TEXTURE_WRAP_S = 10242 Field Value int GL_TEXTURE_WRAP_T public const int GL_TEXTURE_WRAP_T = 10243 Field Value int GL_TIMEOUT_EXPIRED public const int GL_TIMEOUT_EXPIRED = 37147 Field Value int GL_TIMEOUT_IGNORED public const ulong GL_TIMEOUT_IGNORED = 18446744073709551615 Field Value ulong GL_TIMESTAMP public const int GL_TIMESTAMP = 36392 Field Value int GL_TIME_ELAPSED public const int GL_TIME_ELAPSED = 35007 Field Value int GL_TRANSFORM_FEEDBACK_BUFFER public const int GL_TRANSFORM_FEEDBACK_BUFFER = 35982 Field Value int GL_TRANSFORM_FEEDBACK_BUFFER_BINDING public const int GL_TRANSFORM_FEEDBACK_BUFFER_BINDING = 35983 Field Value int GL_TRANSFORM_FEEDBACK_BUFFER_MODE public const int GL_TRANSFORM_FEEDBACK_BUFFER_MODE = 35967 Field Value int GL_TRANSFORM_FEEDBACK_BUFFER_SIZE public const int GL_TRANSFORM_FEEDBACK_BUFFER_SIZE = 35973 Field Value int GL_TRANSFORM_FEEDBACK_BUFFER_START public const int GL_TRANSFORM_FEEDBACK_BUFFER_START = 35972 Field Value int GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN public const int GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 35976 Field Value int GL_TRANSFORM_FEEDBACK_VARYINGS public const int GL_TRANSFORM_FEEDBACK_VARYINGS = 35971 Field Value int GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH public const int GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 35958 Field Value int GL_TRIANGLES public const int GL_TRIANGLES = 4 Field Value int GL_TRIANGLES_ADJACENCY public const int GL_TRIANGLES_ADJACENCY = 12 Field Value int GL_TRIANGLE_FAN public const int GL_TRIANGLE_FAN = 6 Field Value int GL_TRIANGLE_STRIP public const int GL_TRIANGLE_STRIP = 5 Field Value int GL_TRIANGLE_STRIP_ADJACENCY public const int GL_TRIANGLE_STRIP_ADJACENCY = 13 Field Value int GL_TRUE public const int GL_TRUE = 1 Field Value int GL_UInt16_FLOAT public const int GL_UInt16_FLOAT = 5131 Field Value int GL_UNIFORM_ARRAY_STRIDE public const int GL_UNIFORM_ARRAY_STRIDE = 35388 Field Value int GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS public const int GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS = 35394 Field Value int GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES public const int GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 35395 Field Value int GL_UNIFORM_BLOCK_BINDING public const int GL_UNIFORM_BLOCK_BINDING = 35391 Field Value int GL_UNIFORM_BLOCK_DATA_SIZE public const int GL_UNIFORM_BLOCK_DATA_SIZE = 35392 Field Value int GL_UNIFORM_BLOCK_INDEX public const int GL_UNIFORM_BLOCK_INDEX = 35386 Field Value int GL_UNIFORM_BLOCK_NAME_LENGTH public const int GL_UNIFORM_BLOCK_NAME_LENGTH = 35393 Field Value int GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER public const int GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 35398 Field Value int GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER public const int GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 35397 Field Value int GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER public const int GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 35396 Field Value int GL_UNIFORM_BUFFER public const int GL_UNIFORM_BUFFER = 35345 Field Value int GL_UNIFORM_BUFFER_BINDING public const int GL_UNIFORM_BUFFER_BINDING = 35368 Field Value int GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT public const int GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT = 35380 Field Value int GL_UNIFORM_BUFFER_SIZE public const int GL_UNIFORM_BUFFER_SIZE = 35370 Field Value int GL_UNIFORM_BUFFER_START public const int GL_UNIFORM_BUFFER_START = 35369 Field Value int GL_UNIFORM_IS_ROW_MAJOR public const int GL_UNIFORM_IS_ROW_MAJOR = 35390 Field Value int GL_UNIFORM_MATRIX_STRIDE public const int GL_UNIFORM_MATRIX_STRIDE = 35389 Field Value int GL_UNIFORM_NAME_LENGTH public const int GL_UNIFORM_NAME_LENGTH = 35385 Field Value int GL_UNIFORM_OFFSET public const int GL_UNIFORM_OFFSET = 35387 Field Value int GL_UNIFORM_SIZE public const int GL_UNIFORM_SIZE = 35384 Field Value int GL_UNIFORM_TYPE public const int GL_UNIFORM_TYPE = 35383 Field Value int GL_UNPACK_ALIGNMENT public const int GL_UNPACK_ALIGNMENT = 3317 Field Value int GL_UNPACK_IMAGE_HEIGHT public const int GL_UNPACK_IMAGE_HEIGHT = 32878 Field Value int GL_UNPACK_LSB_FIRST public const int GL_UNPACK_LSB_FIRST = 3313 Field Value int GL_UNPACK_ROW_LENGTH public const int GL_UNPACK_ROW_LENGTH = 3314 Field Value int GL_UNPACK_SKIP_IMAGES public const int GL_UNPACK_SKIP_IMAGES = 32877 Field Value int GL_UNPACK_SKIP_PIXELS public const int GL_UNPACK_SKIP_PIXELS = 3316 Field Value int GL_UNPACK_SKIP_ROWS public const int GL_UNPACK_SKIP_ROWS = 3315 Field Value int GL_UNPACK_SWAP_BYTES public const int GL_UNPACK_SWAP_BYTES = 3312 Field Value int GL_UNSIGNALED public const int GL_UNSIGNALED = 37144 Field Value int GL_UNSIGNED_BYTE public const int GL_UNSIGNED_BYTE = 5121 Field Value int GL_UNSIGNED_BYTE_2_3_3_REV public const int GL_UNSIGNED_BYTE_2_3_3_REV = 33634 Field Value int GL_UNSIGNED_BYTE_3_3_2 public const int GL_UNSIGNED_BYTE_3_3_2 = 32818 Field Value int GL_UNSIGNED_INT public const int GL_UNSIGNED_INT = 5125 Field Value int GL_UNSIGNED_INT_10F_11F_11F_REV public const int GL_UNSIGNED_INT_10F_11F_11F_REV = 35899 Field Value int GL_UNSIGNED_INT_10_10_10_2 public const int GL_UNSIGNED_INT_10_10_10_2 = 32822 Field Value int GL_UNSIGNED_INT_24_8 public const int GL_UNSIGNED_INT_24_8 = 34042 Field Value int GL_UNSIGNED_INT_2_10_10_10_REV public const int GL_UNSIGNED_INT_2_10_10_10_REV = 33640 Field Value int GL_UNSIGNED_INT_5_9_9_9_REV public const int GL_UNSIGNED_INT_5_9_9_9_REV = 35902 Field Value int GL_UNSIGNED_INT_8_8_8_8 public const int GL_UNSIGNED_INT_8_8_8_8 = 32821 Field Value int GL_UNSIGNED_INT_8_8_8_8_REV public const int GL_UNSIGNED_INT_8_8_8_8_REV = 33639 Field Value int GL_UNSIGNED_INT_SAMPLER_1D public const int GL_UNSIGNED_INT_SAMPLER_1D = 36305 Field Value int GL_UNSIGNED_INT_SAMPLER_1D_ARRAY public const int GL_UNSIGNED_INT_SAMPLER_1D_ARRAY = 36310 Field Value int GL_UNSIGNED_INT_SAMPLER_2D public const int GL_UNSIGNED_INT_SAMPLER_2D = 36306 Field Value int GL_UNSIGNED_INT_SAMPLER_2D_ARRAY public const int GL_UNSIGNED_INT_SAMPLER_2D_ARRAY = 36311 Field Value int GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE public const int GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 37130 Field Value int GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY public const int GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 37133 Field Value int GL_UNSIGNED_INT_SAMPLER_2D_RECT public const int GL_UNSIGNED_INT_SAMPLER_2D_RECT = 36309 Field Value int GL_UNSIGNED_INT_SAMPLER_3D public const int GL_UNSIGNED_INT_SAMPLER_3D = 36307 Field Value int GL_UNSIGNED_INT_SAMPLER_BUFFER public const int GL_UNSIGNED_INT_SAMPLER_BUFFER = 36312 Field Value int GL_UNSIGNED_INT_SAMPLER_CUBE public const int GL_UNSIGNED_INT_SAMPLER_CUBE = 36308 Field Value int GL_UNSIGNED_INT_VEC2 public const int GL_UNSIGNED_INT_VEC2 = 36294 Field Value int GL_UNSIGNED_INT_VEC3 public const int GL_UNSIGNED_INT_VEC3 = 36295 Field Value int GL_UNSIGNED_INT_VEC4 public const int GL_UNSIGNED_INT_VEC4 = 36296 Field Value int GL_UNSIGNED_NORMALIZED public const int GL_UNSIGNED_NORMALIZED = 35863 Field Value int GL_UNSIGNED_SHORT public const int GL_UNSIGNED_SHORT = 5123 Field Value int GL_UNSIGNED_SHORT_1_5_5_5_REV public const int GL_UNSIGNED_SHORT_1_5_5_5_REV = 33638 Field Value int GL_UNSIGNED_SHORT_4_4_4_4 public const int GL_UNSIGNED_SHORT_4_4_4_4 = 32819 Field Value int GL_UNSIGNED_SHORT_4_4_4_4_REV public const int GL_UNSIGNED_SHORT_4_4_4_4_REV = 33637 Field Value int GL_UNSIGNED_SHORT_5_5_5_1 public const int GL_UNSIGNED_SHORT_5_5_5_1 = 32820 Field Value int GL_UNSIGNED_SHORT_5_6_5 public const int GL_UNSIGNED_SHORT_5_6_5 = 33635 Field Value int GL_UNSIGNED_SHORT_5_6_5_REV public const int GL_UNSIGNED_SHORT_5_6_5_REV = 33636 Field Value int GL_UPPER_LEFT public const int GL_UPPER_LEFT = 36002 Field Value int GL_VALIDATE_STATUS public const int GL_VALIDATE_STATUS = 35715 Field Value int GL_VENDOR public const int GL_VENDOR = 7936 Field Value int GL_VERSION public const int GL_VERSION = 7938 Field Value int GL_VERTEX_ARRAY_BINDING public const int GL_VERTEX_ARRAY_BINDING = 34229 Field Value int GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING public const int GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 34975 Field Value int GL_VERTEX_ATTRIB_ARRAY_DIVISOR public const int GL_VERTEX_ATTRIB_ARRAY_DIVISOR = 35070 Field Value int GL_VERTEX_ATTRIB_ARRAY_ENABLED public const int GL_VERTEX_ATTRIB_ARRAY_ENABLED = 34338 Field Value int GL_VERTEX_ATTRIB_ARRAY_INTEGER public const int GL_VERTEX_ATTRIB_ARRAY_INTEGER = 35069 Field Value int GL_VERTEX_ATTRIB_ARRAY_NORMALIZED public const int GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = 34922 Field Value int GL_VERTEX_ATTRIB_ARRAY_POINTER public const int GL_VERTEX_ATTRIB_ARRAY_POINTER = 34373 Field Value int GL_VERTEX_ATTRIB_ARRAY_SIZE public const int GL_VERTEX_ATTRIB_ARRAY_SIZE = 34339 Field Value int GL_VERTEX_ATTRIB_ARRAY_STRIDE public const int GL_VERTEX_ATTRIB_ARRAY_STRIDE = 34340 Field Value int GL_VERTEX_ATTRIB_ARRAY_TYPE public const int GL_VERTEX_ATTRIB_ARRAY_TYPE = 34341 Field Value int GL_VERTEX_PROGRAM_POINT_SIZE public const int GL_VERTEX_PROGRAM_POINT_SIZE = 34370 Field Value int GL_VERTEX_SHADER public const int GL_VERTEX_SHADER = 35633 Field Value int GL_VIEWPORT public const int GL_VIEWPORT = 2978 Field Value int GL_WAIT_FAILED public const int GL_WAIT_FAILED = 37149 Field Value int GL_WRITE_ONLY public const int GL_WRITE_ONLY = 35001 Field Value int GL_XOR public const int GL_XOR = 5382 Field Value int GL_ZERO public const int GL_ZERO = 0 Field Value int Methods glActiveProgramEXT(uint) public static extern void glActiveProgramEXT(uint program) Parameters program uint glActiveShaderProgram(uint, uint) public static extern void glActiveShaderProgram(uint pipeline, uint program) Parameters pipeline uint program uint glActiveStencilFaceEXT(uint) public static extern void glActiveStencilFaceEXT(uint face) Parameters face uint glActiveTexture(uint) public static extern void glActiveTexture(uint texture) Parameters texture uint glActiveTextureARB(uint) public static extern void glActiveTextureARB(uint texture) Parameters texture uint glActiveVaryingNV(uint, string) public static extern void glActiveVaryingNV(uint program, string name) Parameters program uint name string glApplyTextureEXT(uint) public static extern void glApplyTextureEXT(uint mode) Parameters mode uint glAreTexturesResidentEXT(int, uint*, bool*) public static extern bool glAreTexturesResidentEXT(int n, uint* textures, bool* residences) Parameters n int textures uint* residences bool* Returns bool glArrayObjectATI(uint, int, uint, int, uint, uint) public static extern void glArrayObjectATI(uint array, int size, uint type, int stride, uint buffer, uint offset) Parameters array uint size int type uint stride int buffer uint offset uint glAsyncMarkerSGIX(uint) public static extern void glAsyncMarkerSGIX(uint marker) Parameters marker uint glAttachObjectARB(uint, uint) public static extern void glAttachObjectARB(uint containerObj, uint obj) Parameters containerObj uint obj uint glAttachShader(uint, uint) public static extern void glAttachShader(uint program, uint shader) Parameters program uint shader uint glBeginConditionalRender(uint, uint) public static extern void glBeginConditionalRender(uint id, uint mode) Parameters id uint mode uint glBeginConditionalRenderNV(uint, uint) public static extern void glBeginConditionalRenderNV(uint id, uint mode) Parameters id uint mode uint glBeginFragmentShaderATI() public static extern void glBeginFragmentShaderATI() glBeginOcclusionQueryNV(uint) public static extern void glBeginOcclusionQueryNV(uint id) Parameters id uint glBeginPerfMonitorAMD(uint) public static extern void glBeginPerfMonitorAMD(uint monitor) Parameters monitor uint glBeginQuery(uint, uint) public static extern void glBeginQuery(uint target, uint id) Parameters target uint id uint glBeginQueryARB(uint, uint) public static extern void glBeginQueryARB(uint target, uint id) Parameters target uint id uint glBeginQueryIndexed(uint, uint, uint) public static extern void glBeginQueryIndexed(uint target, uint index, uint id) Parameters target uint index uint id uint glBeginTransformFeedback(uint) public static extern void glBeginTransformFeedback(uint primitiveMode) Parameters primitiveMode uint glBeginTransformFeedbackEXT(uint) public static extern void glBeginTransformFeedbackEXT(uint primitiveMode) Parameters primitiveMode uint glBeginTransformFeedbackNV(uint) public static extern void glBeginTransformFeedbackNV(uint primitiveMode) Parameters primitiveMode uint glBeginVertexShaderEXT() public static extern void glBeginVertexShaderEXT() glBeginVideoCaptureNV(uint) public static extern void glBeginVideoCaptureNV(uint video_capture_slot) Parameters video_capture_slot uint glBindAttribLocation(uint, uint, string) public static extern void glBindAttribLocation(uint program, uint index, string name) Parameters program uint index uint name string glBindAttribLocationARB(uint, uint, string) public static extern void glBindAttribLocationARB(uint programObj, uint index, string name) Parameters programObj uint index uint name string glBindBuffer(uint, uint) public static extern void glBindBuffer(uint target, uint buffer) Parameters target uint buffer uint glBindBufferARB(uint, uint) public static extern void glBindBufferARB(uint target, uint buffer) Parameters target uint buffer uint glBindBufferBase(uint, uint, uint) public static extern void glBindBufferBase(uint target, uint index, uint buffer) Parameters target uint index uint buffer uint glBindBufferBaseEXT(uint, uint, uint) public static extern void glBindBufferBaseEXT(uint target, uint index, uint buffer) Parameters target uint index uint buffer uint glBindBufferBaseNV(uint, uint, uint) public static extern void glBindBufferBaseNV(uint target, uint index, uint buffer) Parameters target uint index uint buffer uint glBindBufferOffsetEXT(uint, uint, uint, nint) public static extern void glBindBufferOffsetEXT(uint target, uint index, uint buffer, nint offset) Parameters target uint index uint buffer uint offset nint glBindBufferOffsetNV(uint, uint, uint, nint) public static extern void glBindBufferOffsetNV(uint target, uint index, uint buffer, nint offset) Parameters target uint index uint buffer uint offset nint glBindBufferRange(uint, uint, uint, nint, nint) public static extern void glBindBufferRange(uint target, uint index, uint buffer, nint offset, nint size) Parameters target uint index uint buffer uint offset nint size nint glBindBufferRangeEXT(uint, uint, uint, nint, nint) public static extern void glBindBufferRangeEXT(uint target, uint index, uint buffer, nint offset, nint size) Parameters target uint index uint buffer uint offset nint size nint glBindBufferRangeNV(uint, uint, uint, nint, nint) public static extern void glBindBufferRangeNV(uint target, uint index, uint buffer, nint offset, nint size) Parameters target uint index uint buffer uint offset nint size nint glBindFragDataLocation(uint, uint, string) public static extern void glBindFragDataLocation(uint program, uint color, string name) Parameters program uint color uint name string glBindFragDataLocationEXT(uint, uint, string) public static extern void glBindFragDataLocationEXT(uint program, uint color, string name) Parameters program uint color uint name string glBindFragDataLocationIndexed(uint, uint, uint, string) public static extern void glBindFragDataLocationIndexed(uint program, uint colorNumber, uint index, string name) Parameters program uint colorNumber uint index uint name string glBindFragmentShaderATI(uint) public static extern void glBindFragmentShaderATI(uint id) Parameters id uint glBindFramebuffer(uint, uint) public static extern void glBindFramebuffer(uint target, uint framebuffer) Parameters target uint framebuffer uint glBindFramebufferEXT(uint, uint) public static extern void glBindFramebufferEXT(uint target, uint framebuffer) Parameters target uint framebuffer uint glBindImageTextureEXT(uint, uint, int, bool, int, uint, int) public static extern void glBindImageTextureEXT(uint index, uint texture, int level, bool layered, int layer, uint access, int format) Parameters index uint texture uint level int layered bool layer int access uint format int glBindLightParameterEXT(uint, uint) public static extern int glBindLightParameterEXT(uint light, uint value) Parameters light uint value uint Returns int glBindMaterialParameterEXT(uint, uint) public static extern int glBindMaterialParameterEXT(uint face, uint value) Parameters face uint value uint Returns int glBindMultiTextureEXT(uint, uint, uint) public static extern void glBindMultiTextureEXT(uint texunit, uint target, uint texture) Parameters texunit uint target uint texture uint glBindParameterEXT(uint) public static extern int glBindParameterEXT(uint value) Parameters value uint Returns int glBindProgramARB(uint, uint) public static extern void glBindProgramARB(uint target, uint program) Parameters target uint program uint glBindProgramNV(uint, uint) public static extern void glBindProgramNV(uint target, uint id) Parameters target uint id uint glBindProgramPipeline(uint) public static extern void glBindProgramPipeline(uint pipeline) Parameters pipeline uint glBindRenderbuffer(uint, uint) public static extern void glBindRenderbuffer(uint target, uint renderbuffer) Parameters target uint renderbuffer uint glBindRenderbufferEXT(uint, uint) public static extern void glBindRenderbufferEXT(uint target, uint renderbuffer) Parameters target uint renderbuffer uint glBindSampler(uint, uint) public static extern void glBindSampler(uint unit, uint sampler) Parameters unit uint sampler uint glBindTexGenParameterEXT(uint, uint, uint) public static extern int glBindTexGenParameterEXT(uint unit, uint coord, uint value) Parameters unit uint coord uint value uint Returns int glBindTexture(uint, uint) public static extern void glBindTexture(uint target, uint texture) Parameters target uint texture uint glBindTextureEXT(uint, uint) public static extern void glBindTextureEXT(uint target, uint texture) Parameters target uint texture uint glBindTextureUnitParameterEXT(uint, uint) public static extern int glBindTextureUnitParameterEXT(uint unit, uint value) Parameters unit uint value uint Returns int glBindTransformFeedback(uint, uint) public static extern void glBindTransformFeedback(uint target, uint id) Parameters target uint id uint glBindTransformFeedbackNV(uint, uint) public static extern void glBindTransformFeedbackNV(uint target, uint id) Parameters target uint id uint glBindVertexArray(uint) public static extern void glBindVertexArray(uint array) Parameters array uint glBindVertexArrayAPPLE(uint) public static extern void glBindVertexArrayAPPLE(uint array) Parameters array uint glBindVertexShaderEXT(uint) public static extern void glBindVertexShaderEXT(uint id) Parameters id uint glBindVideoCaptureStreamBufferNV(uint, uint, uint, nint) public static extern void glBindVideoCaptureStreamBufferNV(uint video_capture_slot, uint stream, uint frame_region, nint offset) Parameters video_capture_slot uint stream uint frame_region uint offset nint glBindVideoCaptureStreamTextureNV(uint, uint, uint, uint, uint) public static extern void glBindVideoCaptureStreamTextureNV(uint video_capture_slot, uint stream, uint frame_region, uint target, uint texture) Parameters video_capture_slot uint stream uint frame_region uint target uint texture uint glBlendColor(float, float, float, float) public static extern void glBlendColor(float red, float green, float blue, float alpha) Parameters red float green float blue float alpha float glBlendColorEXT(float, float, float, float) public static extern void glBlendColorEXT(float red, float green, float blue, float alpha) Parameters red float green float blue float alpha float glBlendEquation(uint) public static extern void glBlendEquation(uint mode) Parameters mode uint glBlendEquationEXT(uint) public static extern void glBlendEquationEXT(uint mode) Parameters mode uint glBlendEquationIndexedAMD(uint, uint) public static extern void glBlendEquationIndexedAMD(uint buf, uint mode) Parameters buf uint mode uint glBlendEquationSeparate(uint, uint) public static extern void glBlendEquationSeparate(uint modeRGB, uint modeAlpha) Parameters modeRGB uint modeAlpha uint glBlendEquationSeparateEXT(uint, uint) public static extern void glBlendEquationSeparateEXT(uint modeRGB, uint modeAlpha) Parameters modeRGB uint modeAlpha uint glBlendEquationSeparateIndexedAMD(uint, uint, uint) public static extern void glBlendEquationSeparateIndexedAMD(uint buf, uint modeRGB, uint modeAlpha) Parameters buf uint modeRGB uint modeAlpha uint glBlendEquationSeparatei(uint, uint, uint) public static extern void glBlendEquationSeparatei(uint buf, uint modeRGB, uint modeAlpha) Parameters buf uint modeRGB uint modeAlpha uint glBlendEquationSeparateiARB(uint, uint, uint) public static extern void glBlendEquationSeparateiARB(uint buf, uint modeRGB, uint modeAlpha) Parameters buf uint modeRGB uint modeAlpha uint glBlendEquationi(uint, uint) public static extern void glBlendEquationi(uint buf, uint mode) Parameters buf uint mode uint glBlendEquationiARB(uint, uint) public static extern void glBlendEquationiARB(uint buf, uint mode) Parameters buf uint mode uint glBlendFunc(uint, uint) public static extern void glBlendFunc(uint sfactor, uint dfactor) Parameters sfactor uint dfactor uint glBlendFuncIndexedAMD(uint, uint, uint) public static extern void glBlendFuncIndexedAMD(uint buf, uint src, uint dst) Parameters buf uint src uint dst uint glBlendFuncSeparate(uint, uint, uint, uint) public static extern void glBlendFuncSeparate(uint sfactorRGB, uint dfactorRGB, uint sfactorAlpha, uint dfactorAlpha) Parameters sfactorRGB uint dfactorRGB uint sfactorAlpha uint dfactorAlpha uint glBlendFuncSeparateEXT(uint, uint, uint, uint) public static extern void glBlendFuncSeparateEXT(uint sfactorRGB, uint dfactorRGB, uint sfactorAlpha, uint dfactorAlpha) Parameters sfactorRGB uint dfactorRGB uint sfactorAlpha uint dfactorAlpha uint glBlendFuncSeparateINGR(uint, uint, uint, uint) public static extern void glBlendFuncSeparateINGR(uint sfactorRGB, uint dfactorRGB, uint sfactorAlpha, uint dfactorAlpha) Parameters sfactorRGB uint dfactorRGB uint sfactorAlpha uint dfactorAlpha uint glBlendFuncSeparateIndexedAMD(uint, uint, uint, uint, uint) public static extern void glBlendFuncSeparateIndexedAMD(uint buf, uint srcRGB, uint dstRGB, uint srcAlpha, uint dstAlpha) Parameters buf uint srcRGB uint dstRGB uint srcAlpha uint dstAlpha uint glBlendFuncSeparatei(uint, uint, uint, uint, uint) public static extern void glBlendFuncSeparatei(uint buf, uint srcRGB, uint dstRGB, uint srcAlpha, uint dstAlpha) Parameters buf uint srcRGB uint dstRGB uint srcAlpha uint dstAlpha uint glBlendFuncSeparateiARB(uint, uint, uint, uint, uint) public static extern void glBlendFuncSeparateiARB(uint buf, uint srcRGB, uint dstRGB, uint srcAlpha, uint dstAlpha) Parameters buf uint srcRGB uint dstRGB uint srcAlpha uint dstAlpha uint glBlendFunci(uint, uint, uint) public static extern void glBlendFunci(uint buf, uint src, uint dst) Parameters buf uint src uint dst uint glBlendFunciARB(uint, uint, uint) public static extern void glBlendFunciARB(uint buf, uint src, uint dst) Parameters buf uint src uint dst uint glBlitFramebuffer(int, int, int, int, int, int, int, int, uint, uint) public static extern void glBlitFramebuffer(int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, uint mask, uint filter) Parameters srcX0 int srcY0 int srcX1 int srcY1 int dstX0 int dstY0 int dstX1 int dstY1 int mask uint filter uint glBlitFramebufferEXT(int, int, int, int, int, int, int, int, uint, uint) public static extern void glBlitFramebufferEXT(int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, uint mask, uint filter) Parameters srcX0 int srcY0 int srcX1 int srcY1 int dstX0 int dstY0 int dstX1 int dstY1 int mask uint filter uint glBufferAddressRangeNV(uint, uint, ulong, nint) public static extern void glBufferAddressRangeNV(uint pname, uint index, ulong address, nint length) Parameters pname uint index uint address ulong length nint glBufferData(uint, nint, nint, uint) public static extern void glBufferData(uint target, nint size, nint data, uint usage) Parameters target uint size nint data nint usage uint glBufferDataARB(uint, nint, nint, uint) public static extern void glBufferDataARB(uint target, nint size, nint data, uint usage) Parameters target uint size nint data nint usage uint glBufferParameteriAPPLE(uint, uint, int) public static extern void glBufferParameteriAPPLE(uint target, uint pname, int param) Parameters target uint pname uint param int glBufferSubData(uint, nint, nint, nint) public static extern void glBufferSubData(uint target, nint offset, nint size, nint data) Parameters target uint offset nint size nint data nint glBufferSubDataARB(uint, nint, nint, nint) public static extern void glBufferSubDataARB(uint target, nint offset, nint size, nint data) Parameters target uint offset nint size nint data nint glCheckFramebufferStatus(uint) public static extern uint glCheckFramebufferStatus(uint target) Parameters target uint Returns uint glCheckFramebufferStatusEXT(uint) public static extern uint glCheckFramebufferStatusEXT(uint target) Parameters target uint Returns uint glCheckNamedFramebufferStatusEXT(uint, uint) public static extern uint glCheckNamedFramebufferStatusEXT(uint framebuffer, uint target) Parameters framebuffer uint target uint Returns uint glClampColor(uint, uint) public static extern void glClampColor(uint target, uint clamp) Parameters target uint clamp uint glClampColorARB(uint, uint) public static extern void glClampColorARB(uint target, uint clamp) Parameters target uint clamp uint glClear(uint) public static extern void glClear(uint mask) Parameters mask uint glClearBufferfi(uint, int, float, int) public static extern void glClearBufferfi(uint buffer, int drawbuffer, float depth, int stencil) Parameters buffer uint drawbuffer int depth float stencil int glClearBufferfv(uint, int, float*) public static extern void glClearBufferfv(uint buffer, int drawbuffer, float* value) Parameters buffer uint drawbuffer int value float* glClearBufferiv(uint, int, int*) public static extern void glClearBufferiv(uint buffer, int drawbuffer, int* value) Parameters buffer uint drawbuffer int value int* glClearBufferuiv(uint, int, uint*) public static extern void glClearBufferuiv(uint buffer, int drawbuffer, uint* value) Parameters buffer uint drawbuffer int value uint* glClearColor(float, float, float, float) public static extern void glClearColor(float red, float green, float blue, float alpha) Parameters red float green float blue float alpha float glClearColorIiEXT(int, int, int, int) public static extern void glClearColorIiEXT(int red, int green, int blue, int alpha) Parameters red int green int blue int alpha int glClearColorIuiEXT(uint, uint, uint, uint) public static extern void glClearColorIuiEXT(uint red, uint green, uint blue, uint alpha) Parameters red uint green uint blue uint alpha uint glClearDepth(double) public static extern void glClearDepth(double depth) Parameters depth double glClearDepthdNV(double) public static extern void glClearDepthdNV(double depth) Parameters depth double glClearDepthf(float) public static extern void glClearDepthf(float d) Parameters d float glClearStencil(int) public static extern void glClearStencil(int s) Parameters s int glClientActiveVertexStreamATI(uint) public static extern void glClientActiveVertexStreamATI(uint stream) Parameters stream uint glClientAttribDefaultEXT(uint) public static extern void glClientAttribDefaultEXT(uint mask) Parameters mask uint glClientWaitSync(nint, uint, ulong) public static extern uint glClientWaitSync(nint sync, uint flags, ulong timeout) Parameters sync nint flags uint timeout ulong Returns uint glColorFormatNV(int, uint, int) public static extern void glColorFormatNV(int size, uint type, int stride) Parameters size int type uint stride int glColorMask(bool, bool, bool, bool) public static extern void glColorMask(bool red, bool green, bool blue, bool alpha) Parameters red bool green bool blue bool alpha bool glColorMaskIndexedEXT(uint, bool, bool, bool, bool) public static extern void glColorMaskIndexedEXT(uint index, bool r, bool g, bool b, bool a) Parameters index uint r bool g bool b bool a bool glColorMaski(uint, bool, bool, bool, bool) public static extern void glColorMaski(uint index, bool r, bool g, bool b, bool a) Parameters index uint r bool g bool b bool a bool glColorPointerListIBM(int, uint, int, nint, int) public static extern void glColorPointerListIBM(int size, uint type, int stride, nint pointer, int ptrstride) Parameters size int type uint stride int pointer nint ptrstride int glColorPointervINTEL(int, uint, nint) public static extern void glColorPointervINTEL(int size, uint type, nint pointer) Parameters size int type uint pointer nint glCombinerStageParameterfvNV(uint, uint, float*) public static extern void glCombinerStageParameterfvNV(uint stage, uint pname, float* @params) Parameters stage uint pname uint params float* glCompileShader(uint) public static extern void glCompileShader(uint shader) Parameters shader uint glCompileShaderARB(uint) public static extern void glCompileShaderARB(uint shaderObj) Parameters shaderObj uint glCompileShaderIncludeARB(uint, int, string[], int*) public static extern void glCompileShaderIncludeARB(uint shader, int count, string[] path, int* length) Parameters shader uint count int path string[] length int* glCompressedMultiTexImage1DEXT(uint, uint, int, uint, int, int, int, nint) public static extern void glCompressedMultiTexImage1DEXT(uint texunit, uint target, int level, uint internalformat, int width, int border, int imageSize, nint bits) Parameters texunit uint target uint level int internalformat uint width int border int imageSize int bits nint glCompressedMultiTexImage2DEXT(uint, uint, int, uint, int, int, int, int, nint) public static extern void glCompressedMultiTexImage2DEXT(uint texunit, uint target, int level, uint internalformat, int width, int height, int border, int imageSize, nint bits) Parameters texunit uint target uint level int internalformat uint width int height int border int imageSize int bits nint glCompressedMultiTexImage3DEXT(uint, uint, int, uint, int, int, int, int, int, nint) public static extern void glCompressedMultiTexImage3DEXT(uint texunit, uint target, int level, uint internalformat, int width, int height, int depth, int border, int imageSize, nint bits) Parameters texunit uint target uint level int internalformat uint width int height int depth int border int imageSize int bits nint glCompressedMultiTexSubImage1DEXT(uint, uint, int, int, int, uint, int, nint) public static extern void glCompressedMultiTexSubImage1DEXT(uint texunit, uint target, int level, int xoffset, int width, uint format, int imageSize, nint bits) Parameters texunit uint target uint level int xoffset int width int format uint imageSize int bits nint glCompressedMultiTexSubImage2DEXT(uint, uint, int, int, int, int, int, uint, int, nint) public static extern void glCompressedMultiTexSubImage2DEXT(uint texunit, uint target, int level, int xoffset, int yoffset, int width, int height, uint format, int imageSize, nint bits) Parameters texunit uint target uint level int xoffset int yoffset int width int height int format uint imageSize int bits nint glCompressedMultiTexSubImage3DEXT(uint, uint, int, int, int, int, int, int, int, uint, int, nint) public static extern void glCompressedMultiTexSubImage3DEXT(uint texunit, uint target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, int imageSize, nint bits) Parameters texunit uint target uint level int xoffset int yoffset int zoffset int width int height int depth int format uint imageSize int bits nint glCompressedTexImage1D(uint, int, uint, int, int, int, nint) public static extern void glCompressedTexImage1D(uint target, int level, uint internalformat, int width, int border, int imageSize, nint data) Parameters target uint level int internalformat uint width int border int imageSize int data nint glCompressedTexImage1DARB(uint, int, uint, int, int, int, nint) public static extern void glCompressedTexImage1DARB(uint target, int level, uint internalformat, int width, int border, int imageSize, nint data) Parameters target uint level int internalformat uint width int border int imageSize int data nint glCompressedTexImage2D(uint, int, uint, int, int, int, int, nint) public static extern void glCompressedTexImage2D(uint target, int level, uint internalformat, int width, int height, int border, int imageSize, nint data) Parameters target uint level int internalformat uint width int height int border int imageSize int data nint glCompressedTexImage2DARB(uint, int, uint, int, int, int, int, nint) public static extern void glCompressedTexImage2DARB(uint target, int level, uint internalformat, int width, int height, int border, int imageSize, nint data) Parameters target uint level int internalformat uint width int height int border int imageSize int data nint glCompressedTexImage3D(uint, int, uint, int, int, int, int, int, nint) public static extern void glCompressedTexImage3D(uint target, int level, uint internalformat, int width, int height, int depth, int border, int imageSize, nint data) Parameters target uint level int internalformat uint width int height int depth int border int imageSize int data nint glCompressedTexImage3DARB(uint, int, uint, int, int, int, int, int, nint) public static extern void glCompressedTexImage3DARB(uint target, int level, uint internalformat, int width, int height, int depth, int border, int imageSize, nint data) Parameters target uint level int internalformat uint width int height int depth int border int imageSize int data nint glCompressedTexSubImage1D(uint, int, int, int, uint, int, nint) public static extern void glCompressedTexSubImage1D(uint target, int level, int xoffset, int width, uint format, int imageSize, nint data) Parameters target uint level int xoffset int width int format uint imageSize int data nint glCompressedTexSubImage1DARB(uint, int, int, int, uint, int, nint) public static extern void glCompressedTexSubImage1DARB(uint target, int level, int xoffset, int width, uint format, int imageSize, nint data) Parameters target uint level int xoffset int width int format uint imageSize int data nint glCompressedTexSubImage2D(uint, int, int, int, int, int, uint, int, nint) public static extern void glCompressedTexSubImage2D(uint target, int level, int xoffset, int yoffset, int width, int height, uint format, int imageSize, nint data) Parameters target uint level int xoffset int yoffset int width int height int format uint imageSize int data nint glCompressedTexSubImage2DARB(uint, int, int, int, int, int, uint, int, nint) public static extern void glCompressedTexSubImage2DARB(uint target, int level, int xoffset, int yoffset, int width, int height, uint format, int imageSize, nint data) Parameters target uint level int xoffset int yoffset int width int height int format uint imageSize int data nint glCompressedTexSubImage3D(uint, int, int, int, int, int, int, int, uint, int, nint) public static extern void glCompressedTexSubImage3D(uint target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, int imageSize, nint data) Parameters target uint level int xoffset int yoffset int zoffset int width int height int depth int format uint imageSize int data nint glCompressedTexSubImage3DARB(uint, int, int, int, int, int, int, int, uint, int, nint) public static extern void glCompressedTexSubImage3DARB(uint target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, int imageSize, nint data) Parameters target uint level int xoffset int yoffset int zoffset int width int height int depth int format uint imageSize int data nint glCompressedTextureImage1DEXT(uint, uint, int, uint, int, int, int, nint) public static extern void glCompressedTextureImage1DEXT(uint texture, uint target, int level, uint internalformat, int width, int border, int imageSize, nint bits) Parameters texture uint target uint level int internalformat uint width int border int imageSize int bits nint glCompressedTextureImage2DEXT(uint, uint, int, uint, int, int, int, int, nint) public static extern void glCompressedTextureImage2DEXT(uint texture, uint target, int level, uint internalformat, int width, int height, int border, int imageSize, nint bits) Parameters texture uint target uint level int internalformat uint width int height int border int imageSize int bits nint glCompressedTextureImage3DEXT(uint, uint, int, uint, int, int, int, int, int, nint) public static extern void glCompressedTextureImage3DEXT(uint texture, uint target, int level, uint internalformat, int width, int height, int depth, int border, int imageSize, nint bits) Parameters texture uint target uint level int internalformat uint width int height int depth int border int imageSize int bits nint glCompressedTextureSubImage1DEXT(uint, uint, int, int, int, uint, int, nint) public static extern void glCompressedTextureSubImage1DEXT(uint texture, uint target, int level, int xoffset, int width, uint format, int imageSize, nint bits) Parameters texture uint target uint level int xoffset int width int format uint imageSize int bits nint glCompressedTextureSubImage2DEXT(uint, uint, int, int, int, int, int, uint, int, nint) public static extern void glCompressedTextureSubImage2DEXT(uint texture, uint target, int level, int xoffset, int yoffset, int width, int height, uint format, int imageSize, nint bits) Parameters texture uint target uint level int xoffset int yoffset int width int height int format uint imageSize int bits nint glCompressedTextureSubImage3DEXT(uint, uint, int, int, int, int, int, int, int, uint, int, nint) public static extern void glCompressedTextureSubImage3DEXT(uint texture, uint target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, int imageSize, nint bits) Parameters texture uint target uint level int xoffset int yoffset int zoffset int width int height int depth int format uint imageSize int bits nint glCopyBufferSubData(uint, uint, nint, nint, nint) public static extern void glCopyBufferSubData(uint readTarget, uint writeTarget, nint readOffset, nint writeOffset, nint size) Parameters readTarget uint writeTarget uint readOffset nint writeOffset nint size nint glCopyImageSubDataNV(uint, uint, int, int, int, int, uint, uint, int, int, int, int, int, int, int) public static extern void glCopyImageSubDataNV(uint srcName, uint srcTarget, int srcLevel, int srcX, int srcY, int srcZ, uint dstName, uint dstTarget, int dstLevel, int dstX, int dstY, int dstZ, int width, int height, int depth) Parameters srcName uint srcTarget uint srcLevel int srcX int srcY int srcZ int dstName uint dstTarget uint dstLevel int dstX int dstY int dstZ int width int height int depth int glCopyMultiTexImage1DEXT(uint, uint, int, uint, int, int, int, int) public static extern void glCopyMultiTexImage1DEXT(uint texunit, uint target, int level, uint internalformat, int x, int y, int width, int border) Parameters texunit uint target uint level int internalformat uint x int y int width int border int glCopyMultiTexImage2DEXT(uint, uint, int, uint, int, int, int, int, int) public static extern void glCopyMultiTexImage2DEXT(uint texunit, uint target, int level, uint internalformat, int x, int y, int width, int height, int border) Parameters texunit uint target uint level int internalformat uint x int y int width int height int border int glCopyMultiTexSubImage1DEXT(uint, uint, int, int, int, int, int) public static extern void glCopyMultiTexSubImage1DEXT(uint texunit, uint target, int level, int xoffset, int x, int y, int width) Parameters texunit uint target uint level int xoffset int x int y int width int glCopyMultiTexSubImage2DEXT(uint, uint, int, int, int, int, int, int, int) public static extern void glCopyMultiTexSubImage2DEXT(uint texunit, uint target, int level, int xoffset, int yoffset, int x, int y, int width, int height) Parameters texunit uint target uint level int xoffset int yoffset int x int y int width int height int glCopyMultiTexSubImage3DEXT(uint, uint, int, int, int, int, int, int, int, int) public static extern void glCopyMultiTexSubImage3DEXT(uint texunit, uint target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height) Parameters texunit uint target uint level int xoffset int yoffset int zoffset int x int y int width int height int glCopyTexImage1D(uint, int, uint, int, int, int, int) public static extern void glCopyTexImage1D(uint target, int level, uint internalformat, int x, int y, int width, int border) Parameters target uint level int internalformat uint x int y int width int border int glCopyTexImage1DEXT(uint, int, uint, int, int, int, int) public static extern void glCopyTexImage1DEXT(uint target, int level, uint internalformat, int x, int y, int width, int border) Parameters target uint level int internalformat uint x int y int width int border int glCopyTexImage2D(uint, int, uint, int, int, int, int, int) public static extern void glCopyTexImage2D(uint target, int level, uint internalformat, int x, int y, int width, int height, int border) Parameters target uint level int internalformat uint x int y int width int height int border int glCopyTexImage2DEXT(uint, int, uint, int, int, int, int, int) public static extern void glCopyTexImage2DEXT(uint target, int level, uint internalformat, int x, int y, int width, int height, int border) Parameters target uint level int internalformat uint x int y int width int height int border int glCopyTexSubImage1D(uint, int, int, int, int, int) public static extern void glCopyTexSubImage1D(uint target, int level, int xoffset, int x, int y, int width) Parameters target uint level int xoffset int x int y int width int glCopyTexSubImage1DEXT(uint, int, int, int, int, int) public static extern void glCopyTexSubImage1DEXT(uint target, int level, int xoffset, int x, int y, int width) Parameters target uint level int xoffset int x int y int width int glCopyTexSubImage2D(uint, int, int, int, int, int, int, int) public static extern void glCopyTexSubImage2D(uint target, int level, int xoffset, int yoffset, int x, int y, int width, int height) Parameters target uint level int xoffset int yoffset int x int y int width int height int glCopyTexSubImage2DEXT(uint, int, int, int, int, int, int, int) public static extern void glCopyTexSubImage2DEXT(uint target, int level, int xoffset, int yoffset, int x, int y, int width, int height) Parameters target uint level int xoffset int yoffset int x int y int width int height int glCopyTexSubImage3D(uint, int, int, int, int, int, int, int, int) public static extern void glCopyTexSubImage3D(uint target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height) Parameters target uint level int xoffset int yoffset int zoffset int x int y int width int height int glCopyTexSubImage3DEXT(uint, int, int, int, int, int, int, int, int) public static extern void glCopyTexSubImage3DEXT(uint target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height) Parameters target uint level int xoffset int yoffset int zoffset int x int y int width int height int glCopyTextureImage1DEXT(uint, uint, int, uint, int, int, int, int) public static extern void glCopyTextureImage1DEXT(uint texture, uint target, int level, uint internalformat, int x, int y, int width, int border) Parameters texture uint target uint level int internalformat uint x int y int width int border int glCopyTextureImage2DEXT(uint, uint, int, uint, int, int, int, int, int) public static extern void glCopyTextureImage2DEXT(uint texture, uint target, int level, uint internalformat, int x, int y, int width, int height, int border) Parameters texture uint target uint level int internalformat uint x int y int width int height int border int glCopyTextureSubImage1DEXT(uint, uint, int, int, int, int, int) public static extern void glCopyTextureSubImage1DEXT(uint texture, uint target, int level, int xoffset, int x, int y, int width) Parameters texture uint target uint level int xoffset int x int y int width int glCopyTextureSubImage2DEXT(uint, uint, int, int, int, int, int, int, int) public static extern void glCopyTextureSubImage2DEXT(uint texture, uint target, int level, int xoffset, int yoffset, int x, int y, int width, int height) Parameters texture uint target uint level int xoffset int yoffset int x int y int width int height int glCopyTextureSubImage3DEXT(uint, uint, int, int, int, int, int, int, int, int) public static extern void glCopyTextureSubImage3DEXT(uint texture, uint target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height) Parameters texture uint target uint level int xoffset int yoffset int zoffset int x int y int width int height int glCreateProgram() public static extern int glCreateProgram() Returns int glCreateProgramObjectARB() public static extern int glCreateProgramObjectARB() Returns int glCreateShader(uint) public static extern int glCreateShader(uint type) Parameters type uint Returns int glCreateShaderObjectARB(uint) public static extern int glCreateShaderObjectARB(uint shaderType) Parameters shaderType uint Returns int glCreateShaderProgramEXT(uint, string) public static extern int glCreateShaderProgramEXT(uint type, string @string) Parameters type uint string string Returns int glCreateShaderProgramv(uint, int, string[]) public static extern int glCreateShaderProgramv(uint type, int count, string[] strings) Parameters type uint count int strings string[] Returns int glCreateSyncFromCLeventARB(nint, nint, uint) public static extern nint glCreateSyncFromCLeventARB(nint context, nint @event, uint flags) Parameters context nint event nint flags uint Returns nint glCullFace(uint) public static extern void glCullFace(uint mode) Parameters mode uint glCullParameterdvEXT(uint, double*) public static extern void glCullParameterdvEXT(uint pname, double* @params) Parameters pname uint params double* glCullParameterfvEXT(uint, float*) public static extern void glCullParameterfvEXT(uint pname, float* @params) Parameters pname uint params float* glDebugMessageControlARB(uint, uint, uint, int, uint*, bool) public static extern void glDebugMessageControlARB(uint source, uint type, uint severity, int count, uint* ids, bool enabled) Parameters source uint type uint severity uint count int ids uint* enabled bool glDebugMessageEnableAMD(uint, uint, int, uint*, bool) public static extern void glDebugMessageEnableAMD(uint category, uint severity, int count, uint* ids, bool enabled) Parameters category uint severity uint count int ids uint* enabled bool glDebugMessageInsertAMD(uint, uint, uint, int, string) public static extern void glDebugMessageInsertAMD(uint category, uint severity, uint id, int length, string buf) Parameters category uint severity uint id uint length int buf string glDebugMessageInsertARB(uint, uint, uint, uint, int, string) public static extern void glDebugMessageInsertARB(uint source, uint type, uint id, uint severity, int length, string buf) Parameters source uint type uint id uint severity uint length int buf string glDeleteAsyncMarkersSGIX(uint, int) public static extern void glDeleteAsyncMarkersSGIX(uint marker, int range) Parameters marker uint range int glDeleteBuffers(int, uint*) public static extern void glDeleteBuffers(int n, uint* buffers) Parameters n int buffers uint* glDeleteBuffersARB(int, uint*) public static extern void glDeleteBuffersARB(int n, uint* buffers) Parameters n int buffers uint* glDeleteFencesAPPLE(int, uint*) public static extern void glDeleteFencesAPPLE(int n, uint* fences) Parameters n int fences uint* glDeleteFencesNV(int, uint*) public static extern void glDeleteFencesNV(int n, uint* fences) Parameters n int fences uint* glDeleteFragmentShaderATI(uint) public static extern void glDeleteFragmentShaderATI(uint id) Parameters id uint glDeleteFramebuffers(int, uint*) public static extern void glDeleteFramebuffers(int n, uint* framebuffers) Parameters n int framebuffers uint* glDeleteFramebuffersEXT(int, uint*) public static extern void glDeleteFramebuffersEXT(int n, uint* framebuffers) Parameters n int framebuffers uint* glDeleteNamedStringARB(int, string) public static extern void glDeleteNamedStringARB(int namelen, string name) Parameters namelen int name string glDeleteNamesAMD(uint, uint, uint*) public static extern void glDeleteNamesAMD(uint identifier, uint num, uint* names) Parameters identifier uint num uint names uint* glDeleteObjectARB(uint) public static extern void glDeleteObjectARB(uint obj) Parameters obj uint glDeleteOcclusionQueriesNV(int, uint*) public static extern void glDeleteOcclusionQueriesNV(int n, uint* ids) Parameters n int ids uint* glDeletePerfMonitorsAMD(int, uint*) public static extern void glDeletePerfMonitorsAMD(int n, uint* monitors) Parameters n int monitors uint* glDeleteProgram(uint) public static extern void glDeleteProgram(uint program) Parameters program uint glDeleteProgramPipelines(int, uint*) public static extern void glDeleteProgramPipelines(int n, uint* pipelines) Parameters n int pipelines uint* glDeleteProgramsARB(int, uint*) public static extern void glDeleteProgramsARB(int n, uint* programs) Parameters n int programs uint* glDeleteProgramsNV(int, uint*) public static extern void glDeleteProgramsNV(int n, uint* programs) Parameters n int programs uint* glDeleteQueries(int, uint*) public static extern void glDeleteQueries(int n, uint* ids) Parameters n int ids uint* glDeleteQueriesARB(int, uint*) public static extern void glDeleteQueriesARB(int n, uint* ids) Parameters n int ids uint* glDeleteRenderbuffers(int, uint*) public static extern void glDeleteRenderbuffers(int n, uint* renderbuffers) Parameters n int renderbuffers uint* glDeleteRenderbuffersEXT(int, uint*) public static extern void glDeleteRenderbuffersEXT(int n, uint* renderbuffers) Parameters n int renderbuffers uint* glDeleteSamplers(int, uint*) public static extern void glDeleteSamplers(int count, uint* samplers) Parameters count int samplers uint* glDeleteShader(uint) public static extern void glDeleteShader(uint shader) Parameters shader uint glDeleteSync(nint) public static extern void glDeleteSync(nint sync) Parameters sync nint glDeleteTextures(int, uint*) public static extern void glDeleteTextures(int n, uint* textures) Parameters n int textures uint* glDeleteTexturesEXT(int, uint*) public static extern void glDeleteTexturesEXT(int n, uint* textures) Parameters n int textures uint* glDeleteTransformFeedbacks(int, uint*) public static extern void glDeleteTransformFeedbacks(int n, uint* ids) Parameters n int ids uint* glDeleteTransformFeedbacksNV(int, uint*) public static extern void glDeleteTransformFeedbacksNV(int n, uint* ids) Parameters n int ids uint* glDeleteVertexArrays(int, uint*) public static extern void glDeleteVertexArrays(int n, uint* arrays) Parameters n int arrays uint* glDeleteVertexArraysAPPLE(int, uint*) public static extern void glDeleteVertexArraysAPPLE(int n, uint* arrays) Parameters n int arrays uint* glDeleteVertexShaderEXT(uint) public static extern void glDeleteVertexShaderEXT(uint id) Parameters id uint glDepthBoundsEXT(double, double) public static extern void glDepthBoundsEXT(double zmin, double zmax) Parameters zmin double zmax double glDepthBoundsdNV(double, double) public static extern void glDepthBoundsdNV(double zmin, double zmax) Parameters zmin double zmax double glDepthFunc(uint) public static extern void glDepthFunc(uint func) Parameters func uint glDepthMask(bool) public static extern void glDepthMask(bool flag) Parameters flag bool glDepthRange(double, double) public static extern void glDepthRange(double near, double far) Parameters near double far double glDepthRangeArrayv(uint, int, double*) public static extern void glDepthRangeArrayv(uint first, int count, double* v) Parameters first uint count int v double* glDepthRangeIndexed(uint, double, double) public static extern void glDepthRangeIndexed(uint index, double n, double f) Parameters index uint n double f double glDepthRangedNV(double, double) public static extern void glDepthRangedNV(double zNear, double zFar) Parameters zNear double zFar double glDepthRangef(float, float) public static extern void glDepthRangef(float n, float f) Parameters n float f float glDetachObjectARB(uint, uint) public static extern void glDetachObjectARB(uint containerObj, uint attachedObj) Parameters containerObj uint attachedObj uint glDetachShader(uint, uint) public static extern void glDetachShader(uint program, uint shader) Parameters program uint shader uint glDisable(uint) public static extern void glDisable(uint cap) Parameters cap uint glDisableClientStateIndexedEXT(uint, uint) public static extern void glDisableClientStateIndexedEXT(uint array, uint index) Parameters array uint index uint glDisableIndexedEXT(uint, uint) public static extern void glDisableIndexedEXT(uint target, uint index) Parameters target uint index uint glDisableVariantClientStateEXT(uint) public static extern void glDisableVariantClientStateEXT(uint id) Parameters id uint glDisableVertexAttribAPPLE(uint, uint) public static extern void glDisableVertexAttribAPPLE(uint index, uint pname) Parameters index uint pname uint glDisableVertexAttribArray(uint) public static extern void glDisableVertexAttribArray(uint index) Parameters index uint glDisableVertexAttribArrayARB(uint) public static extern void glDisableVertexAttribArrayARB(uint index) Parameters index uint glDisablei(uint, uint) public static extern void glDisablei(uint target, uint index) Parameters target uint index uint glDrawArrays(uint, int, int) public static extern void glDrawArrays(uint mode, int first, int count) Parameters mode uint first int count int glDrawArraysEXT(uint, int, int) public static extern void glDrawArraysEXT(uint mode, int first, int count) Parameters mode uint first int count int glDrawArraysIndirect(uint, nint) public static extern void glDrawArraysIndirect(uint mode, nint indirect) Parameters mode uint indirect nint glDrawArraysInstanced(uint, int, int, int) public static extern void glDrawArraysInstanced(uint mode, int first, int count, int primcount) Parameters mode uint first int count int primcount int glDrawArraysInstancedARB(uint, int, int, int) public static extern void glDrawArraysInstancedARB(uint mode, int first, int count, int primcount) Parameters mode uint first int count int primcount int glDrawArraysInstancedEXT(uint, int, int, int) public static extern void glDrawArraysInstancedEXT(uint mode, int start, int count, int primcount) Parameters mode uint start int count int primcount int glDrawBuffer(uint) public static extern void glDrawBuffer(uint mode) Parameters mode uint glDrawBuffers(int, uint*) public static extern void glDrawBuffers(int n, uint* bufs) Parameters n int bufs uint* glDrawBuffersARB(int, uint*) public static extern void glDrawBuffersARB(int n, uint* bufs) Parameters n int bufs uint* glDrawBuffersATI(int, uint*) public static extern void glDrawBuffersATI(int n, uint* bufs) Parameters n int bufs uint* glDrawElementArrayAPPLE(uint, int, int) public static extern void glDrawElementArrayAPPLE(uint mode, int first, int count) Parameters mode uint first int count int glDrawElementArrayATI(uint, int) public static extern void glDrawElementArrayATI(uint mode, int count) Parameters mode uint count int glDrawElements(uint, int, uint, nint) public static extern void glDrawElements(uint mode, int count, uint type, nint indices) Parameters mode uint count int type uint indices nint glDrawElementsBaseVertex(uint, int, uint, nint, int) public static extern void glDrawElementsBaseVertex(uint mode, int count, uint type, nint indices, int basevertex) Parameters mode uint count int type uint indices nint basevertex int glDrawElementsIndirect(uint, uint, nint) public static extern void glDrawElementsIndirect(uint mode, uint type, nint indirect) Parameters mode uint type uint indirect nint glDrawElementsInstanced(uint, int, uint, nint, int) public static extern void glDrawElementsInstanced(uint mode, int count, uint type, nint indices, int primcount) Parameters mode uint count int type uint indices nint primcount int glDrawElementsInstancedARB(uint, int, uint, nint, int) public static extern void glDrawElementsInstancedARB(uint mode, int count, uint type, nint indices, int primcount) Parameters mode uint count int type uint indices nint primcount int glDrawElementsInstancedBaseVertex(uint, int, uint, nint, int, int) public static extern void glDrawElementsInstancedBaseVertex(uint mode, int count, uint type, nint indices, int primcount, int basevertex) Parameters mode uint count int type uint indices nint primcount int basevertex int glDrawElementsInstancedEXT(uint, int, uint, nint, int) public static extern void glDrawElementsInstancedEXT(uint mode, int count, uint type, nint indices, int primcount) Parameters mode uint count int type uint indices nint primcount int glDrawMeshArraysSUN(uint, int, int, int) public static extern void glDrawMeshArraysSUN(uint mode, int first, int count, int width) Parameters mode uint first int count int width int glDrawRangeElementArrayAPPLE(uint, uint, uint, int, int) public static extern void glDrawRangeElementArrayAPPLE(uint mode, uint start, uint end, int first, int count) Parameters mode uint start uint end uint first int count int glDrawRangeElementArrayATI(uint, uint, uint, int) public static extern void glDrawRangeElementArrayATI(uint mode, uint start, uint end, int count) Parameters mode uint start uint end uint count int glDrawRangeElements(uint, uint, uint, int, uint, nint) public static extern void glDrawRangeElements(uint mode, uint start, uint end, int count, uint type, nint indices) Parameters mode uint start uint end uint count int type uint indices nint glDrawRangeElementsBaseVertex(uint, uint, uint, int, uint, nint, int) public static extern void glDrawRangeElementsBaseVertex(uint mode, uint start, uint end, int count, uint type, nint indices, int basevertex) Parameters mode uint start uint end uint count int type uint indices nint basevertex int glDrawRangeElementsEXT(uint, uint, uint, int, uint, nint) public static extern void glDrawRangeElementsEXT(uint mode, uint start, uint end, int count, uint type, nint indices) Parameters mode uint start uint end uint count int type uint indices nint glDrawTransformFeedback(uint, uint) public static extern void glDrawTransformFeedback(uint mode, uint id) Parameters mode uint id uint glDrawTransformFeedbackNV(uint, uint) public static extern void glDrawTransformFeedbackNV(uint mode, uint id) Parameters mode uint id uint glDrawTransformFeedbackStream(uint, uint, uint) public static extern void glDrawTransformFeedbackStream(uint mode, uint id, uint stream) Parameters mode uint id uint stream uint glElementPointerAPPLE(uint, nint) public static extern void glElementPointerAPPLE(uint type, nint pointer) Parameters type uint pointer nint glElementPointerATI(uint, nint) public static extern void glElementPointerATI(uint type, nint pointer) Parameters type uint pointer nint glEnable(uint) public static extern void glEnable(uint cap) Parameters cap uint glEnableClientStateIndexedEXT(uint, uint) public static extern void glEnableClientStateIndexedEXT(uint array, uint index) Parameters array uint index uint glEnableIndexedEXT(uint, uint) public static extern void glEnableIndexedEXT(uint target, uint index) Parameters target uint index uint glEnableVariantClientStateEXT(uint) public static extern void glEnableVariantClientStateEXT(uint id) Parameters id uint glEnableVertexAttribAPPLE(uint, uint) public static extern void glEnableVertexAttribAPPLE(uint index, uint pname) Parameters index uint pname uint glEnableVertexAttribArray(uint) public static extern void glEnableVertexAttribArray(uint index) Parameters index uint glEnableVertexAttribArrayARB(uint) public static extern void glEnableVertexAttribArrayARB(uint index) Parameters index uint glEnablei(uint, uint) public static extern void glEnablei(uint target, uint index) Parameters target uint index uint glEndConditionalRender() public static extern void glEndConditionalRender() glEndConditionalRenderNV() public static extern void glEndConditionalRenderNV() glEndFragmentShaderATI() public static extern void glEndFragmentShaderATI() glEndOcclusionQueryNV() public static extern void glEndOcclusionQueryNV() glEndPerfMonitorAMD(uint) public static extern void glEndPerfMonitorAMD(uint monitor) Parameters monitor uint glEndQuery(uint) public static extern void glEndQuery(uint target) Parameters target uint glEndQueryARB(uint) public static extern void glEndQueryARB(uint target) Parameters target uint glEndQueryIndexed(uint, uint) public static extern void glEndQueryIndexed(uint target, uint index) Parameters target uint index uint glEndTransformFeedback() public static extern void glEndTransformFeedback() glEndTransformFeedbackEXT() public static extern void glEndTransformFeedbackEXT() glEndTransformFeedbackNV() public static extern void glEndTransformFeedbackNV() glEndVertexShaderEXT() public static extern void glEndVertexShaderEXT() glEndVideoCaptureNV(uint) public static extern void glEndVideoCaptureNV(uint video_capture_slot) Parameters video_capture_slot uint glEvalMapsNV(uint, uint) public static extern void glEvalMapsNV(uint target, uint mode) Parameters target uint mode uint glExtractComponentEXT(uint, uint, uint) public static extern void glExtractComponentEXT(uint res, uint src, uint num) Parameters res uint src uint num uint glFinish() public static extern void glFinish() glFinishAsyncSGIX(uint*) public static extern int glFinishAsyncSGIX(uint* markerp) Parameters markerp uint* Returns int glFinishFenceAPPLE(uint) public static extern void glFinishFenceAPPLE(uint fence) Parameters fence uint glFinishFenceNV(uint) public static extern void glFinishFenceNV(uint fence) Parameters fence uint glFinishObjectAPPLE(uint, int) public static extern void glFinishObjectAPPLE(uint @object, int name) Parameters object uint name int glFinishTextureSUNX() public static extern void glFinishTextureSUNX() glFlush() public static extern void glFlush() glFlushMappedBufferRange(uint, nint, nint) public static extern void glFlushMappedBufferRange(uint target, nint offset, nint length) Parameters target uint offset nint length nint glFlushMappedBufferRangeAPPLE(uint, nint, nint) public static extern void glFlushMappedBufferRangeAPPLE(uint target, nint offset, nint size) Parameters target uint offset nint size nint glFlushMappedNamedBufferRangeEXT(uint, nint, nint) public static extern void glFlushMappedNamedBufferRangeEXT(uint buffer, nint offset, nint length) Parameters buffer uint offset nint length nint glFlushPixelDataRangeNV(uint) public static extern void glFlushPixelDataRangeNV(uint target) Parameters target uint glFlushRasterSGIX() public static extern void glFlushRasterSGIX() glFlushVertexArrayRangeAPPLE(int, nint) public static extern void glFlushVertexArrayRangeAPPLE(int length, nint pointer) Parameters length int pointer nint glFlushVertexArrayRangeNV() public static extern void glFlushVertexArrayRangeNV() glFrameTerminatorGREMEDY() public static extern void glFrameTerminatorGREMEDY() glFramebufferDrawBufferEXT(uint, uint) public static extern void glFramebufferDrawBufferEXT(uint framebuffer, uint mode) Parameters framebuffer uint mode uint glFramebufferDrawBuffersEXT(uint, int, uint*) public static extern void glFramebufferDrawBuffersEXT(uint framebuffer, int n, uint* bufs) Parameters framebuffer uint n int bufs uint* glFramebufferReadBufferEXT(uint, uint) public static extern void glFramebufferReadBufferEXT(uint framebuffer, uint mode) Parameters framebuffer uint mode uint glFramebufferRenderbuffer(uint, uint, uint, uint) public static extern void glFramebufferRenderbuffer(uint target, uint attachment, uint renderbuffertarget, uint renderbuffer) Parameters target uint attachment uint renderbuffertarget uint renderbuffer uint glFramebufferRenderbufferEXT(uint, uint, uint, uint) public static extern void glFramebufferRenderbufferEXT(uint target, uint attachment, uint renderbuffertarget, uint renderbuffer) Parameters target uint attachment uint renderbuffertarget uint renderbuffer uint glFramebufferTexture(uint, uint, uint, int) public static extern void glFramebufferTexture(uint target, uint attachment, uint texture, int level) Parameters target uint attachment uint texture uint level int glFramebufferTexture1D(uint, uint, uint, uint, int) public static extern void glFramebufferTexture1D(uint target, uint attachment, uint textarget, uint texture, int level) Parameters target uint attachment uint textarget uint texture uint level int glFramebufferTexture1DEXT(uint, uint, uint, uint, int) public static extern void glFramebufferTexture1DEXT(uint target, uint attachment, uint textarget, uint texture, int level) Parameters target uint attachment uint textarget uint texture uint level int glFramebufferTexture2D(uint, uint, uint, uint, int) public static extern void glFramebufferTexture2D(uint target, uint attachment, uint textarget, uint texture, int level) Parameters target uint attachment uint textarget uint texture uint level int glFramebufferTexture2DEXT(uint, uint, uint, uint, int) public static extern void glFramebufferTexture2DEXT(uint target, uint attachment, uint textarget, uint texture, int level) Parameters target uint attachment uint textarget uint texture uint level int glFramebufferTexture3D(uint, uint, uint, uint, int, int) public static extern void glFramebufferTexture3D(uint target, uint attachment, uint textarget, uint texture, int level, int zoffset) Parameters target uint attachment uint textarget uint texture uint level int zoffset int glFramebufferTexture3DEXT(uint, uint, uint, uint, int, int) public static extern void glFramebufferTexture3DEXT(uint target, uint attachment, uint textarget, uint texture, int level, int zoffset) Parameters target uint attachment uint textarget uint texture uint level int zoffset int glFramebufferTextureARB(uint, uint, uint, int) public static extern void glFramebufferTextureARB(uint target, uint attachment, uint texture, int level) Parameters target uint attachment uint texture uint level int glFramebufferTextureEXT(uint, uint, uint, int) public static extern void glFramebufferTextureEXT(uint target, uint attachment, uint texture, int level) Parameters target uint attachment uint texture uint level int glFramebufferTextureFaceARB(uint, uint, uint, int, uint) public static extern void glFramebufferTextureFaceARB(uint target, uint attachment, uint texture, int level, uint face) Parameters target uint attachment uint texture uint level int face uint glFramebufferTextureFaceEXT(uint, uint, uint, int, uint) public static extern void glFramebufferTextureFaceEXT(uint target, uint attachment, uint texture, int level, uint face) Parameters target uint attachment uint texture uint level int face uint glFramebufferTextureLayer(uint, uint, uint, int, int) public static extern void glFramebufferTextureLayer(uint target, uint attachment, uint texture, int level, int layer) Parameters target uint attachment uint texture uint level int layer int glFramebufferTextureLayerARB(uint, uint, uint, int, int) public static extern void glFramebufferTextureLayerARB(uint target, uint attachment, uint texture, int level, int layer) Parameters target uint attachment uint texture uint level int layer int glFramebufferTextureLayerEXT(uint, uint, uint, int, int) public static extern void glFramebufferTextureLayerEXT(uint target, uint attachment, uint texture, int level, int layer) Parameters target uint attachment uint texture uint level int layer int glFreeObjectBufferATI(uint) public static extern void glFreeObjectBufferATI(uint buffer) Parameters buffer uint glFrontFace(uint) public static extern void glFrontFace(uint mode) Parameters mode uint glGenAsyncMarkersSGIX(int) public static extern int glGenAsyncMarkersSGIX(int range) Parameters range int Returns int glGenBuffers(int, uint*) public static extern void glGenBuffers(int n, uint* buffers) Parameters n int buffers uint* glGenBuffersARB(int, uint*) public static extern void glGenBuffersARB(int n, uint* buffers) Parameters n int buffers uint* glGenFencesAPPLE(int, uint*) public static extern void glGenFencesAPPLE(int n, uint* fences) Parameters n int fences uint* glGenFencesNV(int, uint*) public static extern void glGenFencesNV(int n, uint* fences) Parameters n int fences uint* glGenFragmentShadersATI(uint) public static extern int glGenFragmentShadersATI(uint range) Parameters range uint Returns int glGenFramebuffers(int, uint*) public static extern void glGenFramebuffers(int n, uint* framebuffers) Parameters n int framebuffers uint* glGenFramebuffersEXT(int, uint*) public static extern void glGenFramebuffersEXT(int n, uint* framebuffers) Parameters n int framebuffers uint* glGenNamesAMD(uint, uint, uint*) public static extern void glGenNamesAMD(uint identifier, uint num, uint* names) Parameters identifier uint num uint names uint* glGenOcclusionQueriesNV(int, uint*) public static extern void glGenOcclusionQueriesNV(int n, uint* ids) Parameters n int ids uint* glGenPerfMonitorsAMD(int, uint*) public static extern void glGenPerfMonitorsAMD(int n, uint* monitors) Parameters n int monitors uint* glGenProgramPipelines(int, uint*) public static extern void glGenProgramPipelines(int n, uint* pipelines) Parameters n int pipelines uint* glGenProgramsARB(int, uint*) public static extern void glGenProgramsARB(int n, uint* programs) Parameters n int programs uint* glGenProgramsNV(int, uint*) public static extern void glGenProgramsNV(int n, uint* programs) Parameters n int programs uint* glGenQueries(int, uint*) public static extern void glGenQueries(int n, uint* ids) Parameters n int ids uint* glGenQueriesARB(int, uint*) public static extern void glGenQueriesARB(int n, uint* ids) Parameters n int ids uint* glGenRenderbuffers(int, uint*) public static extern void glGenRenderbuffers(int n, uint* renderbuffers) Parameters n int renderbuffers uint* glGenRenderbuffersEXT(int, uint*) public static extern void glGenRenderbuffersEXT(int n, uint* renderbuffers) Parameters n int renderbuffers uint* glGenSamplers(int, uint*) public static extern void glGenSamplers(int count, uint* samplers) Parameters count int samplers uint* glGenSymbolsEXT(uint, uint, uint, uint) public static extern int glGenSymbolsEXT(uint datatype, uint storagetype, uint range, uint components) Parameters datatype uint storagetype uint range uint components uint Returns int glGenTextures(int, uint*) public static extern void glGenTextures(int n, uint* textures) Parameters n int textures uint* glGenTexturesEXT(int, uint*) public static extern void glGenTexturesEXT(int n, uint* textures) Parameters n int textures uint* glGenTransformFeedbacks(int, uint*) public static extern void glGenTransformFeedbacks(int n, uint* ids) Parameters n int ids uint* glGenTransformFeedbacksNV(int, uint*) public static extern void glGenTransformFeedbacksNV(int n, uint* ids) Parameters n int ids uint* glGenVertexArrays(int, uint*) public static extern void glGenVertexArrays(int n, uint* arrays) Parameters n int arrays uint* glGenVertexArraysAPPLE(int, uint*) public static extern void glGenVertexArraysAPPLE(int n, uint* arrays) Parameters n int arrays uint* glGenVertexShadersEXT(uint) public static extern int glGenVertexShadersEXT(uint range) Parameters range uint Returns int glGenerateMipmap(uint) public static extern void glGenerateMipmap(uint target) Parameters target uint glGenerateMipmapEXT(uint) public static extern void glGenerateMipmapEXT(uint target) Parameters target uint glGenerateMultiTexMipmapEXT(uint, uint) public static extern void glGenerateMultiTexMipmapEXT(uint texunit, uint target) Parameters texunit uint target uint glGenerateTextureMipmapEXT(uint, uint) public static extern void glGenerateTextureMipmapEXT(uint texture, uint target) Parameters texture uint target uint glGetActiveAttrib(uint, uint, int, int*, int*, uint*, StringBuilder) public static extern void glGetActiveAttrib(uint program, uint index, int bufSize, int* length, int* size, uint* type, StringBuilder name) Parameters program uint index uint bufSize int length int* size int* type uint* name StringBuilder glGetActiveAttribARB(uint, uint, int, int*, int*, uint*, StringBuilder) public static extern void glGetActiveAttribARB(uint programObj, uint index, int maxLength, int* length, int* size, uint* type, StringBuilder name) Parameters programObj uint index uint maxLength int length int* size int* type uint* name StringBuilder glGetActiveSubroutineName(uint, uint, uint, int, int*, StringBuilder) public static extern void glGetActiveSubroutineName(uint program, uint shadertype, uint index, int bufsize, int* length, StringBuilder name) Parameters program uint shadertype uint index uint bufsize int length int* name StringBuilder glGetActiveSubroutineUniformName(uint, uint, uint, int, int*, StringBuilder) public static extern void glGetActiveSubroutineUniformName(uint program, uint shadertype, uint index, int bufsize, int* length, StringBuilder name) Parameters program uint shadertype uint index uint bufsize int length int* name StringBuilder glGetActiveSubroutineUniformiv(uint, uint, uint, uint, int*) public static extern void glGetActiveSubroutineUniformiv(uint program, uint shadertype, uint index, uint pname, int* values) Parameters program uint shadertype uint index uint pname uint values int* glGetActiveUniform(uint, uint, int, int*, int*, uint*, StringBuilder) public static extern void glGetActiveUniform(uint program, uint index, int bufSize, int* length, int* size, uint* type, StringBuilder name) Parameters program uint index uint bufSize int length int* size int* type uint* name StringBuilder glGetActiveUniformARB(uint, uint, int, int*, int*, uint*, StringBuilder) public static extern void glGetActiveUniformARB(uint programObj, uint index, int maxLength, int* length, int* size, uint* type, StringBuilder name) Parameters programObj uint index uint maxLength int length int* size int* type uint* name StringBuilder glGetActiveUniformBlockName(uint, uint, int, int*, StringBuilder) public static extern void glGetActiveUniformBlockName(uint program, uint uniformBlockIndex, int bufSize, int* length, StringBuilder uniformBlockName) Parameters program uint uniformBlockIndex uint bufSize int length int* uniformBlockName StringBuilder glGetActiveUniformBlockiv(uint, uint, uint, int*) public static extern void glGetActiveUniformBlockiv(uint program, uint uniformBlockIndex, uint pname, int* @params) Parameters program uint uniformBlockIndex uint pname uint params int* glGetActiveUniformName(uint, uint, int, int*, StringBuilder) public static extern void glGetActiveUniformName(uint program, uint uniformIndex, int bufSize, int* length, StringBuilder uniformName) Parameters program uint uniformIndex uint bufSize int length int* uniformName StringBuilder glGetActiveUniformsiv(uint, int, uint*, uint, int*) public static extern void glGetActiveUniformsiv(uint program, int uniformCount, uint* uniformIndices, uint pname, int* @params) Parameters program uint uniformCount int uniformIndices uint* pname uint params int* glGetActiveVaryingNV(uint, uint, int, int*, int*, uint*, StringBuilder) public static extern void glGetActiveVaryingNV(uint program, uint index, int bufSize, int* length, int* size, uint* type, StringBuilder name) Parameters program uint index uint bufSize int length int* size int* type uint* name StringBuilder glGetArrayObjectfvATI(uint, uint, float*) public static extern void glGetArrayObjectfvATI(uint array, uint pname, float* @params) Parameters array uint pname uint params float* glGetArrayObjectivATI(uint, uint, int*) public static extern void glGetArrayObjectivATI(uint array, uint pname, int* @params) Parameters array uint pname uint params int* glGetAttachedObjectsARB(uint, int, int*, uint*) public static extern void glGetAttachedObjectsARB(uint containerObj, int maxCount, int* count, uint* obj) Parameters containerObj uint maxCount int count int* obj uint* glGetAttachedShaders(uint, int, int*, uint*) public static extern void glGetAttachedShaders(uint program, int maxCount, int* count, uint* obj) Parameters program uint maxCount int count int* obj uint* glGetAttribLocation(uint, string) public static extern int glGetAttribLocation(uint program, string name) Parameters program uint name string Returns int glGetAttribLocationARB(uint, string) public static extern int glGetAttribLocationARB(uint programObj, string name) Parameters programObj uint name string Returns int glGetBooleanIndexedvEXT(uint, uint, bool*) public static extern void glGetBooleanIndexedvEXT(uint target, uint index, bool* data) Parameters target uint index uint data bool* glGetBooleani_v(uint, uint, bool*) public static extern void glGetBooleani_v(uint target, uint index, bool* data) Parameters target uint index uint data bool* glGetBooleanv(uint, bool*) public static extern void glGetBooleanv(uint pname, bool* @params) Parameters pname uint params bool* glGetBufferParameteri64v(uint, uint, long*) public static extern void glGetBufferParameteri64v(uint target, uint pname, long* @params) Parameters target uint pname uint params long* glGetBufferParameteriv(uint, uint, int*) public static extern void glGetBufferParameteriv(uint target, uint pname, int* @params) Parameters target uint pname uint params int* glGetBufferParameterivARB(uint, uint, int*) public static extern void glGetBufferParameterivARB(uint target, uint pname, int* @params) Parameters target uint pname uint params int* glGetBufferParameterui64vNV(uint, uint, ulong*) public static extern void glGetBufferParameterui64vNV(uint target, uint pname, ulong* @params) Parameters target uint pname uint params ulong* glGetBufferPointerv(uint, uint, nint) public static extern void glGetBufferPointerv(uint target, uint pname, nint @params) Parameters target uint pname uint params nint glGetBufferPointervARB(uint, uint, nint) public static extern void glGetBufferPointervARB(uint target, uint pname, nint @params) Parameters target uint pname uint params nint glGetBufferSubData(uint, nint, nint, nint) public static extern void glGetBufferSubData(uint target, nint offset, nint size, nint data) Parameters target uint offset nint size nint data nint glGetBufferSubDataARB(uint, nint, nint, nint) public static extern void glGetBufferSubDataARB(uint target, nint offset, nint size, nint data) Parameters target uint offset nint size nint data nint glGetCompressedMultiTexImageEXT(uint, uint, int, nint) public static extern void glGetCompressedMultiTexImageEXT(uint texunit, uint target, int lod, nint img) Parameters texunit uint target uint lod int img nint glGetCompressedTexImage(uint, int, nint) public static extern void glGetCompressedTexImage(uint target, int level, nint img) Parameters target uint level int img nint glGetCompressedTexImageARB(uint, int, nint) public static extern void glGetCompressedTexImageARB(uint target, int level, nint img) Parameters target uint level int img nint glGetCompressedTextureImageEXT(uint, uint, int, nint) public static extern void glGetCompressedTextureImageEXT(uint texture, uint target, int lod, nint img) Parameters texture uint target uint lod int img nint glGetDebugMessageLogAMD(uint, int, uint*, uint*, uint*, int*, StringBuilder) public static extern int glGetDebugMessageLogAMD(uint count, int bufsize, uint* categories, uint* severities, uint* ids, int* lengths, StringBuilder message) Parameters count uint bufsize int categories uint* severities uint* ids uint* lengths int* message StringBuilder Returns int glGetDebugMessageLogARB(uint, int, uint*, uint*, uint*, uint*, int*, StringBuilder) public static extern int glGetDebugMessageLogARB(uint count, int bufsize, uint* sources, uint* types, uint* ids, uint* severities, int* lengths, StringBuilder messageLog) Parameters count uint bufsize int sources uint* types uint* ids uint* severities uint* lengths int* messageLog StringBuilder Returns int glGetError() public static extern uint glGetError() Returns uint glGetFenceivNV(uint, uint, int*) public static extern void glGetFenceivNV(uint fence, uint pname, int* @params) Parameters fence uint pname uint params int* glGetFinalCombinerInputParameterfvNV(uint, uint, float*) public static extern void glGetFinalCombinerInputParameterfvNV(uint variable, uint pname, float* @params) Parameters variable uint pname uint params float* glGetFinalCombinerInputParameterivNV(uint, uint, int*) public static extern void glGetFinalCombinerInputParameterivNV(uint variable, uint pname, int* @params) Parameters variable uint pname uint params int* glGetFloatIndexedvEXT(uint, uint, float*) public static extern void glGetFloatIndexedvEXT(uint target, uint index, float* data) Parameters target uint index uint data float* glGetFloati_v(uint, uint, float*) public static extern void glGetFloati_v(uint target, uint index, float* data) Parameters target uint index uint data float* glGetFloatv(uint, float*) public static extern void glGetFloatv(uint pname, float* @params) Parameters pname uint params float* glGetFogFuncSGIS(float*) public static extern void glGetFogFuncSGIS(float* points) Parameters points float* glGetFragDataIndex(uint, string) public static extern int glGetFragDataIndex(uint program, string name) Parameters program uint name string Returns int glGetFragDataLocation(uint, string) public static extern int glGetFragDataLocation(uint program, string name) Parameters program uint name string Returns int glGetFragDataLocationEXT(uint, string) public static extern int glGetFragDataLocationEXT(uint program, string name) Parameters program uint name string Returns int glGetFramebufferAttachmentParameteriv(uint, uint, uint, int*) public static extern void glGetFramebufferAttachmentParameteriv(uint target, uint attachment, uint pname, int* @params) Parameters target uint attachment uint pname uint params int* glGetFramebufferAttachmentParameterivEXT(uint, uint, uint, int*) public static extern void glGetFramebufferAttachmentParameterivEXT(uint target, uint attachment, uint pname, int* @params) Parameters target uint attachment uint pname uint params int* glGetFramebufferParameterivEXT(uint, uint, int*) public static extern void glGetFramebufferParameterivEXT(uint framebuffer, uint pname, int* @params) Parameters framebuffer uint pname uint params int* glGetGraphicsResetStatusARB() public static extern uint glGetGraphicsResetStatusARB() Returns uint glGetHandleARB(uint) public static extern int glGetHandleARB(uint pname) Parameters pname uint Returns int glGetImageTransformParameterfvHP(uint, uint, float*) public static extern void glGetImageTransformParameterfvHP(uint target, uint pname, float* @params) Parameters target uint pname uint params float* glGetImageTransformParameterivHP(uint, uint, int*) public static extern void glGetImageTransformParameterivHP(uint target, uint pname, int* @params) Parameters target uint pname uint params int* glGetInfoLogARB(uint, int, int*, StringBuilder) public static extern void glGetInfoLogARB(uint obj, int maxLength, int* length, StringBuilder infoLog) Parameters obj uint maxLength int length int* infoLog StringBuilder glGetInteger64i_v(uint, uint, long*) public static extern void glGetInteger64i_v(uint target, uint index, long* data) Parameters target uint index uint data long* glGetInteger64v(uint, long*) public static extern void glGetInteger64v(uint pname, long* @params) Parameters pname uint params long* glGetIntegerIndexedvEXT(uint, uint, int*) public static extern void glGetIntegerIndexedvEXT(uint target, uint index, int* data) Parameters target uint index uint data int* glGetIntegeri_v(uint, uint, int*) public static extern void glGetIntegeri_v(uint target, uint index, int* data) Parameters target uint index uint data int* glGetIntegerui64i_vNV(uint, uint, ulong*) public static extern void glGetIntegerui64i_vNV(uint value, uint index, ulong* result) Parameters value uint index uint result ulong* glGetIntegerui64vNV(uint, ulong*) public static extern void glGetIntegerui64vNV(uint value, ulong* result) Parameters value uint result ulong* glGetIntegerv(uint, int*) public static extern void glGetIntegerv(uint pname, int* @params) Parameters pname uint params int* glGetInvariantBooleanvEXT(uint, uint, bool*) public static extern void glGetInvariantBooleanvEXT(uint id, uint value, bool* data) Parameters id uint value uint data bool* glGetInvariantFloatvEXT(uint, uint, float*) public static extern void glGetInvariantFloatvEXT(uint id, uint value, float* data) Parameters id uint value uint data float* glGetInvariantIntegervEXT(uint, uint, int*) public static extern void glGetInvariantIntegervEXT(uint id, uint value, int* data) Parameters id uint value uint data int* glGetLocalConstantBooleanvEXT(uint, uint, bool*) public static extern void glGetLocalConstantBooleanvEXT(uint id, uint value, bool* data) Parameters id uint value uint data bool* glGetLocalConstantFloatvEXT(uint, uint, float*) public static extern void glGetLocalConstantFloatvEXT(uint id, uint value, float* data) Parameters id uint value uint data float* glGetLocalConstantIntegervEXT(uint, uint, int*) public static extern void glGetLocalConstantIntegervEXT(uint id, uint value, int* data) Parameters id uint value uint data int* glGetMultiTexEnvfvEXT(uint, uint, uint, float*) public static extern void glGetMultiTexEnvfvEXT(uint texunit, uint target, uint pname, float* @params) Parameters texunit uint target uint pname uint params float* glGetMultiTexEnvivEXT(uint, uint, uint, int*) public static extern void glGetMultiTexEnvivEXT(uint texunit, uint target, uint pname, int* @params) Parameters texunit uint target uint pname uint params int* glGetMultiTexGendvEXT(uint, uint, uint, double*) public static extern void glGetMultiTexGendvEXT(uint texunit, uint coord, uint pname, double* @params) Parameters texunit uint coord uint pname uint params double* glGetMultiTexGenfvEXT(uint, uint, uint, float*) public static extern void glGetMultiTexGenfvEXT(uint texunit, uint coord, uint pname, float* @params) Parameters texunit uint coord uint pname uint params float* glGetMultiTexGenivEXT(uint, uint, uint, int*) public static extern void glGetMultiTexGenivEXT(uint texunit, uint coord, uint pname, int* @params) Parameters texunit uint coord uint pname uint params int* glGetMultiTexImageEXT(uint, uint, int, uint, uint, nint) public static extern void glGetMultiTexImageEXT(uint texunit, uint target, int level, uint format, uint type, nint pixels) Parameters texunit uint target uint level int format uint type uint pixels nint glGetMultiTexLevelParameterfvEXT(uint, uint, int, uint, float*) public static extern void glGetMultiTexLevelParameterfvEXT(uint texunit, uint target, int level, uint pname, float* @params) Parameters texunit uint target uint level int pname uint params float* glGetMultiTexLevelParameterivEXT(uint, uint, int, uint, int*) public static extern void glGetMultiTexLevelParameterivEXT(uint texunit, uint target, int level, uint pname, int* @params) Parameters texunit uint target uint level int pname uint params int* glGetMultiTexParameterIivEXT(uint, uint, uint, int*) public static extern void glGetMultiTexParameterIivEXT(uint texunit, uint target, uint pname, int* @params) Parameters texunit uint target uint pname uint params int* glGetMultiTexParameterIuivEXT(uint, uint, uint, uint*) public static extern void glGetMultiTexParameterIuivEXT(uint texunit, uint target, uint pname, uint* @params) Parameters texunit uint target uint pname uint params uint* glGetMultiTexParameterfvEXT(uint, uint, uint, float*) public static extern void glGetMultiTexParameterfvEXT(uint texunit, uint target, uint pname, float* @params) Parameters texunit uint target uint pname uint params float* glGetMultiTexParameterivEXT(uint, uint, uint, int*) public static extern void glGetMultiTexParameterivEXT(uint texunit, uint target, uint pname, int* @params) Parameters texunit uint target uint pname uint params int* glGetMultisamplefv(uint, uint, float*) public static extern void glGetMultisamplefv(uint pname, uint index, float* val) Parameters pname uint index uint val float* glGetMultisamplefvNV(uint, uint, float*) public static extern void glGetMultisamplefvNV(uint pname, uint index, float* val) Parameters pname uint index uint val float* glGetNamedBufferParameterivEXT(uint, uint, int*) public static extern void glGetNamedBufferParameterivEXT(uint buffer, uint pname, int* @params) Parameters buffer uint pname uint params int* glGetNamedBufferParameterui64vNV(uint, uint, ulong*) public static extern void glGetNamedBufferParameterui64vNV(uint buffer, uint pname, ulong* @params) Parameters buffer uint pname uint params ulong* glGetNamedBufferPointervEXT(uint, uint, nint) public static extern void glGetNamedBufferPointervEXT(uint buffer, uint pname, nint @params) Parameters buffer uint pname uint params nint glGetNamedBufferSubDataEXT(uint, nint, nint, nint) public static extern void glGetNamedBufferSubDataEXT(uint buffer, nint offset, nint size, nint data) Parameters buffer uint offset nint size nint data nint glGetNamedFramebufferAttachmentParameterivEXT(uint, uint, uint, int*) public static extern void glGetNamedFramebufferAttachmentParameterivEXT(uint framebuffer, uint attachment, uint pname, int* @params) Parameters framebuffer uint attachment uint pname uint params int* glGetNamedProgramLocalParameterIivEXT(uint, uint, uint, int*) public static extern void glGetNamedProgramLocalParameterIivEXT(uint program, uint target, uint index, int* @params) Parameters program uint target uint index uint params int* glGetNamedProgramLocalParameterIuivEXT(uint, uint, uint, uint*) public static extern void glGetNamedProgramLocalParameterIuivEXT(uint program, uint target, uint index, uint* @params) Parameters program uint target uint index uint params uint* glGetNamedProgramLocalParameterdvEXT(uint, uint, uint, double*) public static extern void glGetNamedProgramLocalParameterdvEXT(uint program, uint target, uint index, double* @params) Parameters program uint target uint index uint params double* glGetNamedProgramLocalParameterfvEXT(uint, uint, uint, float*) public static extern void glGetNamedProgramLocalParameterfvEXT(uint program, uint target, uint index, float* @params) Parameters program uint target uint index uint params float* glGetNamedProgramStringEXT(uint, uint, uint, nint) public static extern void glGetNamedProgramStringEXT(uint program, uint target, uint pname, nint @string) Parameters program uint target uint pname uint string nint glGetNamedProgramivEXT(uint, uint, uint, int*) public static extern void glGetNamedProgramivEXT(uint program, uint target, uint pname, int* @params) Parameters program uint target uint pname uint params int* glGetNamedRenderbufferParameterivEXT(uint, uint, int*) public static extern void glGetNamedRenderbufferParameterivEXT(uint renderbuffer, uint pname, int* @params) Parameters renderbuffer uint pname uint params int* glGetNamedStringARB(int, string, int, int*, StringBuilder) public static extern void glGetNamedStringARB(int namelen, string name, int bufSize, int* stringlen, StringBuilder @string) Parameters namelen int name string bufSize int stringlen int* string StringBuilder glGetNamedStringivARB(int, string, uint, int*) public static extern void glGetNamedStringivARB(int namelen, string name, uint pname, int* @params) Parameters namelen int name string pname uint params int* glGetObjectBufferfvATI(uint, uint, float*) public static extern void glGetObjectBufferfvATI(uint buffer, uint pname, float* @params) Parameters buffer uint pname uint params float* glGetObjectBufferivATI(uint, uint, int*) public static extern void glGetObjectBufferivATI(uint buffer, uint pname, int* @params) Parameters buffer uint pname uint params int* glGetObjectParameterfvARB(uint, uint, float*) public static extern void glGetObjectParameterfvARB(uint obj, uint pname, float* @params) Parameters obj uint pname uint params float* glGetObjectParameterivAPPLE(uint, uint, uint, int*) public static extern void glGetObjectParameterivAPPLE(uint objectType, uint name, uint pname, int* @params) Parameters objectType uint name uint pname uint params int* glGetObjectParameterivARB(uint, uint, int*) public static extern void glGetObjectParameterivARB(uint obj, uint pname, int* @params) Parameters obj uint pname uint params int* glGetOcclusionQueryivNV(uint, uint, int*) public static extern void glGetOcclusionQueryivNV(uint id, uint pname, int* @params) Parameters id uint pname uint params int* glGetOcclusionQueryuivNV(uint, uint, uint*) public static extern void glGetOcclusionQueryuivNV(uint id, uint pname, uint* @params) Parameters id uint pname uint params uint* glGetPerfMonitorCounterDataAMD(uint, uint, int, uint*, int*) public static extern void glGetPerfMonitorCounterDataAMD(uint monitor, uint pname, int dataSize, uint* data, int* bytesWritten) Parameters monitor uint pname uint dataSize int data uint* bytesWritten int* glGetPerfMonitorCounterInfoAMD(uint, uint, uint, nint) public static extern void glGetPerfMonitorCounterInfoAMD(uint group, uint counter, uint pname, nint data) Parameters group uint counter uint pname uint data nint glGetPerfMonitorCounterStringAMD(uint, uint, int, int*, StringBuilder) public static extern void glGetPerfMonitorCounterStringAMD(uint group, uint counter, int bufSize, int* length, StringBuilder counterString) Parameters group uint counter uint bufSize int length int* counterString StringBuilder glGetPerfMonitorCountersAMD(uint, int*, int*, int, uint*) public static extern void glGetPerfMonitorCountersAMD(uint group, int* numCounters, int* maxActiveCounters, int counterSize, uint* counters) Parameters group uint numCounters int* maxActiveCounters int* counterSize int counters uint* glGetPerfMonitorGroupStringAMD(uint, int, int*, StringBuilder) public static extern void glGetPerfMonitorGroupStringAMD(uint group, int bufSize, int* length, StringBuilder groupString) Parameters group uint bufSize int length int* groupString StringBuilder glGetPerfMonitorGroupsAMD(int*, int, uint*) public static extern void glGetPerfMonitorGroupsAMD(int* numGroups, int groupsSize, uint* groups) Parameters numGroups int* groupsSize int groups uint* glGetPixelTexGenParameterfvSGIS(uint, float*) public static extern void glGetPixelTexGenParameterfvSGIS(uint pname, float* @params) Parameters pname uint params float* glGetPixelTexGenParameterivSGIS(uint, int*) public static extern void glGetPixelTexGenParameterivSGIS(uint pname, int* @params) Parameters pname uint params int* glGetPointerIndexedvEXT(uint, uint, nint) public static extern void glGetPointerIndexedvEXT(uint target, uint index, nint data) Parameters target uint index uint data nint glGetPointervEXT(uint, nint) public static extern void glGetPointervEXT(uint pname, nint @params) Parameters pname uint params nint glGetProgramBinary(uint, int, int*, uint*, nint) public static extern void glGetProgramBinary(uint program, int bufSize, int* length, uint* binaryFormat, nint binary) Parameters program uint bufSize int length int* binaryFormat uint* binary nint glGetProgramInfoLog(uint, int, int*, StringBuilder) public static extern void glGetProgramInfoLog(uint program, int bufSize, int* length, StringBuilder infoLog) Parameters program uint bufSize int length int* infoLog StringBuilder glGetProgramPipelineInfoLog(uint, int, int*, StringBuilder) public static extern void glGetProgramPipelineInfoLog(uint pipeline, int bufSize, int* length, StringBuilder infoLog) Parameters pipeline uint bufSize int length int* infoLog StringBuilder glGetProgramPipelineiv(uint, uint, int*) public static extern void glGetProgramPipelineiv(uint pipeline, uint pname, int* @params) Parameters pipeline uint pname uint params int* glGetProgramStageiv(uint, uint, uint, int*) public static extern void glGetProgramStageiv(uint program, uint shadertype, uint pname, int* values) Parameters program uint shadertype uint pname uint values int* glGetProgramSubroutineParameteruivNV(uint, uint, uint*) public static extern void glGetProgramSubroutineParameteruivNV(uint target, uint index, uint* param) Parameters target uint index uint param uint* glGetProgramiv(uint, uint, int*) public static extern void glGetProgramiv(uint program, uint pname, int* @params) Parameters program uint pname uint params int* glGetProgramivARB(uint, uint, int*) public static extern void glGetProgramivARB(uint target, uint pname, int* @params) Parameters target uint pname uint params int* glGetProgramivNV(uint, uint, int*) public static extern void glGetProgramivNV(uint id, uint pname, int* @params) Parameters id uint pname uint params int* glGetQueryIndexediv(uint, uint, uint, int*) public static extern void glGetQueryIndexediv(uint target, uint index, uint pname, int* @params) Parameters target uint index uint pname uint params int* glGetQueryObjecti64v(uint, uint, long*) public static extern void glGetQueryObjecti64v(uint id, uint pname, long* @params) Parameters id uint pname uint params long* glGetQueryObjecti64vEXT(uint, uint, long*) public static extern void glGetQueryObjecti64vEXT(uint id, uint pname, long* @params) Parameters id uint pname uint params long* glGetQueryObjectiv(uint, uint, int*) public static extern void glGetQueryObjectiv(uint id, uint pname, int* @params) Parameters id uint pname uint params int* glGetQueryObjectivARB(uint, uint, int*) public static extern void glGetQueryObjectivARB(uint id, uint pname, int* @params) Parameters id uint pname uint params int* glGetQueryObjectui64v(uint, uint, ulong*) public static extern void glGetQueryObjectui64v(uint id, uint pname, ulong* @params) Parameters id uint pname uint params ulong* glGetQueryObjectui64vEXT(uint, uint, ulong*) public static extern void glGetQueryObjectui64vEXT(uint id, uint pname, ulong* @params) Parameters id uint pname uint params ulong* glGetQueryObjectuiv(uint, uint, uint*) public static extern void glGetQueryObjectuiv(uint id, uint pname, uint* @params) Parameters id uint pname uint params uint* glGetQueryObjectuivARB(uint, uint, uint*) public static extern void glGetQueryObjectuivARB(uint id, uint pname, uint* @params) Parameters id uint pname uint params uint* glGetQueryiv(uint, uint, int*) public static extern void glGetQueryiv(uint target, uint pname, int* @params) Parameters target uint pname uint params int* glGetQueryivARB(uint, uint, int*) public static extern void glGetQueryivARB(uint target, uint pname, int* @params) Parameters target uint pname uint params int* glGetRenderbufferParameteriv(uint, uint, int*) public static extern void glGetRenderbufferParameteriv(uint target, uint pname, int* @params) Parameters target uint pname uint params int* glGetRenderbufferParameterivEXT(uint, uint, int*) public static extern void glGetRenderbufferParameterivEXT(uint target, uint pname, int* @params) Parameters target uint pname uint params int* glGetSamplerParameterIiv(uint, uint, int*) public static extern void glGetSamplerParameterIiv(uint sampler, uint pname, int* @params) Parameters sampler uint pname uint params int* glGetSamplerParameterIuiv(uint, uint, uint*) public static extern void glGetSamplerParameterIuiv(uint sampler, uint pname, uint* @params) Parameters sampler uint pname uint params uint* glGetSamplerParameterfv(uint, uint, float*) public static extern void glGetSamplerParameterfv(uint sampler, uint pname, float* @params) Parameters sampler uint pname uint params float* glGetSamplerParameteriv(uint, uint, int*) public static extern void glGetSamplerParameteriv(uint sampler, uint pname, int* @params) Parameters sampler uint pname uint params int* glGetShaderInfoLog(uint, int, int*, StringBuilder) public static extern void glGetShaderInfoLog(uint shader, int bufSize, int* length, StringBuilder infoLog) Parameters shader uint bufSize int length int* infoLog StringBuilder glGetShaderPrecisionFormat(uint, uint, int*, int*) public static extern void glGetShaderPrecisionFormat(uint shadertype, uint precisiontype, int* range, int* precision) Parameters shadertype uint precisiontype uint range int* precision int* glGetShaderSource(uint, int, int*, StringBuilder) public static extern void glGetShaderSource(uint shader, int bufSize, int* length, StringBuilder source) Parameters shader uint bufSize int length int* source StringBuilder glGetShaderSourceARB(uint, int, int*, StringBuilder) public static extern void glGetShaderSourceARB(uint obj, int maxLength, int* length, StringBuilder source) Parameters obj uint maxLength int length int* source StringBuilder glGetShaderiv(uint, uint, int*) public static extern void glGetShaderiv(uint shader, uint pname, int* @params) Parameters shader uint pname uint params int* glGetString(uint) public static extern nint glGetString(uint name) Parameters name uint Returns nint glGetStringi(uint, uint) public static extern nint glGetStringi(uint name, uint index) Parameters name uint index uint Returns nint glGetSubroutineIndex(uint, uint, string) public static extern int glGetSubroutineIndex(uint program, uint shadertype, string name) Parameters program uint shadertype uint name string Returns int glGetSubroutineUniformLocation(uint, uint, string) public static extern int glGetSubroutineUniformLocation(uint program, uint shadertype, string name) Parameters program uint shadertype uint name string Returns int glGetSynciv(nint, uint, int, int*, int*) public static extern void glGetSynciv(nint sync, uint pname, int bufSize, int* length, int* values) Parameters sync nint pname uint bufSize int length int* values int* glGetTexBumpParameterfvATI(uint, float*) public static extern void glGetTexBumpParameterfvATI(uint pname, float* param) Parameters pname uint param float* glGetTexBumpParameterivATI(uint, int*) public static extern void glGetTexBumpParameterivATI(uint pname, int* param) Parameters pname uint param int* glGetTexFilterFuncSGIS(uint, uint, float*) public static extern void glGetTexFilterFuncSGIS(uint target, uint filter, float* weights) Parameters target uint filter uint weights float* glGetTexImage(uint, int, uint, uint, nint) public static extern void glGetTexImage(uint target, int level, uint format, uint type, nint pixels) Parameters target uint level int format uint type uint pixels nint glGetTexLevelParameterfv(uint, int, uint, float*) public static extern void glGetTexLevelParameterfv(uint target, int level, uint pname, float* @params) Parameters target uint level int pname uint params float* glGetTexLevelParameteriv(uint, int, uint, int*) public static extern void glGetTexLevelParameteriv(uint target, int level, uint pname, int* @params) Parameters target uint level int pname uint params int* glGetTexParameterIiv(uint, uint, int*) public static extern void glGetTexParameterIiv(uint target, uint pname, int* @params) Parameters target uint pname uint params int* glGetTexParameterIivEXT(uint, uint, int*) public static extern void glGetTexParameterIivEXT(uint target, uint pname, int* @params) Parameters target uint pname uint params int* glGetTexParameterIuiv(uint, uint, uint*) public static extern void glGetTexParameterIuiv(uint target, uint pname, uint* @params) Parameters target uint pname uint params uint* glGetTexParameterIuivEXT(uint, uint, uint*) public static extern void glGetTexParameterIuivEXT(uint target, uint pname, uint* @params) Parameters target uint pname uint params uint* glGetTexParameterPointervAPPLE(uint, uint, nint) public static extern void glGetTexParameterPointervAPPLE(uint target, uint pname, nint @params) Parameters target uint pname uint params nint glGetTexParameterfv(uint, uint, float*) public static extern void glGetTexParameterfv(uint target, uint pname, float* @params) Parameters target uint pname uint params float* glGetTexParameteriv(uint, uint, int*) public static extern void glGetTexParameteriv(uint target, uint pname, int* @params) Parameters target uint pname uint params int* glGetTextureImageEXT(uint, uint, int, uint, uint, nint) public static extern void glGetTextureImageEXT(uint texture, uint target, int level, uint format, uint type, nint pixels) Parameters texture uint target uint level int format uint type uint pixels nint glGetTextureLevelParameterfvEXT(uint, uint, int, uint, float*) public static extern void glGetTextureLevelParameterfvEXT(uint texture, uint target, int level, uint pname, float* @params) Parameters texture uint target uint level int pname uint params float* glGetTextureLevelParameterivEXT(uint, uint, int, uint, int*) public static extern void glGetTextureLevelParameterivEXT(uint texture, uint target, int level, uint pname, int* @params) Parameters texture uint target uint level int pname uint params int* glGetTextureParameterIivEXT(uint, uint, uint, int*) public static extern void glGetTextureParameterIivEXT(uint texture, uint target, uint pname, int* @params) Parameters texture uint target uint pname uint params int* glGetTextureParameterIuivEXT(uint, uint, uint, uint*) public static extern void glGetTextureParameterIuivEXT(uint texture, uint target, uint pname, uint* @params) Parameters texture uint target uint pname uint params uint* glGetTextureParameterfvEXT(uint, uint, uint, float*) public static extern void glGetTextureParameterfvEXT(uint texture, uint target, uint pname, float* @params) Parameters texture uint target uint pname uint params float* glGetTextureParameterivEXT(uint, uint, uint, int*) public static extern void glGetTextureParameterivEXT(uint texture, uint target, uint pname, int* @params) Parameters texture uint target uint pname uint params int* glGetTrackMatrixivNV(uint, uint, uint, int*) public static extern void glGetTrackMatrixivNV(uint target, uint address, uint pname, int* @params) Parameters target uint address uint pname uint params int* glGetTransformFeedbackVarying(uint, uint, int, int*, int*, uint*, StringBuilder) public static extern void glGetTransformFeedbackVarying(uint program, uint index, int bufSize, int* length, int* size, uint* type, StringBuilder name) Parameters program uint index uint bufSize int length int* size int* type uint* name StringBuilder glGetTransformFeedbackVaryingEXT(uint, uint, int, int*, int*, uint*, StringBuilder) public static extern void glGetTransformFeedbackVaryingEXT(uint program, uint index, int bufSize, int* length, int* size, uint* type, StringBuilder name) Parameters program uint index uint bufSize int length int* size int* type uint* name StringBuilder glGetTransformFeedbackVaryingNV(uint, uint, int*) public static extern void glGetTransformFeedbackVaryingNV(uint program, uint index, int* location) Parameters program uint index uint location int* glGetUniformBlockIndex(uint, string) public static extern int glGetUniformBlockIndex(uint program, string uniformBlockName) Parameters program uint uniformBlockName string Returns int glGetUniformBufferSizeEXT(uint, int) public static extern int glGetUniformBufferSizeEXT(uint program, int location) Parameters program uint location int Returns int glGetUniformIndices(uint, int, string[], uint*) public static extern void glGetUniformIndices(uint program, int uniformCount, string[] uniformNames, uint* uniformIndices) Parameters program uint uniformCount int uniformNames string[] uniformIndices uint* glGetUniformLocation(uint, string) public static extern int glGetUniformLocation(uint program, string name) Parameters program uint name string Returns int glGetUniformLocationARB(uint, string) public static extern int glGetUniformLocationARB(uint programObj, string name) Parameters programObj uint name string Returns int glGetUniformOffsetEXT(uint, int) public static extern nint glGetUniformOffsetEXT(uint program, int location) Parameters program uint location int Returns nint glGetUniformSubroutineuiv(uint, int, uint*) public static extern void glGetUniformSubroutineuiv(uint shadertype, int location, uint* @params) Parameters shadertype uint location int params uint* glGetUniformdv(uint, int, double*) public static extern void glGetUniformdv(uint program, int location, double* @params) Parameters program uint location int params double* glGetUniformfv(uint, int, float*) public static extern void glGetUniformfv(uint program, int location, float* @params) Parameters program uint location int params float* glGetUniformfvARB(uint, int, float*) public static extern void glGetUniformfvARB(uint programObj, int location, float* @params) Parameters programObj uint location int params float* glGetUniformi64vNV(uint, int, long*) public static extern void glGetUniformi64vNV(uint program, int location, long* @params) Parameters program uint location int params long* glGetUniformiv(uint, int, int*) public static extern void glGetUniformiv(uint program, int location, int* @params) Parameters program uint location int params int* glGetUniformivARB(uint, int, int*) public static extern void glGetUniformivARB(uint programObj, int location, int* @params) Parameters programObj uint location int params int* glGetUniformui64vNV(uint, int, ulong*) public static extern void glGetUniformui64vNV(uint program, int location, ulong* @params) Parameters program uint location int params ulong* glGetUniformuiv(uint, int, uint*) public static extern void glGetUniformuiv(uint program, int location, uint* @params) Parameters program uint location int params uint* glGetUniformuivEXT(uint, int, uint*) public static extern void glGetUniformuivEXT(uint program, int location, uint* @params) Parameters program uint location int params uint* glGetVariantArrayObjectfvATI(uint, uint, float*) public static extern void glGetVariantArrayObjectfvATI(uint id, uint pname, float* @params) Parameters id uint pname uint params float* glGetVariantArrayObjectivATI(uint, uint, int*) public static extern void glGetVariantArrayObjectivATI(uint id, uint pname, int* @params) Parameters id uint pname uint params int* glGetVariantBooleanvEXT(uint, uint, bool*) public static extern void glGetVariantBooleanvEXT(uint id, uint value, bool* data) Parameters id uint value uint data bool* glGetVariantFloatvEXT(uint, uint, float*) public static extern void glGetVariantFloatvEXT(uint id, uint value, float* data) Parameters id uint value uint data float* glGetVariantIntegervEXT(uint, uint, int*) public static extern void glGetVariantIntegervEXT(uint id, uint value, int* data) Parameters id uint value uint data int* glGetVariantPointervEXT(uint, uint, nint) public static extern void glGetVariantPointervEXT(uint id, uint value, nint data) Parameters id uint value uint data nint glGetVaryingLocationNV(uint, string) public static extern int glGetVaryingLocationNV(uint program, string name) Parameters program uint name string Returns int glGetVertexAttribArrayObjectfvATI(uint, uint, float*) public static extern void glGetVertexAttribArrayObjectfvATI(uint index, uint pname, float* @params) Parameters index uint pname uint params float* glGetVertexAttribArrayObjectivATI(uint, uint, int*) public static extern void glGetVertexAttribArrayObjectivATI(uint index, uint pname, int* @params) Parameters index uint pname uint params int* glGetVertexAttribIiv(uint, uint, int*) public static extern void glGetVertexAttribIiv(uint index, uint pname, int* @params) Parameters index uint pname uint params int* glGetVertexAttribIivEXT(uint, uint, int*) public static extern void glGetVertexAttribIivEXT(uint index, uint pname, int* @params) Parameters index uint pname uint params int* glGetVertexAttribIuiv(uint, uint, uint*) public static extern void glGetVertexAttribIuiv(uint index, uint pname, uint* @params) Parameters index uint pname uint params uint* glGetVertexAttribIuivEXT(uint, uint, uint*) public static extern void glGetVertexAttribIuivEXT(uint index, uint pname, uint* @params) Parameters index uint pname uint params uint* glGetVertexAttribLdv(uint, uint, double*) public static extern void glGetVertexAttribLdv(uint index, uint pname, double* @params) Parameters index uint pname uint params double* glGetVertexAttribLdvEXT(uint, uint, double*) public static extern void glGetVertexAttribLdvEXT(uint index, uint pname, double* @params) Parameters index uint pname uint params double* glGetVertexAttribLi64vNV(uint, uint, long*) public static extern void glGetVertexAttribLi64vNV(uint index, uint pname, long* @params) Parameters index uint pname uint params long* glGetVertexAttribLui64vNV(uint, uint, ulong*) public static extern void glGetVertexAttribLui64vNV(uint index, uint pname, ulong* @params) Parameters index uint pname uint params ulong* glGetVertexAttribPointerv(uint, uint, nint) public static extern void glGetVertexAttribPointerv(uint index, uint pname, nint pointer) Parameters index uint pname uint pointer nint glGetVertexAttribPointervARB(uint, uint, nint) public static extern void glGetVertexAttribPointervARB(uint index, uint pname, nint pointer) Parameters index uint pname uint pointer nint glGetVertexAttribPointervNV(uint, uint, nint) public static extern void glGetVertexAttribPointervNV(uint index, uint pname, nint pointer) Parameters index uint pname uint pointer nint glGetVertexAttribdv(uint, uint, double*) public static extern void glGetVertexAttribdv(uint index, uint pname, double* @params) Parameters index uint pname uint params double* glGetVertexAttribdvARB(uint, uint, double*) public static extern void glGetVertexAttribdvARB(uint index, uint pname, double* @params) Parameters index uint pname uint params double* glGetVertexAttribdvNV(uint, uint, double*) public static extern void glGetVertexAttribdvNV(uint index, uint pname, double* @params) Parameters index uint pname uint params double* glGetVertexAttribfv(uint, uint, float*) public static extern void glGetVertexAttribfv(uint index, uint pname, float* @params) Parameters index uint pname uint params float* glGetVertexAttribfvARB(uint, uint, float*) public static extern void glGetVertexAttribfvARB(uint index, uint pname, float* @params) Parameters index uint pname uint params float* glGetVertexAttribfvNV(uint, uint, float*) public static extern void glGetVertexAttribfvNV(uint index, uint pname, float* @params) Parameters index uint pname uint params float* glGetVertexAttribiv(uint, uint, int*) public static extern void glGetVertexAttribiv(uint index, uint pname, int* @params) Parameters index uint pname uint params int* glGetVertexAttribivARB(uint, uint, int*) public static extern void glGetVertexAttribivARB(uint index, uint pname, int* @params) Parameters index uint pname uint params int* glGetVertexAttribivNV(uint, uint, int*) public static extern void glGetVertexAttribivNV(uint index, uint pname, int* @params) Parameters index uint pname uint params int* glGetVideoCaptureStreamdvNV(uint, uint, uint, double*) public static extern void glGetVideoCaptureStreamdvNV(uint video_capture_slot, uint stream, uint pname, double* @params) Parameters video_capture_slot uint stream uint pname uint params double* glGetVideoCaptureStreamfvNV(uint, uint, uint, float*) public static extern void glGetVideoCaptureStreamfvNV(uint video_capture_slot, uint stream, uint pname, float* @params) Parameters video_capture_slot uint stream uint pname uint params float* glGetVideoCaptureStreamivNV(uint, uint, uint, int*) public static extern void glGetVideoCaptureStreamivNV(uint video_capture_slot, uint stream, uint pname, int* @params) Parameters video_capture_slot uint stream uint pname uint params int* glGetVideoCaptureivNV(uint, uint, int*) public static extern void glGetVideoCaptureivNV(uint video_capture_slot, uint pname, int* @params) Parameters video_capture_slot uint pname uint params int* glGetVideoi64vNV(uint, uint, long*) public static extern void glGetVideoi64vNV(uint video_slot, uint pname, long* @params) Parameters video_slot uint pname uint params long* glGetVideoivNV(uint, uint, int*) public static extern void glGetVideoivNV(uint video_slot, uint pname, int* @params) Parameters video_slot uint pname uint params int* glGetVideoui64vNV(uint, uint, ulong*) public static extern void glGetVideoui64vNV(uint video_slot, uint pname, ulong* @params) Parameters video_slot uint pname uint params ulong* glGetVideouivNV(uint, uint, uint*) public static extern void glGetVideouivNV(uint video_slot, uint pname, uint* @params) Parameters video_slot uint pname uint params uint* glGetnColorTableARB(uint, uint, uint, int, nint) public static extern void glGetnColorTableARB(uint target, uint format, uint type, int bufSize, nint table) Parameters target uint format uint type uint bufSize int table nint glGetnCompressedTexImageARB(uint, int, int, nint) public static extern void glGetnCompressedTexImageARB(uint target, int lod, int bufSize, nint img) Parameters target uint lod int bufSize int img nint glGetnConvolutionFilterARB(uint, uint, uint, int, nint) public static extern void glGetnConvolutionFilterARB(uint target, uint format, uint type, int bufSize, nint image) Parameters target uint format uint type uint bufSize int image nint glGetnHistogramARB(uint, bool, uint, uint, int, nint) public static extern void glGetnHistogramARB(uint target, bool reset, uint format, uint type, int bufSize, nint values) Parameters target uint reset bool format uint type uint bufSize int values nint glGetnMapdvARB(uint, uint, int, double*) public static extern void glGetnMapdvARB(uint target, uint query, int bufSize, double* v) Parameters target uint query uint bufSize int v double* glGetnMapfvARB(uint, uint, int, float*) public static extern void glGetnMapfvARB(uint target, uint query, int bufSize, float* v) Parameters target uint query uint bufSize int v float* glGetnMapivARB(uint, uint, int, int*) public static extern void glGetnMapivARB(uint target, uint query, int bufSize, int* v) Parameters target uint query uint bufSize int v int* glGetnMinmaxARB(uint, bool, uint, uint, int, nint) public static extern void glGetnMinmaxARB(uint target, bool reset, uint format, uint type, int bufSize, nint values) Parameters target uint reset bool format uint type uint bufSize int values nint glGetnPixelMapfvARB(uint, int, float*) public static extern void glGetnPixelMapfvARB(uint map, int bufSize, float* values) Parameters map uint bufSize int values float* glGetnPixelMapuivARB(uint, int, uint*) public static extern void glGetnPixelMapuivARB(uint map, int bufSize, uint* values) Parameters map uint bufSize int values uint* glGetnPixelMapusvARB(uint, int, ushort*) public static extern void glGetnPixelMapusvARB(uint map, int bufSize, ushort* values) Parameters map uint bufSize int values ushort* glGetnPolygonStippleARB(int, byte*) public static extern void glGetnPolygonStippleARB(int bufSize, byte* pattern) Parameters bufSize int pattern byte* glGetnSeparableFilterARB(uint, uint, uint, int, nint, int, nint, nint) public static extern void glGetnSeparableFilterARB(uint target, uint format, uint type, int rowBufSize, nint row, int columnBufSize, nint column, nint span) Parameters target uint format uint type uint rowBufSize int row nint columnBufSize int column nint span nint glGetnTexImageARB(uint, int, uint, uint, int, nint) public static extern void glGetnTexImageARB(uint target, int level, uint format, uint type, int bufSize, nint img) Parameters target uint level int format uint type uint bufSize int img nint glGetnUniformdvARB(uint, int, int, double*) public static extern void glGetnUniformdvARB(uint program, int location, int bufSize, double* @params) Parameters program uint location int bufSize int params double* glGetnUniformfvARB(uint, int, int, float*) public static extern void glGetnUniformfvARB(uint program, int location, int bufSize, float* @params) Parameters program uint location int bufSize int params float* glGetnUniformivARB(uint, int, int, int*) public static extern void glGetnUniformivARB(uint program, int location, int bufSize, int* @params) Parameters program uint location int bufSize int params int* glGetnUniformuivARB(uint, int, int, uint*) public static extern void glGetnUniformuivARB(uint program, int location, int bufSize, uint* @params) Parameters program uint location int bufSize int params uint* glHint(uint, uint) public static extern void glHint(uint target, uint mode) Parameters target uint mode uint glHintPGI(uint, int) public static extern void glHintPGI(uint target, int mode) Parameters target uint mode int glImageTransformParameterfHP(uint, uint, float) public static extern void glImageTransformParameterfHP(uint target, uint pname, float param) Parameters target uint pname uint param float glImageTransformParameterfvHP(uint, uint, float*) public static extern void glImageTransformParameterfvHP(uint target, uint pname, float* @params) Parameters target uint pname uint params float* glImageTransformParameteriHP(uint, uint, int) public static extern void glImageTransformParameteriHP(uint target, uint pname, int param) Parameters target uint pname uint param int glImageTransformParameterivHP(uint, uint, int*) public static extern void glImageTransformParameterivHP(uint target, uint pname, int* @params) Parameters target uint pname uint params int* glImportSyncEXT(uint, nint, uint) public static extern nint glImportSyncEXT(uint external_sync_type, nint external_sync, uint flags) Parameters external_sync_type uint external_sync nint flags uint Returns nint glInsertComponentEXT(uint, uint, uint) public static extern void glInsertComponentEXT(uint res, uint src, uint num) Parameters res uint src uint num uint glIsAsyncMarkerSGIX(uint) public static extern int glIsAsyncMarkerSGIX(uint marker) Parameters marker uint Returns int glIsBuffer(uint) public static extern int glIsBuffer(uint buffer) Parameters buffer uint Returns int glIsBufferARB(uint) public static extern int glIsBufferARB(uint buffer) Parameters buffer uint Returns int glIsBufferResidentNV(uint) public static extern int glIsBufferResidentNV(uint target) Parameters target uint Returns int glIsEnabled(uint) public static extern int glIsEnabled(uint cap) Parameters cap uint Returns int glIsEnabledIndexedEXT(uint, uint) public static extern int glIsEnabledIndexedEXT(uint target, uint index) Parameters target uint index uint Returns int glIsEnabledi(uint, uint) public static extern int glIsEnabledi(uint target, uint index) Parameters target uint index uint Returns int glIsFenceAPPLE(uint) public static extern int glIsFenceAPPLE(uint fence) Parameters fence uint Returns int glIsFenceNV(uint) public static extern int glIsFenceNV(uint fence) Parameters fence uint Returns int glIsFramebuffer(uint) public static extern int glIsFramebuffer(uint framebuffer) Parameters framebuffer uint Returns int glIsFramebufferEXT(uint) public static extern int glIsFramebufferEXT(uint framebuffer) Parameters framebuffer uint Returns int glIsNameAMD(uint, uint) public static extern int glIsNameAMD(uint identifier, uint name) Parameters identifier uint name uint Returns int glIsNamedBufferResidentNV(uint) public static extern int glIsNamedBufferResidentNV(uint buffer) Parameters buffer uint Returns int glIsNamedStringARB(int, string) public static extern int glIsNamedStringARB(int namelen, string name) Parameters namelen int name string Returns int glIsObjectBufferATI(uint) public static extern int glIsObjectBufferATI(uint buffer) Parameters buffer uint Returns int glIsOcclusionQueryNV(uint) public static extern int glIsOcclusionQueryNV(uint id) Parameters id uint Returns int glIsProgram(uint) public static extern int glIsProgram(uint program) Parameters program uint Returns int glIsProgramARB(uint) public static extern int glIsProgramARB(uint program) Parameters program uint Returns int glIsProgramNV(uint) public static extern int glIsProgramNV(uint id) Parameters id uint Returns int glIsProgramPipeline(uint) public static extern int glIsProgramPipeline(uint pipeline) Parameters pipeline uint Returns int glIsQuery(uint) public static extern int glIsQuery(uint id) Parameters id uint Returns int glIsQueryARB(uint) public static extern int glIsQueryARB(uint id) Parameters id uint Returns int glIsRenderbuffer(uint) public static extern int glIsRenderbuffer(uint renderbuffer) Parameters renderbuffer uint Returns int glIsRenderbufferEXT(uint) public static extern int glIsRenderbufferEXT(uint renderbuffer) Parameters renderbuffer uint Returns int glIsSampler(uint) public static extern int glIsSampler(uint sampler) Parameters sampler uint Returns int glIsShader(uint) public static extern int glIsShader(uint shader) Parameters shader uint Returns int glIsSync(nint) public static extern int glIsSync(nint sync) Parameters sync nint Returns int glIsTexture(uint) public static extern int glIsTexture(uint texture) Parameters texture uint Returns int glIsTextureEXT(uint) public static extern int glIsTextureEXT(uint texture) Parameters texture uint Returns int glIsTransformFeedback(uint) public static extern int glIsTransformFeedback(uint id) Parameters id uint Returns int glIsTransformFeedbackNV(uint) public static extern int glIsTransformFeedbackNV(uint id) Parameters id uint Returns int glIsVariantEnabledEXT(uint, uint) public static extern int glIsVariantEnabledEXT(uint id, uint cap) Parameters id uint cap uint Returns int glIsVertexArray(uint) public static extern int glIsVertexArray(uint array) Parameters array uint Returns int glIsVertexArrayAPPLE(uint) public static extern int glIsVertexArrayAPPLE(uint array) Parameters array uint Returns int glIsVertexAttribEnabledAPPLE(uint, uint) public static extern int glIsVertexAttribEnabledAPPLE(uint index, uint pname) Parameters index uint pname uint Returns int glLineWidth(float) public static extern void glLineWidth(float width) Parameters width float glLinkProgram(uint) public static extern void glLinkProgram(uint program) Parameters program uint glLinkProgramARB(uint) public static extern void glLinkProgramARB(uint programObj) Parameters programObj uint glLockArraysEXT(int, int) public static extern void glLockArraysEXT(int first, int count) Parameters first int count int glLogicOp(uint) public static extern void glLogicOp(uint opcode) Parameters opcode uint glMakeBufferNonResidentNV(uint) public static extern void glMakeBufferNonResidentNV(uint target) Parameters target uint glMakeBufferResidentNV(uint, uint) public static extern void glMakeBufferResidentNV(uint target, uint access) Parameters target uint access uint glMakeNamedBufferNonResidentNV(uint) public static extern void glMakeNamedBufferNonResidentNV(uint buffer) Parameters buffer uint glMakeNamedBufferResidentNV(uint, uint) public static extern void glMakeNamedBufferResidentNV(uint buffer, uint access) Parameters buffer uint access uint glMapBuffer(uint, uint) public static extern nint glMapBuffer(uint target, uint access) Parameters target uint access uint Returns nint glMapBufferARB(uint, uint) public static extern nint glMapBufferARB(uint target, uint access) Parameters target uint access uint Returns nint glMapBufferRange(uint, nint, nint, uint) public static extern nint glMapBufferRange(uint target, nint offset, nint length, uint access) Parameters target uint offset nint length nint access uint Returns nint glMapControlPointsNV(uint, uint, uint, int, int, int, int, bool, nint) public static extern void glMapControlPointsNV(uint target, uint index, uint type, int ustride, int vstride, int uorder, int vorder, bool packed, nint points) Parameters target uint index uint type uint ustride int vstride int uorder int vorder int packed bool points nint glMapNamedBufferEXT(uint, uint) public static extern nint glMapNamedBufferEXT(uint buffer, uint access) Parameters buffer uint access uint Returns nint glMapNamedBufferRangeEXT(uint, nint, nint, uint) public static extern nint glMapNamedBufferRangeEXT(uint buffer, nint offset, nint length, uint access) Parameters buffer uint offset nint length nint access uint Returns nint glMapObjectBufferATI(uint) public static extern nint glMapObjectBufferATI(uint buffer) Parameters buffer uint Returns nint glMapParameterfvNV(uint, uint, float*) public static extern void glMapParameterfvNV(uint target, uint pname, float* @params) Parameters target uint pname uint params float* glMapParameterivNV(uint, uint, int*) public static extern void glMapParameterivNV(uint target, uint pname, int* @params) Parameters target uint pname uint params int* glMapVertexAttrib1dAPPLE(uint, uint, double, double, int, int, double*) public static extern void glMapVertexAttrib1dAPPLE(uint index, uint size, double u1, double u2, int stride, int order, double* points) Parameters index uint size uint u1 double u2 double stride int order int points double* glMapVertexAttrib1fAPPLE(uint, uint, float, float, int, int, float*) public static extern void glMapVertexAttrib1fAPPLE(uint index, uint size, float u1, float u2, int stride, int order, float* points) Parameters index uint size uint u1 float u2 float stride int order int points float* glMapVertexAttrib2dAPPLE(uint, uint, double, double, int, int, double, double, int, int, double*) public static extern void glMapVertexAttrib2dAPPLE(uint index, uint size, double u1, double u2, int ustride, int uorder, double v1, double v2, int vstride, int vorder, double* points) Parameters index uint size uint u1 double u2 double ustride int uorder int v1 double v2 double vstride int vorder int points double* glMapVertexAttrib2fAPPLE(uint, uint, float, float, int, int, float, float, int, int, float*) public static extern void glMapVertexAttrib2fAPPLE(uint index, uint size, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float* points) Parameters index uint size uint u1 float u2 float ustride int uorder int v1 float v2 float vstride int vorder int points float* glMatrixFrustumEXT(uint, double, double, double, double, double, double) public static extern void glMatrixFrustumEXT(uint mode, double left, double right, double bottom, double top, double zNear, double zFar) Parameters mode uint left double right double bottom double top double zNear double zFar double glMatrixLoadIdentityEXT(uint) public static extern void glMatrixLoadIdentityEXT(uint mode) Parameters mode uint glMatrixLoadTransposedEXT(uint, double*) public static extern void glMatrixLoadTransposedEXT(uint mode, double* m) Parameters mode uint m double* glMatrixLoadTransposefEXT(uint, float*) public static extern void glMatrixLoadTransposefEXT(uint mode, float* m) Parameters mode uint m float* glMatrixLoaddEXT(uint, double*) public static extern void glMatrixLoaddEXT(uint mode, double* m) Parameters mode uint m double* glMatrixLoadfEXT(uint, float*) public static extern void glMatrixLoadfEXT(uint mode, float* m) Parameters mode uint m float* glMatrixMultTransposedEXT(uint, double*) public static extern void glMatrixMultTransposedEXT(uint mode, double* m) Parameters mode uint m double* glMatrixMultTransposefEXT(uint, float*) public static extern void glMatrixMultTransposefEXT(uint mode, float* m) Parameters mode uint m float* glMatrixMultdEXT(uint, double*) public static extern void glMatrixMultdEXT(uint mode, double* m) Parameters mode uint m double* glMatrixMultfEXT(uint, float*) public static extern void glMatrixMultfEXT(uint mode, float* m) Parameters mode uint m float* glMatrixOrthoEXT(uint, double, double, double, double, double, double) public static extern void glMatrixOrthoEXT(uint mode, double left, double right, double bottom, double top, double zNear, double zFar) Parameters mode uint left double right double bottom double top double zNear double zFar double glMatrixPopEXT(uint) public static extern void glMatrixPopEXT(uint mode) Parameters mode uint glMatrixPushEXT(uint) public static extern void glMatrixPushEXT(uint mode) Parameters mode uint glMatrixRotatedEXT(uint, double, double, double, double) public static extern void glMatrixRotatedEXT(uint mode, double angle, double x, double y, double z) Parameters mode uint angle double x double y double z double glMatrixRotatefEXT(uint, float, float, float, float) public static extern void glMatrixRotatefEXT(uint mode, float angle, float x, float y, float z) Parameters mode uint angle float x float y float z float glMatrixScaledEXT(uint, double, double, double) public static extern void glMatrixScaledEXT(uint mode, double x, double y, double z) Parameters mode uint x double y double z double glMatrixScalefEXT(uint, float, float, float) public static extern void glMatrixScalefEXT(uint mode, float x, float y, float z) Parameters mode uint x float y float z float glMatrixTranslatedEXT(uint, double, double, double) public static extern void glMatrixTranslatedEXT(uint mode, double x, double y, double z) Parameters mode uint x double y double z double glMatrixTranslatefEXT(uint, float, float, float) public static extern void glMatrixTranslatefEXT(uint mode, float x, float y, float z) Parameters mode uint x float y float z float glMemoryBarrierEXT(uint) public static extern void glMemoryBarrierEXT(uint barriers) Parameters barriers uint glMinSampleShading(float) public static extern void glMinSampleShading(float value) Parameters value float glMinSampleShadingARB(float) public static extern void glMinSampleShadingARB(float value) Parameters value float glMultiDrawArrays(uint, int*, int*, int) public static extern void glMultiDrawArrays(uint mode, int* first, int* count, int primcount) Parameters mode uint first int* count int* primcount int glMultiDrawArraysEXT(uint, int*, int*, int) public static extern void glMultiDrawArraysEXT(uint mode, int* first, int* count, int primcount) Parameters mode uint first int* count int* primcount int glMultiDrawArraysIndirectAMD(uint, nint, int, int) public static extern void glMultiDrawArraysIndirectAMD(uint mode, nint indirect, int primcount, int stride) Parameters mode uint indirect nint primcount int stride int glMultiDrawElementArrayAPPLE(uint, int*, int*, int) public static extern void glMultiDrawElementArrayAPPLE(uint mode, int* first, int* count, int primcount) Parameters mode uint first int* count int* primcount int glMultiDrawElements(uint, int*, uint, nint, int) public static extern void glMultiDrawElements(uint mode, int* count, uint type, nint indices, int primcount) Parameters mode uint count int* type uint indices nint primcount int glMultiDrawElementsBaseVertex(uint, int*, uint, nint, int, int*) public static extern void glMultiDrawElementsBaseVertex(uint mode, int* count, uint type, nint indices, int primcount, int* basevertex) Parameters mode uint count int* type uint indices nint primcount int basevertex int* glMultiDrawElementsEXT(uint, int*, uint, nint, int) public static extern void glMultiDrawElementsEXT(uint mode, int* count, uint type, nint indices, int primcount) Parameters mode uint count int* type uint indices nint primcount int glMultiDrawElementsIndirectAMD(uint, uint, nint, int, int) public static extern void glMultiDrawElementsIndirectAMD(uint mode, uint type, nint indirect, int primcount, int stride) Parameters mode uint type uint indirect nint primcount int stride int glMultiDrawRangeElementArrayAPPLE(uint, uint, uint, int*, int*, int) public static extern void glMultiDrawRangeElementArrayAPPLE(uint mode, uint start, uint end, int* first, int* count, int primcount) Parameters mode uint start uint end uint first int* count int* primcount int glMultiModeDrawArraysIBM(uint*, int*, int*, int, int) public static extern void glMultiModeDrawArraysIBM(uint* mode, int* first, int* count, int primcount, int modestride) Parameters mode uint* first int* count int* primcount int modestride int glMultiModeDrawElementsIBM(uint*, int*, uint, nint, int, int) public static extern void glMultiModeDrawElementsIBM(uint* mode, int* count, uint type, nint indices, int primcount, int modestride) Parameters mode uint* count int* type uint indices nint primcount int modestride int glMultiTexBufferEXT(uint, uint, uint, uint) public static extern void glMultiTexBufferEXT(uint texunit, uint target, uint internalformat, uint buffer) Parameters texunit uint target uint internalformat uint buffer uint glMultiTexCoordPointerEXT(uint, int, uint, int, nint) public static extern void glMultiTexCoordPointerEXT(uint texunit, int size, uint type, int stride, nint pointer) Parameters texunit uint size int type uint stride int pointer nint glMultiTexEnvfEXT(uint, uint, uint, float) public static extern void glMultiTexEnvfEXT(uint texunit, uint target, uint pname, float param) Parameters texunit uint target uint pname uint param float glMultiTexEnvfvEXT(uint, uint, uint, float*) public static extern void glMultiTexEnvfvEXT(uint texunit, uint target, uint pname, float* @params) Parameters texunit uint target uint pname uint params float* glMultiTexEnviEXT(uint, uint, uint, int) public static extern void glMultiTexEnviEXT(uint texunit, uint target, uint pname, int param) Parameters texunit uint target uint pname uint param int glMultiTexEnvivEXT(uint, uint, uint, int*) public static extern void glMultiTexEnvivEXT(uint texunit, uint target, uint pname, int* @params) Parameters texunit uint target uint pname uint params int* glMultiTexGendEXT(uint, uint, uint, double) public static extern void glMultiTexGendEXT(uint texunit, uint coord, uint pname, double param) Parameters texunit uint coord uint pname uint param double glMultiTexGendvEXT(uint, uint, uint, double*) public static extern void glMultiTexGendvEXT(uint texunit, uint coord, uint pname, double* @params) Parameters texunit uint coord uint pname uint params double* glMultiTexGenfEXT(uint, uint, uint, float) public static extern void glMultiTexGenfEXT(uint texunit, uint coord, uint pname, float param) Parameters texunit uint coord uint pname uint param float glMultiTexGenfvEXT(uint, uint, uint, float*) public static extern void glMultiTexGenfvEXT(uint texunit, uint coord, uint pname, float* @params) Parameters texunit uint coord uint pname uint params float* glMultiTexGeniEXT(uint, uint, uint, int) public static extern void glMultiTexGeniEXT(uint texunit, uint coord, uint pname, int param) Parameters texunit uint coord uint pname uint param int glMultiTexGenivEXT(uint, uint, uint, int*) public static extern void glMultiTexGenivEXT(uint texunit, uint coord, uint pname, int* @params) Parameters texunit uint coord uint pname uint params int* glMultiTexImage1DEXT(uint, uint, int, uint, int, int, uint, uint, nint) public static extern void glMultiTexImage1DEXT(uint texunit, uint target, int level, uint internalformat, int width, int border, uint format, uint type, nint pixels) Parameters texunit uint target uint level int internalformat uint width int border int format uint type uint pixels nint glMultiTexImage2DEXT(uint, uint, int, uint, int, int, int, uint, uint, nint) public static extern void glMultiTexImage2DEXT(uint texunit, uint target, int level, uint internalformat, int width, int height, int border, uint format, uint type, nint pixels) Parameters texunit uint target uint level int internalformat uint width int height int border int format uint type uint pixels nint glMultiTexImage3DEXT(uint, uint, int, uint, int, int, int, int, uint, uint, nint) public static extern void glMultiTexImage3DEXT(uint texunit, uint target, int level, uint internalformat, int width, int height, int depth, int border, uint format, uint type, nint pixels) Parameters texunit uint target uint level int internalformat uint width int height int depth int border int format uint type uint pixels nint glMultiTexParameterIivEXT(uint, uint, uint, int*) public static extern void glMultiTexParameterIivEXT(uint texunit, uint target, uint pname, int* @params) Parameters texunit uint target uint pname uint params int* glMultiTexParameterIuivEXT(uint, uint, uint, uint*) public static extern void glMultiTexParameterIuivEXT(uint texunit, uint target, uint pname, uint* @params) Parameters texunit uint target uint pname uint params uint* glMultiTexParameterfEXT(uint, uint, uint, float) public static extern void glMultiTexParameterfEXT(uint texunit, uint target, uint pname, float param) Parameters texunit uint target uint pname uint param float glMultiTexParameterfvEXT(uint, uint, uint, float*) public static extern void glMultiTexParameterfvEXT(uint texunit, uint target, uint pname, float* @params) Parameters texunit uint target uint pname uint params float* glMultiTexParameteriEXT(uint, uint, uint, int) public static extern void glMultiTexParameteriEXT(uint texunit, uint target, uint pname, int param) Parameters texunit uint target uint pname uint param int glMultiTexParameterivEXT(uint, uint, uint, int*) public static extern void glMultiTexParameterivEXT(uint texunit, uint target, uint pname, int* @params) Parameters texunit uint target uint pname uint params int* glMultiTexRenderbufferEXT(uint, uint, uint) public static extern void glMultiTexRenderbufferEXT(uint texunit, uint target, uint renderbuffer) Parameters texunit uint target uint renderbuffer uint glMultiTexSubImage1DEXT(uint, uint, int, int, int, uint, uint, nint) public static extern void glMultiTexSubImage1DEXT(uint texunit, uint target, int level, int xoffset, int width, uint format, uint type, nint pixels) Parameters texunit uint target uint level int xoffset int width int format uint type uint pixels nint glMultiTexSubImage2DEXT(uint, uint, int, int, int, int, int, uint, uint, nint) public static extern void glMultiTexSubImage2DEXT(uint texunit, uint target, int level, int xoffset, int yoffset, int width, int height, uint format, uint type, nint pixels) Parameters texunit uint target uint level int xoffset int yoffset int width int height int format uint type uint pixels nint glMultiTexSubImage3DEXT(uint, uint, int, int, int, int, int, int, int, uint, uint, nint) public static extern void glMultiTexSubImage3DEXT(uint texunit, uint target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, uint type, nint pixels) Parameters texunit uint target uint level int xoffset int yoffset int zoffset int width int height int depth int format uint type uint pixels nint glNamedBufferDataEXT(uint, nint, nint, uint) public static extern void glNamedBufferDataEXT(uint buffer, nint size, nint data, uint usage) Parameters buffer uint size nint data nint usage uint glNamedBufferSubDataEXT(uint, nint, nint, nint) public static extern void glNamedBufferSubDataEXT(uint buffer, nint offset, nint size, nint data) Parameters buffer uint offset nint size nint data nint glNamedCopyBufferSubDataEXT(uint, uint, nint, nint, nint) public static extern void glNamedCopyBufferSubDataEXT(uint readBuffer, uint writeBuffer, nint readOffset, nint writeOffset, nint size) Parameters readBuffer uint writeBuffer uint readOffset nint writeOffset nint size nint glNamedFramebufferRenderbufferEXT(uint, uint, uint, uint) public static extern void glNamedFramebufferRenderbufferEXT(uint framebuffer, uint attachment, uint renderbuffertarget, uint renderbuffer) Parameters framebuffer uint attachment uint renderbuffertarget uint renderbuffer uint glNamedFramebufferTexture1DEXT(uint, uint, uint, uint, int) public static extern void glNamedFramebufferTexture1DEXT(uint framebuffer, uint attachment, uint textarget, uint texture, int level) Parameters framebuffer uint attachment uint textarget uint texture uint level int glNamedFramebufferTexture2DEXT(uint, uint, uint, uint, int) public static extern void glNamedFramebufferTexture2DEXT(uint framebuffer, uint attachment, uint textarget, uint texture, int level) Parameters framebuffer uint attachment uint textarget uint texture uint level int glNamedFramebufferTexture3DEXT(uint, uint, uint, uint, int, int) public static extern void glNamedFramebufferTexture3DEXT(uint framebuffer, uint attachment, uint textarget, uint texture, int level, int zoffset) Parameters framebuffer uint attachment uint textarget uint texture uint level int zoffset int glNamedFramebufferTextureEXT(uint, uint, uint, int) public static extern void glNamedFramebufferTextureEXT(uint framebuffer, uint attachment, uint texture, int level) Parameters framebuffer uint attachment uint texture uint level int glNamedFramebufferTextureFaceEXT(uint, uint, uint, int, uint) public static extern void glNamedFramebufferTextureFaceEXT(uint framebuffer, uint attachment, uint texture, int level, uint face) Parameters framebuffer uint attachment uint texture uint level int face uint glNamedFramebufferTextureLayerEXT(uint, uint, uint, int, int) public static extern void glNamedFramebufferTextureLayerEXT(uint framebuffer, uint attachment, uint texture, int level, int layer) Parameters framebuffer uint attachment uint texture uint level int layer int glNamedProgramLocalParameter4dEXT(uint, uint, uint, double, double, double, double) public static extern void glNamedProgramLocalParameter4dEXT(uint program, uint target, uint index, double x, double y, double z, double w) Parameters program uint target uint index uint x double y double z double w double glNamedProgramLocalParameter4dvEXT(uint, uint, uint, double*) public static extern void glNamedProgramLocalParameter4dvEXT(uint program, uint target, uint index, double* @params) Parameters program uint target uint index uint params double* glNamedProgramLocalParameter4fEXT(uint, uint, uint, float, float, float, float) public static extern void glNamedProgramLocalParameter4fEXT(uint program, uint target, uint index, float x, float y, float z, float w) Parameters program uint target uint index uint x float y float z float w float glNamedProgramLocalParameter4fvEXT(uint, uint, uint, float*) public static extern void glNamedProgramLocalParameter4fvEXT(uint program, uint target, uint index, float* @params) Parameters program uint target uint index uint params float* glNamedProgramLocalParameterI4iEXT(uint, uint, uint, int, int, int, int) public static extern void glNamedProgramLocalParameterI4iEXT(uint program, uint target, uint index, int x, int y, int z, int w) Parameters program uint target uint index uint x int y int z int w int glNamedProgramLocalParameterI4ivEXT(uint, uint, uint, int*) public static extern void glNamedProgramLocalParameterI4ivEXT(uint program, uint target, uint index, int* @params) Parameters program uint target uint index uint params int* glNamedProgramLocalParameterI4uiEXT(uint, uint, uint, uint, uint, uint, uint) public static extern void glNamedProgramLocalParameterI4uiEXT(uint program, uint target, uint index, uint x, uint y, uint z, uint w) Parameters program uint target uint index uint x uint y uint z uint w uint glNamedProgramLocalParameterI4uivEXT(uint, uint, uint, uint*) public static extern void glNamedProgramLocalParameterI4uivEXT(uint program, uint target, uint index, uint* @params) Parameters program uint target uint index uint params uint* glNamedProgramLocalParameters4fvEXT(uint, uint, uint, int, float*) public static extern void glNamedProgramLocalParameters4fvEXT(uint program, uint target, uint index, int count, float* @params) Parameters program uint target uint index uint count int params float* glNamedProgramLocalParametersI4ivEXT(uint, uint, uint, int, int*) public static extern void glNamedProgramLocalParametersI4ivEXT(uint program, uint target, uint index, int count, int* @params) Parameters program uint target uint index uint count int params int* glNamedProgramLocalParametersI4uivEXT(uint, uint, uint, int, uint*) public static extern void glNamedProgramLocalParametersI4uivEXT(uint program, uint target, uint index, int count, uint* @params) Parameters program uint target uint index uint count int params uint* glNamedProgramStringEXT(uint, uint, uint, int, nint) public static extern void glNamedProgramStringEXT(uint program, uint target, uint format, int len, nint @string) Parameters program uint target uint format uint len int string nint glNamedRenderbufferStorageEXT(uint, uint, int, int) public static extern void glNamedRenderbufferStorageEXT(uint renderbuffer, uint internalformat, int width, int height) Parameters renderbuffer uint internalformat uint width int height int glNamedRenderbufferStorageMultisampleCoverageEXT(uint, int, int, uint, int, int) public static extern void glNamedRenderbufferStorageMultisampleCoverageEXT(uint renderbuffer, int coverageSamples, int colorSamples, uint internalformat, int width, int height) Parameters renderbuffer uint coverageSamples int colorSamples int internalformat uint width int height int glNamedRenderbufferStorageMultisampleEXT(uint, int, uint, int, int) public static extern void glNamedRenderbufferStorageMultisampleEXT(uint renderbuffer, int samples, uint internalformat, int width, int height) Parameters renderbuffer uint samples int internalformat uint width int height int glNamedStringARB(uint, int, string, int, string) public static extern void glNamedStringARB(uint type, int namelen, string name, int stringlen, string @string) Parameters type uint namelen int name string stringlen int string string glNewObjectBufferATI(int, nint, uint) public static extern int glNewObjectBufferATI(int size, nint pointer, uint usage) Parameters size int pointer nint usage uint Returns int glNormalFormatNV(uint, int) public static extern void glNormalFormatNV(uint type, int stride) Parameters type uint stride int glNormalPointerListIBM(uint, int, nint, int) public static extern void glNormalPointerListIBM(uint type, int stride, nint pointer, int ptrstride) Parameters type uint stride int pointer nint ptrstride int glNormalPointervINTEL(uint, nint) public static extern void glNormalPointervINTEL(uint type, nint pointer) Parameters type uint pointer nint glNormalStream3bATI(uint, sbyte, sbyte, sbyte) public static extern void glNormalStream3bATI(uint stream, sbyte nx, sbyte ny, sbyte nz) Parameters stream uint nx sbyte ny sbyte nz sbyte glNormalStream3bvATI(uint, sbyte*) public static extern void glNormalStream3bvATI(uint stream, sbyte* coords) Parameters stream uint coords sbyte* glNormalStream3dATI(uint, double, double, double) public static extern void glNormalStream3dATI(uint stream, double nx, double ny, double nz) Parameters stream uint nx double ny double nz double glNormalStream3dvATI(uint, double*) public static extern void glNormalStream3dvATI(uint stream, double* coords) Parameters stream uint coords double* glNormalStream3fATI(uint, float, float, float) public static extern void glNormalStream3fATI(uint stream, float nx, float ny, float nz) Parameters stream uint nx float ny float nz float glNormalStream3fvATI(uint, float*) public static extern void glNormalStream3fvATI(uint stream, float* coords) Parameters stream uint coords float* glNormalStream3iATI(uint, int, int, int) public static extern void glNormalStream3iATI(uint stream, int nx, int ny, int nz) Parameters stream uint nx int ny int nz int glNormalStream3ivATI(uint, int*) public static extern void glNormalStream3ivATI(uint stream, int* coords) Parameters stream uint coords int* glNormalStream3sATI(uint, short, short, short) public static extern void glNormalStream3sATI(uint stream, short nx, short ny, short nz) Parameters stream uint nx short ny short nz short glNormalStream3svATI(uint, short*) public static extern void glNormalStream3svATI(uint stream, short* coords) Parameters stream uint coords short* glObjectPurgeableAPPLE(uint, uint, uint) public static extern uint glObjectPurgeableAPPLE(uint objectType, uint name, uint option) Parameters objectType uint name uint option uint Returns uint glObjectUnpurgeableAPPLE(uint, uint, uint) public static extern uint glObjectUnpurgeableAPPLE(uint objectType, uint name, uint option) Parameters objectType uint name uint option uint Returns uint glPassTexCoordATI(uint, uint, uint) public static extern void glPassTexCoordATI(uint dst, uint coord, uint swizzle) Parameters dst uint coord uint swizzle uint glPatchParameterfv(uint, float*) public static extern void glPatchParameterfv(uint pname, float* values) Parameters pname uint values float* glPatchParameteri(uint, int) public static extern void glPatchParameteri(uint pname, int value) Parameters pname uint value int glPauseTransformFeedback() public static extern void glPauseTransformFeedback() glPauseTransformFeedbackNV() public static extern void glPauseTransformFeedbackNV() glPixelDataRangeNV(uint, int, nint) public static extern void glPixelDataRangeNV(uint target, int length, nint pointer) Parameters target uint length int pointer nint glPixelStoref(uint, float) public static extern void glPixelStoref(uint pname, float param) Parameters pname uint param float glPixelStorei(uint, int) public static extern void glPixelStorei(uint pname, int param) Parameters pname uint param int glPixelTransformParameterfEXT(uint, uint, float) public static extern void glPixelTransformParameterfEXT(uint target, uint pname, float param) Parameters target uint pname uint param float glPixelTransformParameterfvEXT(uint, uint, float*) public static extern void glPixelTransformParameterfvEXT(uint target, uint pname, float* @params) Parameters target uint pname uint params float* glPixelTransformParameteriEXT(uint, uint, int) public static extern void glPixelTransformParameteriEXT(uint target, uint pname, int param) Parameters target uint pname uint param int glPixelTransformParameterivEXT(uint, uint, int*) public static extern void glPixelTransformParameterivEXT(uint target, uint pname, int* @params) Parameters target uint pname uint params int* glPointParameterf(uint, float) public static extern void glPointParameterf(uint pname, float param) Parameters pname uint param float glPointParameterfARB(uint, float) public static extern void glPointParameterfARB(uint pname, float param) Parameters pname uint param float glPointParameterfEXT(uint, float) public static extern void glPointParameterfEXT(uint pname, float param) Parameters pname uint param float glPointParameterfSGIS(uint, float) public static extern void glPointParameterfSGIS(uint pname, float param) Parameters pname uint param float glPointParameterfv(uint, float*) public static extern void glPointParameterfv(uint pname, float* @params) Parameters pname uint params float* glPointParameterfvARB(uint, float*) public static extern void glPointParameterfvARB(uint pname, float* @params) Parameters pname uint params float* glPointParameterfvEXT(uint, float*) public static extern void glPointParameterfvEXT(uint pname, float* @params) Parameters pname uint params float* glPointParameterfvSGIS(uint, float*) public static extern void glPointParameterfvSGIS(uint pname, float* @params) Parameters pname uint params float* glPointParameteri(uint, int) public static extern void glPointParameteri(uint pname, int param) Parameters pname uint param int glPointParameteriNV(uint, int) public static extern void glPointParameteriNV(uint pname, int param) Parameters pname uint param int glPointParameteriv(uint, int*) public static extern void glPointParameteriv(uint pname, int* @params) Parameters pname uint params int* glPointParameterivNV(uint, int*) public static extern void glPointParameterivNV(uint pname, int* @params) Parameters pname uint params int* glPointSize(float) public static extern void glPointSize(float size) Parameters size float glPollAsyncSGIX(uint*) public static extern int glPollAsyncSGIX(uint* markerp) Parameters markerp uint* Returns int glPolygonMode(uint, uint) public static extern void glPolygonMode(uint face, uint mode) Parameters face uint mode uint glPolygonOffset(float, float) public static extern void glPolygonOffset(float factor, float units) Parameters factor float units float glPolygonOffsetEXT(float, float) public static extern void glPolygonOffsetEXT(float factor, float bias) Parameters factor float bias float glPresentFrameDualFillNV(uint, ulong, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint) public static extern void glPresentFrameDualFillNV(uint video_slot, ulong minPresentTime, uint beginPresentTimeId, uint presentDurationId, uint type, uint target0, uint fill0, uint target1, uint fill1, uint target2, uint fill2, uint target3, uint fill3) Parameters video_slot uint minPresentTime ulong beginPresentTimeId uint presentDurationId uint type uint target0 uint fill0 uint target1 uint fill1 uint target2 uint fill2 uint target3 uint fill3 uint glPresentFrameKeyedNV(uint, ulong, uint, uint, uint, uint, uint, uint, uint, uint, uint) public static extern void glPresentFrameKeyedNV(uint video_slot, ulong minPresentTime, uint beginPresentTimeId, uint presentDurationId, uint type, uint target0, uint fill0, uint key0, uint target1, uint fill1, uint key1) Parameters video_slot uint minPresentTime ulong beginPresentTimeId uint presentDurationId uint type uint target0 uint fill0 uint key0 uint target1 uint fill1 uint key1 uint glPrimitiveRestartIndex(uint) public static extern void glPrimitiveRestartIndex(uint index) Parameters index uint glPrimitiveRestartIndexNV(uint) public static extern void glPrimitiveRestartIndexNV(uint index) Parameters index uint glPrimitiveRestartNV() public static extern void glPrimitiveRestartNV() glPrioritizeTexturesEXT(int, uint*, float*) public static extern void glPrioritizeTexturesEXT(int n, uint* textures, float* priorities) Parameters n int textures uint* priorities float* glProgramBinary(uint, uint, nint, int) public static extern void glProgramBinary(uint program, uint binaryFormat, nint binary, int length) Parameters program uint binaryFormat uint binary nint length int glProgramBufferParametersIivNV(uint, uint, uint, int, int*) public static extern void glProgramBufferParametersIivNV(uint target, uint buffer, uint index, int count, int* @params) Parameters target uint buffer uint index uint count int params int* glProgramBufferParametersIuivNV(uint, uint, uint, int, uint*) public static extern void glProgramBufferParametersIuivNV(uint target, uint buffer, uint index, int count, uint* @params) Parameters target uint buffer uint index uint count int params uint* glProgramBufferParametersfvNV(uint, uint, uint, int, float*) public static extern void glProgramBufferParametersfvNV(uint target, uint buffer, uint index, int count, float* @params) Parameters target uint buffer uint index uint count int params float* glProgramParameteri(uint, uint, int) public static extern void glProgramParameteri(uint program, uint pname, int value) Parameters program uint pname uint value int glProgramParameteriARB(uint, uint, int) public static extern void glProgramParameteriARB(uint program, uint pname, int value) Parameters program uint pname uint value int glProgramParameteriEXT(uint, uint, int) public static extern void glProgramParameteriEXT(uint program, uint pname, int value) Parameters program uint pname uint value int glProgramParameters4dvNV(uint, uint, int, double*) public static extern void glProgramParameters4dvNV(uint target, uint index, int count, double* v) Parameters target uint index uint count int v double* glProgramParameters4fvNV(uint, uint, int, float*) public static extern void glProgramParameters4fvNV(uint target, uint index, int count, float* v) Parameters target uint index uint count int v float* glProgramSubroutineParametersuivNV(uint, int, uint*) public static extern void glProgramSubroutineParametersuivNV(uint target, int count, uint* @params) Parameters target uint count int params uint* glProgramUniform1d(uint, int, double) public static extern void glProgramUniform1d(uint program, int location, double v0) Parameters program uint location int v0 double glProgramUniform1dEXT(uint, int, double) public static extern void glProgramUniform1dEXT(uint program, int location, double x) Parameters program uint location int x double glProgramUniform1dv(uint, int, int, double*) public static extern void glProgramUniform1dv(uint program, int location, int count, double* value) Parameters program uint location int count int value double* glProgramUniform1dvEXT(uint, int, int, double*) public static extern void glProgramUniform1dvEXT(uint program, int location, int count, double* value) Parameters program uint location int count int value double* glProgramUniform1f(uint, int, float) public static extern void glProgramUniform1f(uint program, int location, float v0) Parameters program uint location int v0 float glProgramUniform1fEXT(uint, int, float) public static extern void glProgramUniform1fEXT(uint program, int location, float v0) Parameters program uint location int v0 float glProgramUniform1fv(uint, int, int, float*) public static extern void glProgramUniform1fv(uint program, int location, int count, float* value) Parameters program uint location int count int value float* glProgramUniform1fvEXT(uint, int, int, float*) public static extern void glProgramUniform1fvEXT(uint program, int location, int count, float* value) Parameters program uint location int count int value float* glProgramUniform1i(uint, int, int) public static extern void glProgramUniform1i(uint program, int location, int v0) Parameters program uint location int v0 int glProgramUniform1i64NV(uint, int, long) public static extern void glProgramUniform1i64NV(uint program, int location, long x) Parameters program uint location int x long glProgramUniform1i64vNV(uint, int, int, long*) public static extern void glProgramUniform1i64vNV(uint program, int location, int count, long* value) Parameters program uint location int count int value long* glProgramUniform1iEXT(uint, int, int) public static extern void glProgramUniform1iEXT(uint program, int location, int v0) Parameters program uint location int v0 int glProgramUniform1iv(uint, int, int, int*) public static extern void glProgramUniform1iv(uint program, int location, int count, int* value) Parameters program uint location int count int value int* glProgramUniform1ivEXT(uint, int, int, int*) public static extern void glProgramUniform1ivEXT(uint program, int location, int count, int* value) Parameters program uint location int count int value int* glProgramUniform1ui(uint, int, uint) public static extern void glProgramUniform1ui(uint program, int location, uint v0) Parameters program uint location int v0 uint glProgramUniform1ui64NV(uint, int, ulong) public static extern void glProgramUniform1ui64NV(uint program, int location, ulong x) Parameters program uint location int x ulong glProgramUniform1ui64vNV(uint, int, int, ulong*) public static extern void glProgramUniform1ui64vNV(uint program, int location, int count, ulong* value) Parameters program uint location int count int value ulong* glProgramUniform1uiEXT(uint, int, uint) public static extern void glProgramUniform1uiEXT(uint program, int location, uint v0) Parameters program uint location int v0 uint glProgramUniform1uiv(uint, int, int, uint*) public static extern void glProgramUniform1uiv(uint program, int location, int count, uint* value) Parameters program uint location int count int value uint* glProgramUniform1uivEXT(uint, int, int, uint*) public static extern void glProgramUniform1uivEXT(uint program, int location, int count, uint* value) Parameters program uint location int count int value uint* glProgramUniform2d(uint, int, double, double) public static extern void glProgramUniform2d(uint program, int location, double v0, double v1) Parameters program uint location int v0 double v1 double glProgramUniform2dEXT(uint, int, double, double) public static extern void glProgramUniform2dEXT(uint program, int location, double x, double y) Parameters program uint location int x double y double glProgramUniform2dv(uint, int, int, double*) public static extern void glProgramUniform2dv(uint program, int location, int count, double* value) Parameters program uint location int count int value double* glProgramUniform2dvEXT(uint, int, int, double*) public static extern void glProgramUniform2dvEXT(uint program, int location, int count, double* value) Parameters program uint location int count int value double* glProgramUniform2f(uint, int, float, float) public static extern void glProgramUniform2f(uint program, int location, float v0, float v1) Parameters program uint location int v0 float v1 float glProgramUniform2fEXT(uint, int, float, float) public static extern void glProgramUniform2fEXT(uint program, int location, float v0, float v1) Parameters program uint location int v0 float v1 float glProgramUniform2fv(uint, int, int, float*) public static extern void glProgramUniform2fv(uint program, int location, int count, float* value) Parameters program uint location int count int value float* glProgramUniform2fvEXT(uint, int, int, float*) public static extern void glProgramUniform2fvEXT(uint program, int location, int count, float* value) Parameters program uint location int count int value float* glProgramUniform2i(uint, int, int, int) public static extern void glProgramUniform2i(uint program, int location, int v0, int v1) Parameters program uint location int v0 int v1 int glProgramUniform2i64NV(uint, int, long, long) public static extern void glProgramUniform2i64NV(uint program, int location, long x, long y) Parameters program uint location int x long y long glProgramUniform2i64vNV(uint, int, int, long*) public static extern void glProgramUniform2i64vNV(uint program, int location, int count, long* value) Parameters program uint location int count int value long* glProgramUniform2iEXT(uint, int, int, int) public static extern void glProgramUniform2iEXT(uint program, int location, int v0, int v1) Parameters program uint location int v0 int v1 int glProgramUniform2iv(uint, int, int, int*) public static extern void glProgramUniform2iv(uint program, int location, int count, int* value) Parameters program uint location int count int value int* glProgramUniform2ivEXT(uint, int, int, int*) public static extern void glProgramUniform2ivEXT(uint program, int location, int count, int* value) Parameters program uint location int count int value int* glProgramUniform2ui(uint, int, uint, uint) public static extern void glProgramUniform2ui(uint program, int location, uint v0, uint v1) Parameters program uint location int v0 uint v1 uint glProgramUniform2ui64NV(uint, int, ulong, ulong) public static extern void glProgramUniform2ui64NV(uint program, int location, ulong x, ulong y) Parameters program uint location int x ulong y ulong glProgramUniform2ui64vNV(uint, int, int, ulong*) public static extern void glProgramUniform2ui64vNV(uint program, int location, int count, ulong* value) Parameters program uint location int count int value ulong* glProgramUniform2uiEXT(uint, int, uint, uint) public static extern void glProgramUniform2uiEXT(uint program, int location, uint v0, uint v1) Parameters program uint location int v0 uint v1 uint glProgramUniform2uiv(uint, int, int, uint*) public static extern void glProgramUniform2uiv(uint program, int location, int count, uint* value) Parameters program uint location int count int value uint* glProgramUniform2uivEXT(uint, int, int, uint*) public static extern void glProgramUniform2uivEXT(uint program, int location, int count, uint* value) Parameters program uint location int count int value uint* glProgramUniform3d(uint, int, double, double, double) public static extern void glProgramUniform3d(uint program, int location, double v0, double v1, double v2) Parameters program uint location int v0 double v1 double v2 double glProgramUniform3dEXT(uint, int, double, double, double) public static extern void glProgramUniform3dEXT(uint program, int location, double x, double y, double z) Parameters program uint location int x double y double z double glProgramUniform3dv(uint, int, int, double*) public static extern void glProgramUniform3dv(uint program, int location, int count, double* value) Parameters program uint location int count int value double* glProgramUniform3dvEXT(uint, int, int, double*) public static extern void glProgramUniform3dvEXT(uint program, int location, int count, double* value) Parameters program uint location int count int value double* glProgramUniform3f(uint, int, float, float, float) public static extern void glProgramUniform3f(uint program, int location, float v0, float v1, float v2) Parameters program uint location int v0 float v1 float v2 float glProgramUniform3fEXT(uint, int, float, float, float) public static extern void glProgramUniform3fEXT(uint program, int location, float v0, float v1, float v2) Parameters program uint location int v0 float v1 float v2 float glProgramUniform3fv(uint, int, int, float*) public static extern void glProgramUniform3fv(uint program, int location, int count, float* value) Parameters program uint location int count int value float* glProgramUniform3fvEXT(uint, int, int, float*) public static extern void glProgramUniform3fvEXT(uint program, int location, int count, float* value) Parameters program uint location int count int value float* glProgramUniform3i(uint, int, int, int, int) public static extern void glProgramUniform3i(uint program, int location, int v0, int v1, int v2) Parameters program uint location int v0 int v1 int v2 int glProgramUniform3i64NV(uint, int, long, long, long) public static extern void glProgramUniform3i64NV(uint program, int location, long x, long y, long z) Parameters program uint location int x long y long z long glProgramUniform3i64vNV(uint, int, int, long*) public static extern void glProgramUniform3i64vNV(uint program, int location, int count, long* value) Parameters program uint location int count int value long* glProgramUniform3iEXT(uint, int, int, int, int) public static extern void glProgramUniform3iEXT(uint program, int location, int v0, int v1, int v2) Parameters program uint location int v0 int v1 int v2 int glProgramUniform3iv(uint, int, int, int*) public static extern void glProgramUniform3iv(uint program, int location, int count, int* value) Parameters program uint location int count int value int* glProgramUniform3ivEXT(uint, int, int, int*) public static extern void glProgramUniform3ivEXT(uint program, int location, int count, int* value) Parameters program uint location int count int value int* glProgramUniform3ui(uint, int, uint, uint, uint) public static extern void glProgramUniform3ui(uint program, int location, uint v0, uint v1, uint v2) Parameters program uint location int v0 uint v1 uint v2 uint glProgramUniform3ui64NV(uint, int, ulong, ulong, ulong) public static extern void glProgramUniform3ui64NV(uint program, int location, ulong x, ulong y, ulong z) Parameters program uint location int x ulong y ulong z ulong glProgramUniform3ui64vNV(uint, int, int, ulong*) public static extern void glProgramUniform3ui64vNV(uint program, int location, int count, ulong* value) Parameters program uint location int count int value ulong* glProgramUniform3uiEXT(uint, int, uint, uint, uint) public static extern void glProgramUniform3uiEXT(uint program, int location, uint v0, uint v1, uint v2) Parameters program uint location int v0 uint v1 uint v2 uint glProgramUniform3uiv(uint, int, int, uint*) public static extern void glProgramUniform3uiv(uint program, int location, int count, uint* value) Parameters program uint location int count int value uint* glProgramUniform3uivEXT(uint, int, int, uint*) public static extern void glProgramUniform3uivEXT(uint program, int location, int count, uint* value) Parameters program uint location int count int value uint* glProgramUniform4d(uint, int, double, double, double, double) public static extern void glProgramUniform4d(uint program, int location, double v0, double v1, double v2, double v3) Parameters program uint location int v0 double v1 double v2 double v3 double glProgramUniform4dEXT(uint, int, double, double, double, double) public static extern void glProgramUniform4dEXT(uint program, int location, double x, double y, double z, double w) Parameters program uint location int x double y double z double w double glProgramUniform4dv(uint, int, int, double*) public static extern void glProgramUniform4dv(uint program, int location, int count, double* value) Parameters program uint location int count int value double* glProgramUniform4dvEXT(uint, int, int, double*) public static extern void glProgramUniform4dvEXT(uint program, int location, int count, double* value) Parameters program uint location int count int value double* glProgramUniform4f(uint, int, float, float, float, float) public static extern void glProgramUniform4f(uint program, int location, float v0, float v1, float v2, float v3) Parameters program uint location int v0 float v1 float v2 float v3 float glProgramUniform4fEXT(uint, int, float, float, float, float) public static extern void glProgramUniform4fEXT(uint program, int location, float v0, float v1, float v2, float v3) Parameters program uint location int v0 float v1 float v2 float v3 float glProgramUniform4fv(uint, int, int, float*) public static extern void glProgramUniform4fv(uint program, int location, int count, float* value) Parameters program uint location int count int value float* glProgramUniform4fvEXT(uint, int, int, float*) public static extern void glProgramUniform4fvEXT(uint program, int location, int count, float* value) Parameters program uint location int count int value float* glProgramUniform4i(uint, int, int, int, int, int) public static extern void glProgramUniform4i(uint program, int location, int v0, int v1, int v2, int v3) Parameters program uint location int v0 int v1 int v2 int v3 int glProgramUniform4i64NV(uint, int, long, long, long, long) public static extern void glProgramUniform4i64NV(uint program, int location, long x, long y, long z, long w) Parameters program uint location int x long y long z long w long glProgramUniform4i64vNV(uint, int, int, long*) public static extern void glProgramUniform4i64vNV(uint program, int location, int count, long* value) Parameters program uint location int count int value long* glProgramUniform4iEXT(uint, int, int, int, int, int) public static extern void glProgramUniform4iEXT(uint program, int location, int v0, int v1, int v2, int v3) Parameters program uint location int v0 int v1 int v2 int v3 int glProgramUniform4iv(uint, int, int, int*) public static extern void glProgramUniform4iv(uint program, int location, int count, int* value) Parameters program uint location int count int value int* glProgramUniform4ivEXT(uint, int, int, int*) public static extern void glProgramUniform4ivEXT(uint program, int location, int count, int* value) Parameters program uint location int count int value int* glProgramUniform4ui(uint, int, uint, uint, uint, uint) public static extern void glProgramUniform4ui(uint program, int location, uint v0, uint v1, uint v2, uint v3) Parameters program uint location int v0 uint v1 uint v2 uint v3 uint glProgramUniform4ui64NV(uint, int, ulong, ulong, ulong, ulong) public static extern void glProgramUniform4ui64NV(uint program, int location, ulong x, ulong y, ulong z, ulong w) Parameters program uint location int x ulong y ulong z ulong w ulong glProgramUniform4ui64vNV(uint, int, int, ulong*) public static extern void glProgramUniform4ui64vNV(uint program, int location, int count, ulong* value) Parameters program uint location int count int value ulong* glProgramUniform4uiEXT(uint, int, uint, uint, uint, uint) public static extern void glProgramUniform4uiEXT(uint program, int location, uint v0, uint v1, uint v2, uint v3) Parameters program uint location int v0 uint v1 uint v2 uint v3 uint glProgramUniform4uiv(uint, int, int, uint*) public static extern void glProgramUniform4uiv(uint program, int location, int count, uint* value) Parameters program uint location int count int value uint* glProgramUniform4uivEXT(uint, int, int, uint*) public static extern void glProgramUniform4uivEXT(uint program, int location, int count, uint* value) Parameters program uint location int count int value uint* glProgramUniformMatrix2dv(uint, int, int, bool, double*) public static extern void glProgramUniformMatrix2dv(uint program, int location, int count, bool transpose, double* value) Parameters program uint location int count int transpose bool value double* glProgramUniformMatrix2dvEXT(uint, int, int, bool, double*) public static extern void glProgramUniformMatrix2dvEXT(uint program, int location, int count, bool transpose, double* value) Parameters program uint location int count int transpose bool value double* glProgramUniformMatrix2fv(uint, int, int, bool, float*) public static extern void glProgramUniformMatrix2fv(uint program, int location, int count, bool transpose, float* value) Parameters program uint location int count int transpose bool value float* glProgramUniformMatrix2fvEXT(uint, int, int, bool, float*) public static extern void glProgramUniformMatrix2fvEXT(uint program, int location, int count, bool transpose, float* value) Parameters program uint location int count int transpose bool value float* glProgramUniformMatrix2x3dv(uint, int, int, bool, double*) public static extern void glProgramUniformMatrix2x3dv(uint program, int location, int count, bool transpose, double* value) Parameters program uint location int count int transpose bool value double* glProgramUniformMatrix2x3dvEXT(uint, int, int, bool, double*) public static extern void glProgramUniformMatrix2x3dvEXT(uint program, int location, int count, bool transpose, double* value) Parameters program uint location int count int transpose bool value double* glProgramUniformMatrix2x3fv(uint, int, int, bool, float*) public static extern void glProgramUniformMatrix2x3fv(uint program, int location, int count, bool transpose, float* value) Parameters program uint location int count int transpose bool value float* glProgramUniformMatrix2x3fvEXT(uint, int, int, bool, float*) public static extern void glProgramUniformMatrix2x3fvEXT(uint program, int location, int count, bool transpose, float* value) Parameters program uint location int count int transpose bool value float* glProgramUniformMatrix2x4dv(uint, int, int, bool, double*) public static extern void glProgramUniformMatrix2x4dv(uint program, int location, int count, bool transpose, double* value) Parameters program uint location int count int transpose bool value double* glProgramUniformMatrix2x4dvEXT(uint, int, int, bool, double*) public static extern void glProgramUniformMatrix2x4dvEXT(uint program, int location, int count, bool transpose, double* value) Parameters program uint location int count int transpose bool value double* glProgramUniformMatrix2x4fv(uint, int, int, bool, float*) public static extern void glProgramUniformMatrix2x4fv(uint program, int location, int count, bool transpose, float* value) Parameters program uint location int count int transpose bool value float* glProgramUniformMatrix2x4fvEXT(uint, int, int, bool, float*) public static extern void glProgramUniformMatrix2x4fvEXT(uint program, int location, int count, bool transpose, float* value) Parameters program uint location int count int transpose bool value float* glProgramUniformMatrix3dv(uint, int, int, bool, double*) public static extern void glProgramUniformMatrix3dv(uint program, int location, int count, bool transpose, double* value) Parameters program uint location int count int transpose bool value double* glProgramUniformMatrix3dvEXT(uint, int, int, bool, double*) public static extern void glProgramUniformMatrix3dvEXT(uint program, int location, int count, bool transpose, double* value) Parameters program uint location int count int transpose bool value double* glProgramUniformMatrix3fv(uint, int, int, bool, float*) public static extern void glProgramUniformMatrix3fv(uint program, int location, int count, bool transpose, float* value) Parameters program uint location int count int transpose bool value float* glProgramUniformMatrix3fvEXT(uint, int, int, bool, float*) public static extern void glProgramUniformMatrix3fvEXT(uint program, int location, int count, bool transpose, float* value) Parameters program uint location int count int transpose bool value float* glProgramUniformMatrix3x2dv(uint, int, int, bool, double*) public static extern void glProgramUniformMatrix3x2dv(uint program, int location, int count, bool transpose, double* value) Parameters program uint location int count int transpose bool value double* glProgramUniformMatrix3x2dvEXT(uint, int, int, bool, double*) public static extern void glProgramUniformMatrix3x2dvEXT(uint program, int location, int count, bool transpose, double* value) Parameters program uint location int count int transpose bool value double* glProgramUniformMatrix3x2fv(uint, int, int, bool, float*) public static extern void glProgramUniformMatrix3x2fv(uint program, int location, int count, bool transpose, float* value) Parameters program uint location int count int transpose bool value float* glProgramUniformMatrix3x2fvEXT(uint, int, int, bool, float*) public static extern void glProgramUniformMatrix3x2fvEXT(uint program, int location, int count, bool transpose, float* value) Parameters program uint location int count int transpose bool value float* glProgramUniformMatrix3x4dv(uint, int, int, bool, double*) public static extern void glProgramUniformMatrix3x4dv(uint program, int location, int count, bool transpose, double* value) Parameters program uint location int count int transpose bool value double* glProgramUniformMatrix3x4dvEXT(uint, int, int, bool, double*) public static extern void glProgramUniformMatrix3x4dvEXT(uint program, int location, int count, bool transpose, double* value) Parameters program uint location int count int transpose bool value double* glProgramUniformMatrix3x4fv(uint, int, int, bool, float*) public static extern void glProgramUniformMatrix3x4fv(uint program, int location, int count, bool transpose, float* value) Parameters program uint location int count int transpose bool value float* glProgramUniformMatrix3x4fvEXT(uint, int, int, bool, float*) public static extern void glProgramUniformMatrix3x4fvEXT(uint program, int location, int count, bool transpose, float* value) Parameters program uint location int count int transpose bool value float* glProgramUniformMatrix4dv(uint, int, int, bool, double*) public static extern void glProgramUniformMatrix4dv(uint program, int location, int count, bool transpose, double* value) Parameters program uint location int count int transpose bool value double* glProgramUniformMatrix4dvEXT(uint, int, int, bool, double*) public static extern void glProgramUniformMatrix4dvEXT(uint program, int location, int count, bool transpose, double* value) Parameters program uint location int count int transpose bool value double* glProgramUniformMatrix4fv(uint, int, int, bool, float*) public static extern void glProgramUniformMatrix4fv(uint program, int location, int count, bool transpose, float* value) Parameters program uint location int count int transpose bool value float* glProgramUniformMatrix4fvEXT(uint, int, int, bool, float*) public static extern void glProgramUniformMatrix4fvEXT(uint program, int location, int count, bool transpose, float* value) Parameters program uint location int count int transpose bool value float* glProgramUniformMatrix4x2dv(uint, int, int, bool, double*) public static extern void glProgramUniformMatrix4x2dv(uint program, int location, int count, bool transpose, double* value) Parameters program uint location int count int transpose bool value double* glProgramUniformMatrix4x2dvEXT(uint, int, int, bool, double*) public static extern void glProgramUniformMatrix4x2dvEXT(uint program, int location, int count, bool transpose, double* value) Parameters program uint location int count int transpose bool value double* glProgramUniformMatrix4x2fv(uint, int, int, bool, float*) public static extern void glProgramUniformMatrix4x2fv(uint program, int location, int count, bool transpose, float* value) Parameters program uint location int count int transpose bool value float* glProgramUniformMatrix4x2fvEXT(uint, int, int, bool, float*) public static extern void glProgramUniformMatrix4x2fvEXT(uint program, int location, int count, bool transpose, float* value) Parameters program uint location int count int transpose bool value float* glProgramUniformMatrix4x3dv(uint, int, int, bool, double*) public static extern void glProgramUniformMatrix4x3dv(uint program, int location, int count, bool transpose, double* value) Parameters program uint location int count int transpose bool value double* glProgramUniformMatrix4x3dvEXT(uint, int, int, bool, double*) public static extern void glProgramUniformMatrix4x3dvEXT(uint program, int location, int count, bool transpose, double* value) Parameters program uint location int count int transpose bool value double* glProgramUniformMatrix4x3fv(uint, int, int, bool, float*) public static extern void glProgramUniformMatrix4x3fv(uint program, int location, int count, bool transpose, float* value) Parameters program uint location int count int transpose bool value float* glProgramUniformMatrix4x3fvEXT(uint, int, int, bool, float*) public static extern void glProgramUniformMatrix4x3fvEXT(uint program, int location, int count, bool transpose, float* value) Parameters program uint location int count int transpose bool value float* glProgramUniformui64NV(uint, int, ulong) public static extern void glProgramUniformui64NV(uint program, int location, ulong value) Parameters program uint location int value ulong glProgramUniformui64vNV(uint, int, int, ulong*) public static extern void glProgramUniformui64vNV(uint program, int location, int count, ulong* value) Parameters program uint location int count int value ulong* glProgramVertexLimitNV(uint, int) public static extern void glProgramVertexLimitNV(uint target, int limit) Parameters target uint limit int glProvokingVertex(uint) public static extern void glProvokingVertex(uint mode) Parameters mode uint glProvokingVertexEXT(uint) public static extern void glProvokingVertexEXT(uint mode) Parameters mode uint glPushClientAttribDefaultEXT(uint) public static extern void glPushClientAttribDefaultEXT(uint mask) Parameters mask uint glQueryCounter(uint, uint) public static extern void glQueryCounter(uint id, uint target) Parameters id uint target uint glReadBuffer(uint) public static extern void glReadBuffer(uint mode) Parameters mode uint glReadPixels(int, int, int, int, uint, uint, nint) public static extern void glReadPixels(int x, int y, int width, int height, uint format, uint type, nint pixels) Parameters x int y int width int height int format uint type uint pixels nint glReadnPixelsARB(int, int, int, int, uint, uint, int, nint) public static extern void glReadnPixelsARB(int x, int y, int width, int height, uint format, uint type, int bufSize, nint data) Parameters x int y int width int height int format uint type uint bufSize int data nint glReleaseShaderCompiler() public static extern void glReleaseShaderCompiler() glRenderbufferStorage(uint, uint, int, int) public static extern void glRenderbufferStorage(uint target, uint internalformat, int width, int height) Parameters target uint internalformat uint width int height int glRenderbufferStorageEXT(uint, uint, int, int) public static extern void glRenderbufferStorageEXT(uint target, uint internalformat, int width, int height) Parameters target uint internalformat uint width int height int glRenderbufferStorageMultisample(uint, int, uint, int, int) public static extern void glRenderbufferStorageMultisample(uint target, int samples, uint internalformat, int width, int height) Parameters target uint samples int internalformat uint width int height int glRenderbufferStorageMultisampleCoverageNV(uint, int, int, uint, int, int) public static extern void glRenderbufferStorageMultisampleCoverageNV(uint target, int coverageSamples, int colorSamples, uint internalformat, int width, int height) Parameters target uint coverageSamples int colorSamples int internalformat uint width int height int glRenderbufferStorageMultisampleEXT(uint, int, uint, int, int) public static extern void glRenderbufferStorageMultisampleEXT(uint target, int samples, uint internalformat, int width, int height) Parameters target uint samples int internalformat uint width int height int glReplacementCodePointerSUN(uint, int, nint) public static extern void glReplacementCodePointerSUN(uint type, int stride, nint pointer) Parameters type uint stride int pointer nint glResizeBuffersMESA() public static extern void glResizeBuffersMESA() glResumeTransformFeedback() public static extern void glResumeTransformFeedback() glResumeTransformFeedbackNV() public static extern void glResumeTransformFeedbackNV() glSampleCoverage(float, bool) public static extern void glSampleCoverage(float value, bool invert) Parameters value float invert bool glSampleCoverageARB(float, bool) public static extern void glSampleCoverageARB(float value, bool invert) Parameters value float invert bool glSampleMapATI(uint, uint, uint) public static extern void glSampleMapATI(uint dst, uint interp, uint swizzle) Parameters dst uint interp uint swizzle uint glSampleMaskEXT(float, bool) public static extern void glSampleMaskEXT(float value, bool invert) Parameters value float invert bool glSampleMaskIndexedNV(uint, uint) public static extern void glSampleMaskIndexedNV(uint index, uint mask) Parameters index uint mask uint glSampleMaskSGIS(float, bool) public static extern void glSampleMaskSGIS(float value, bool invert) Parameters value float invert bool glSampleMaski(uint, uint) public static extern void glSampleMaski(uint index, uint mask) Parameters index uint mask uint glSamplePatternEXT(uint) public static extern void glSamplePatternEXT(uint pattern) Parameters pattern uint glSamplePatternSGIS(uint) public static extern void glSamplePatternSGIS(uint pattern) Parameters pattern uint glSamplerParameterIiv(uint, uint, int*) public static extern void glSamplerParameterIiv(uint sampler, uint pname, int* param) Parameters sampler uint pname uint param int* glSamplerParameterIuiv(uint, uint, uint*) public static extern void glSamplerParameterIuiv(uint sampler, uint pname, uint* param) Parameters sampler uint pname uint param uint* glSamplerParameterf(uint, uint, float) public static extern void glSamplerParameterf(uint sampler, uint pname, float param) Parameters sampler uint pname uint param float glSamplerParameterfv(uint, uint, float*) public static extern void glSamplerParameterfv(uint sampler, uint pname, float* param) Parameters sampler uint pname uint param float* glSamplerParameteri(uint, uint, int) public static extern void glSamplerParameteri(uint sampler, uint pname, int param) Parameters sampler uint pname uint param int glSamplerParameteriv(uint, uint, int*) public static extern void glSamplerParameteriv(uint sampler, uint pname, int* param) Parameters sampler uint pname uint param int* glScissor(int, int, int, int) public static extern void glScissor(int x, int y, int width, int height) Parameters x int y int width int height int glScissorArrayv(uint, int, int*) public static extern void glScissorArrayv(uint first, int count, int* v) Parameters first uint count int v int* glScissorIndexed(uint, int, int, int, int) public static extern void glScissorIndexed(uint index, int left, int bottom, int width, int height) Parameters index uint left int bottom int width int height int glScissorIndexedv(uint, int*) public static extern void glScissorIndexedv(uint index, int* v) Parameters index uint v int* glSecondaryColorFormatNV(int, uint, int) public static extern void glSecondaryColorFormatNV(int size, uint type, int stride) Parameters size int type uint stride int glSecondaryColorPointerListIBM(int, uint, int, nint, int) public static extern void glSecondaryColorPointerListIBM(int size, uint type, int stride, nint pointer, int ptrstride) Parameters size int type uint stride int pointer nint ptrstride int glSelectPerfMonitorCountersAMD(uint, bool, uint, int, uint*) public static extern void glSelectPerfMonitorCountersAMD(uint monitor, bool enable, uint group, int numCounters, uint* counterList) Parameters monitor uint enable bool group uint numCounters int counterList uint* glSetFenceAPPLE(uint) public static extern void glSetFenceAPPLE(uint fence) Parameters fence uint glSetFenceNV(uint, uint) public static extern void glSetFenceNV(uint fence, uint condition) Parameters fence uint condition uint glSetFragmentShaderConstantATI(uint, float*) public static extern void glSetFragmentShaderConstantATI(uint dst, float* value) Parameters dst uint value float* glSetInvariantEXT(uint, uint, nint) public static extern void glSetInvariantEXT(uint id, uint type, nint addr) Parameters id uint type uint addr nint glSetLocalConstantEXT(uint, uint, nint) public static extern void glSetLocalConstantEXT(uint id, uint type, nint addr) Parameters id uint type uint addr nint glSetMultisamplefvAMD(uint, uint, float*) public static extern void glSetMultisamplefvAMD(uint pname, uint index, float* val) Parameters pname uint index uint val float* glShaderBinary(int, uint*, uint, nint, int) public static extern void glShaderBinary(int count, uint* shaders, uint binaryformat, nint binary, int length) Parameters count int shaders uint* binaryformat uint binary nint length int glShaderOp1EXT(uint, uint, uint) public static extern void glShaderOp1EXT(uint op, uint res, uint arg1) Parameters op uint res uint arg1 uint glShaderOp2EXT(uint, uint, uint, uint) public static extern void glShaderOp2EXT(uint op, uint res, uint arg1, uint arg2) Parameters op uint res uint arg1 uint arg2 uint glShaderOp3EXT(uint, uint, uint, uint, uint) public static extern void glShaderOp3EXT(uint op, uint res, uint arg1, uint arg2, uint arg3) Parameters op uint res uint arg1 uint arg2 uint arg3 uint glShaderSource(uint, int, string[], int*) public static extern void glShaderSource(uint shader, int count, string[] @string, int* length) Parameters shader uint count int string string[] length int* glShaderSourceARB(uint, int, string[], int*) public static extern void glShaderSourceARB(uint shaderObj, int count, string[] @string, int* length) Parameters shaderObj uint count int string string[] length int* glStencilClearTagEXT(int, uint) public static extern void glStencilClearTagEXT(int stencilTagBits, uint stencilClearTag) Parameters stencilTagBits int stencilClearTag uint glStencilFunc(uint, int, uint) public static extern void glStencilFunc(uint func, int @ref, uint mask) Parameters func uint ref int mask uint glStencilFuncSeparate(uint, uint, int, uint) public static extern void glStencilFuncSeparate(uint face, uint func, int @ref, uint mask) Parameters face uint func uint ref int mask uint glStencilFuncSeparateATI(uint, uint, int, uint) public static extern void glStencilFuncSeparateATI(uint frontfunc, uint backfunc, int @ref, uint mask) Parameters frontfunc uint backfunc uint ref int mask uint glStencilMask(uint) public static extern void glStencilMask(uint mask) Parameters mask uint glStencilMaskSeparate(uint, uint) public static extern void glStencilMaskSeparate(uint face, uint mask) Parameters face uint mask uint glStencilOp(uint, uint, uint) public static extern void glStencilOp(uint fail, uint zfail, uint zpass) Parameters fail uint zfail uint zpass uint glStencilOpSeparate(uint, uint, uint, uint) public static extern void glStencilOpSeparate(uint face, uint sfail, uint dpfail, uint dppass) Parameters face uint sfail uint dpfail uint dppass uint glStencilOpSeparateATI(uint, uint, uint, uint) public static extern void glStencilOpSeparateATI(uint face, uint sfail, uint dpfail, uint dppass) Parameters face uint sfail uint dpfail uint dppass uint glStringMarkerGREMEDY(int, nint) public static extern void glStringMarkerGREMEDY(int len, nint @string) Parameters len int string nint glSwizzleEXT(uint, uint, uint, uint, uint, uint) public static extern void glSwizzleEXT(uint res, uint @in, uint outX, uint outY, uint outZ, uint outW) Parameters res uint in uint outX uint outY uint outZ uint outW uint glTbufferMask3DFX(uint) public static extern void glTbufferMask3DFX(uint mask) Parameters mask uint glTessellationFactorAMD(float) public static extern void glTessellationFactorAMD(float factor) Parameters factor float glTessellationModeAMD(uint) public static extern void glTessellationModeAMD(uint mode) Parameters mode uint glTestFenceAPPLE(uint) public static extern int glTestFenceAPPLE(uint fence) Parameters fence uint Returns int glTestFenceNV(uint) public static extern int glTestFenceNV(uint fence) Parameters fence uint Returns int glTestObjectAPPLE(uint, uint) public static extern int glTestObjectAPPLE(uint @object, uint name) Parameters object uint name uint Returns int glTexBuffer(uint, uint, uint) public static extern void glTexBuffer(uint target, uint internalformat, uint buffer) Parameters target uint internalformat uint buffer uint glTexBufferARB(uint, uint, uint) public static extern void glTexBufferARB(uint target, uint internalformat, uint buffer) Parameters target uint internalformat uint buffer uint glTexBufferEXT(uint, uint, uint) public static extern void glTexBufferEXT(uint target, uint internalformat, uint buffer) Parameters target uint internalformat uint buffer uint glTexCoordFormatNV(int, uint, int) public static extern void glTexCoordFormatNV(int size, uint type, int stride) Parameters size int type uint stride int glTexCoordPointerListIBM(int, uint, int, nint, int) public static extern void glTexCoordPointerListIBM(int size, uint type, int stride, nint pointer, int ptrstride) Parameters size int type uint stride int pointer nint ptrstride int glTexCoordPointervINTEL(int, uint, nint) public static extern void glTexCoordPointervINTEL(int size, uint type, nint pointer) Parameters size int type uint pointer nint glTexFilterFuncSGIS(uint, uint, int, float*) public static extern void glTexFilterFuncSGIS(uint target, uint filter, int n, float* weights) Parameters target uint filter uint n int weights float* glTexImage1D(uint, int, uint, int, int, uint, uint, nint) public static extern void glTexImage1D(uint target, int level, uint internalformat, int width, int border, uint format, uint type, nint pixels) Parameters target uint level int internalformat uint width int border int format uint type uint pixels nint glTexImage2D(uint, int, uint, int, int, int, uint, uint, nint) public static extern void glTexImage2D(uint target, int level, uint internalformat, int width, int height, int border, uint format, uint type, nint pixels) Parameters target uint level int internalformat uint width int height int border int format uint type uint pixels nint glTexImage2DMultisample(uint, int, uint, int, int, bool) public static extern void glTexImage2DMultisample(uint target, int samples, uint internalformat, int width, int height, bool fixedsamplelocations) Parameters target uint samples int internalformat uint width int height int fixedsamplelocations bool glTexImage2DMultisampleCoverageNV(uint, int, int, int, int, int, bool) public static extern void glTexImage2DMultisampleCoverageNV(uint target, int coverageSamples, int colorSamples, int internalFormat, int width, int height, bool fixedSampleLocations) Parameters target uint coverageSamples int colorSamples int internalFormat int width int height int fixedSampleLocations bool glTexImage3D(uint, int, uint, int, int, int, int, uint, uint, nint) public static extern void glTexImage3D(uint target, int level, uint internalformat, int width, int height, int depth, int border, uint format, uint type, nint pixels) Parameters target uint level int internalformat uint width int height int depth int border int format uint type uint pixels nint glTexImage3DEXT(uint, int, uint, int, int, int, int, uint, uint, nint) public static extern void glTexImage3DEXT(uint target, int level, uint internalformat, int width, int height, int depth, int border, uint format, uint type, nint pixels) Parameters target uint level int internalformat uint width int height int depth int border int format uint type uint pixels nint glTexImage3DMultisample(uint, int, uint, int, int, int, bool) public static extern void glTexImage3DMultisample(uint target, int samples, uint internalformat, int width, int height, int depth, bool fixedsamplelocations) Parameters target uint samples int internalformat uint width int height int depth int fixedsamplelocations bool glTexImage3DMultisampleCoverageNV(uint, int, int, int, int, int, int, bool) public static extern void glTexImage3DMultisampleCoverageNV(uint target, int coverageSamples, int colorSamples, int internalFormat, int width, int height, int depth, bool fixedSampleLocations) Parameters target uint coverageSamples int colorSamples int internalFormat int width int height int depth int fixedSampleLocations bool glTexImage4DSGIS(uint, int, uint, int, int, int, int, int, uint, uint, nint) public static extern void glTexImage4DSGIS(uint target, int level, uint internalformat, int width, int height, int depth, int size4d, int border, uint format, uint type, nint pixels) Parameters target uint level int internalformat uint width int height int depth int size4d int border int format uint type uint pixels nint glTexParameterIiv(uint, uint, int*) public static extern void glTexParameterIiv(uint target, uint pname, int* @params) Parameters target uint pname uint params int* glTexParameterIivEXT(uint, uint, int*) public static extern void glTexParameterIivEXT(uint target, uint pname, int* @params) Parameters target uint pname uint params int* glTexParameterIuiv(uint, uint, uint*) public static extern void glTexParameterIuiv(uint target, uint pname, uint* @params) Parameters target uint pname uint params uint* glTexParameterIuivEXT(uint, uint, uint*) public static extern void glTexParameterIuivEXT(uint target, uint pname, uint* @params) Parameters target uint pname uint params uint* glTexParameterf(uint, uint, float) public static extern void glTexParameterf(uint target, uint pname, float param) Parameters target uint pname uint param float glTexParameterfv(uint, uint, float*) public static extern void glTexParameterfv(uint target, uint pname, float* @params) Parameters target uint pname uint params float* glTexParameteri(uint, uint, int) public static extern void glTexParameteri(uint target, uint pname, int param) Parameters target uint pname uint param int glTexParameteriv(uint, uint, int*) public static extern void glTexParameteriv(uint target, uint pname, int* @params) Parameters target uint pname uint params int* glTexRenderbufferNV(uint, uint) public static extern void glTexRenderbufferNV(uint target, uint renderbuffer) Parameters target uint renderbuffer uint glTexSubImage1D(uint, int, int, int, uint, uint, nint) public static extern void glTexSubImage1D(uint target, int level, int xoffset, int width, uint format, uint type, nint pixels) Parameters target uint level int xoffset int width int format uint type uint pixels nint glTexSubImage1DEXT(uint, int, int, int, uint, uint, nint) public static extern void glTexSubImage1DEXT(uint target, int level, int xoffset, int width, uint format, uint type, nint pixels) Parameters target uint level int xoffset int width int format uint type uint pixels nint glTexSubImage2D(uint, int, int, int, int, int, uint, uint, nint) public static extern void glTexSubImage2D(uint target, int level, int xoffset, int yoffset, int width, int height, uint format, uint type, nint pixels) Parameters target uint level int xoffset int yoffset int width int height int format uint type uint pixels nint glTexSubImage2DEXT(uint, int, int, int, int, int, uint, uint, nint) public static extern void glTexSubImage2DEXT(uint target, int level, int xoffset, int yoffset, int width, int height, uint format, uint type, nint pixels) Parameters target uint level int xoffset int yoffset int width int height int format uint type uint pixels nint glTexSubImage3D(uint, int, int, int, int, int, int, int, uint, uint, nint) public static extern void glTexSubImage3D(uint target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, uint type, nint pixels) Parameters target uint level int xoffset int yoffset int zoffset int width int height int depth int format uint type uint pixels nint glTexSubImage3DEXT(uint, int, int, int, int, int, int, int, uint, uint, nint) public static extern void glTexSubImage3DEXT(uint target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, uint type, nint pixels) Parameters target uint level int xoffset int yoffset int zoffset int width int height int depth int format uint type uint pixels nint glTexSubImage4DSGIS(uint, int, int, int, int, int, int, int, int, int, uint, uint, nint) public static extern void glTexSubImage4DSGIS(uint target, int level, int xoffset, int yoffset, int zoffset, int woffset, int width, int height, int depth, int size4d, uint format, uint type, nint pixels) Parameters target uint level int xoffset int yoffset int zoffset int woffset int width int height int depth int size4d int format uint type uint pixels nint glTextureBarrierNV() public static extern void glTextureBarrierNV() glTextureBufferEXT(uint, uint, uint, uint) public static extern void glTextureBufferEXT(uint texture, uint target, uint internalformat, uint buffer) Parameters texture uint target uint internalformat uint buffer uint glTextureImage1DEXT(uint, uint, int, uint, int, int, uint, uint, nint) public static extern void glTextureImage1DEXT(uint texture, uint target, int level, uint internalformat, int width, int border, uint format, uint type, nint pixels) Parameters texture uint target uint level int internalformat uint width int border int format uint type uint pixels nint glTextureImage2DEXT(uint, uint, int, uint, int, int, int, uint, uint, nint) public static extern void glTextureImage2DEXT(uint texture, uint target, int level, uint internalformat, int width, int height, int border, uint format, uint type, nint pixels) Parameters texture uint target uint level int internalformat uint width int height int border int format uint type uint pixels nint glTextureImage2DMultisampleCoverageNV(uint, uint, int, int, int, int, int, bool) public static extern void glTextureImage2DMultisampleCoverageNV(uint texture, uint target, int coverageSamples, int colorSamples, int internalFormat, int width, int height, bool fixedSampleLocations) Parameters texture uint target uint coverageSamples int colorSamples int internalFormat int width int height int fixedSampleLocations bool glTextureImage2DMultisampleNV(uint, uint, int, int, int, int, bool) public static extern void glTextureImage2DMultisampleNV(uint texture, uint target, int samples, int internalFormat, int width, int height, bool fixedSampleLocations) Parameters texture uint target uint samples int internalFormat int width int height int fixedSampleLocations bool glTextureImage3DEXT(uint, uint, int, uint, int, int, int, int, uint, uint, nint) public static extern void glTextureImage3DEXT(uint texture, uint target, int level, uint internalformat, int width, int height, int depth, int border, uint format, uint type, nint pixels) Parameters texture uint target uint level int internalformat uint width int height int depth int border int format uint type uint pixels nint glTextureImage3DMultisampleCoverageNV(uint, uint, int, int, int, int, int, int, bool) public static extern void glTextureImage3DMultisampleCoverageNV(uint texture, uint target, int coverageSamples, int colorSamples, int internalFormat, int width, int height, int depth, bool fixedSampleLocations) Parameters texture uint target uint coverageSamples int colorSamples int internalFormat int width int height int depth int fixedSampleLocations bool glTextureImage3DMultisampleNV(uint, uint, int, int, int, int, int, bool) public static extern void glTextureImage3DMultisampleNV(uint texture, uint target, int samples, int internalFormat, int width, int height, int depth, bool fixedSampleLocations) Parameters texture uint target uint samples int internalFormat int width int height int depth int fixedSampleLocations bool glTextureParameterIivEXT(uint, uint, uint, int*) public static extern void glTextureParameterIivEXT(uint texture, uint target, uint pname, int* @params) Parameters texture uint target uint pname uint params int* glTextureParameterIuivEXT(uint, uint, uint, uint*) public static extern void glTextureParameterIuivEXT(uint texture, uint target, uint pname, uint* @params) Parameters texture uint target uint pname uint params uint* glTextureParameterfEXT(uint, uint, uint, float) public static extern void glTextureParameterfEXT(uint texture, uint target, uint pname, float param) Parameters texture uint target uint pname uint param float glTextureParameterfvEXT(uint, uint, uint, float*) public static extern void glTextureParameterfvEXT(uint texture, uint target, uint pname, float* @params) Parameters texture uint target uint pname uint params float* glTextureParameteriEXT(uint, uint, uint, int) public static extern void glTextureParameteriEXT(uint texture, uint target, uint pname, int param) Parameters texture uint target uint pname uint param int glTextureParameterivEXT(uint, uint, uint, int*) public static extern void glTextureParameterivEXT(uint texture, uint target, uint pname, int* @params) Parameters texture uint target uint pname uint params int* glTextureRangeAPPLE(uint, int, nint) public static extern void glTextureRangeAPPLE(uint target, int length, nint pointer) Parameters target uint length int pointer nint glTextureRenderbufferEXT(uint, uint, uint) public static extern void glTextureRenderbufferEXT(uint texture, uint target, uint renderbuffer) Parameters texture uint target uint renderbuffer uint glTextureSubImage1DEXT(uint, uint, int, int, int, uint, uint, nint) public static extern void glTextureSubImage1DEXT(uint texture, uint target, int level, int xoffset, int width, uint format, uint type, nint pixels) Parameters texture uint target uint level int xoffset int width int format uint type uint pixels nint glTextureSubImage2DEXT(uint, uint, int, int, int, int, int, uint, uint, nint) public static extern void glTextureSubImage2DEXT(uint texture, uint target, int level, int xoffset, int yoffset, int width, int height, uint format, uint type, nint pixels) Parameters texture uint target uint level int xoffset int yoffset int width int height int format uint type uint pixels nint glTextureSubImage3DEXT(uint, uint, int, int, int, int, int, int, int, uint, uint, nint) public static extern void glTextureSubImage3DEXT(uint texture, uint target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, uint type, nint pixels) Parameters texture uint target uint level int xoffset int yoffset int zoffset int width int height int depth int format uint type uint pixels nint glTransformFeedbackAttribsNV(uint, int*, uint) public static extern void glTransformFeedbackAttribsNV(uint count, int* attribs, uint bufferMode) Parameters count uint attribs int* bufferMode uint glTransformFeedbackStreamAttribsNV(int, int*, int, int*, uint) public static extern void glTransformFeedbackStreamAttribsNV(int count, int* attribs, int nbuffers, int* bufstreams, uint bufferMode) Parameters count int attribs int* nbuffers int bufstreams int* bufferMode uint glTransformFeedbackVaryings(uint, int, string[], uint) public static extern void glTransformFeedbackVaryings(uint program, int count, string[] varyings, uint bufferMode) Parameters program uint count int varyings string[] bufferMode uint glTransformFeedbackVaryingsEXT(uint, int, string[], uint) public static extern void glTransformFeedbackVaryingsEXT(uint program, int count, string[] varyings, uint bufferMode) Parameters program uint count int varyings string[] bufferMode uint glTransformFeedbackVaryingsNV(uint, int, int*, uint) public static extern void glTransformFeedbackVaryingsNV(uint program, int count, int* locations, uint bufferMode) Parameters program uint count int locations int* bufferMode uint glUniform1d(int, double) public static extern void glUniform1d(int location, double x) Parameters location int x double glUniform1dv(int, int, double*) public static extern void glUniform1dv(int location, int count, double* value) Parameters location int count int value double* glUniform1f(int, float) public static extern void glUniform1f(int location, float v0) Parameters location int v0 float glUniform1fARB(int, float) public static extern void glUniform1fARB(int location, float v0) Parameters location int v0 float glUniform1fv(int, int, float*) public static extern void glUniform1fv(int location, int count, float* value) Parameters location int count int value float* glUniform1fvARB(int, int, float*) public static extern void glUniform1fvARB(int location, int count, float* value) Parameters location int count int value float* glUniform1i(int, int) public static extern void glUniform1i(int location, int v0) Parameters location int v0 int glUniform1i64NV(int, long) public static extern void glUniform1i64NV(int location, long x) Parameters location int x long glUniform1i64vNV(int, int, long*) public static extern void glUniform1i64vNV(int location, int count, long* value) Parameters location int count int value long* glUniform1iARB(int, int) public static extern void glUniform1iARB(int location, int v0) Parameters location int v0 int glUniform1iv(int, int, int*) public static extern void glUniform1iv(int location, int count, int* value) Parameters location int count int value int* glUniform1ivARB(int, int, int*) public static extern void glUniform1ivARB(int location, int count, int* value) Parameters location int count int value int* glUniform1ui(int, uint) public static extern void glUniform1ui(int location, uint v0) Parameters location int v0 uint glUniform1ui64NV(int, ulong) public static extern void glUniform1ui64NV(int location, ulong x) Parameters location int x ulong glUniform1ui64vNV(int, int, ulong*) public static extern void glUniform1ui64vNV(int location, int count, ulong* value) Parameters location int count int value ulong* glUniform1uiEXT(int, uint) public static extern void glUniform1uiEXT(int location, uint v0) Parameters location int v0 uint glUniform1uiv(int, int, uint*) public static extern void glUniform1uiv(int location, int count, uint* value) Parameters location int count int value uint* glUniform1uivEXT(int, int, uint*) public static extern void glUniform1uivEXT(int location, int count, uint* value) Parameters location int count int value uint* glUniform2d(int, double, double) public static extern void glUniform2d(int location, double x, double y) Parameters location int x double y double glUniform2dv(int, int, double*) public static extern void glUniform2dv(int location, int count, double* value) Parameters location int count int value double* glUniform2f(int, float, float) public static extern void glUniform2f(int location, float v0, float v1) Parameters location int v0 float v1 float glUniform2fARB(int, float, float) public static extern void glUniform2fARB(int location, float v0, float v1) Parameters location int v0 float v1 float glUniform2fv(int, int, float*) public static extern void glUniform2fv(int location, int count, float* value) Parameters location int count int value float* glUniform2fvARB(int, int, float*) public static extern void glUniform2fvARB(int location, int count, float* value) Parameters location int count int value float* glUniform2i(int, int, int) public static extern void glUniform2i(int location, int v0, int v1) Parameters location int v0 int v1 int glUniform2i64NV(int, long, long) public static extern void glUniform2i64NV(int location, long x, long y) Parameters location int x long y long glUniform2i64vNV(int, int, long*) public static extern void glUniform2i64vNV(int location, int count, long* value) Parameters location int count int value long* glUniform2iARB(int, int, int) public static extern void glUniform2iARB(int location, int v0, int v1) Parameters location int v0 int v1 int glUniform2iv(int, int, int*) public static extern void glUniform2iv(int location, int count, int* value) Parameters location int count int value int* glUniform2ivARB(int, int, int*) public static extern void glUniform2ivARB(int location, int count, int* value) Parameters location int count int value int* glUniform2ui(int, uint, uint) public static extern void glUniform2ui(int location, uint v0, uint v1) Parameters location int v0 uint v1 uint glUniform2ui64NV(int, ulong, ulong) public static extern void glUniform2ui64NV(int location, ulong x, ulong y) Parameters location int x ulong y ulong glUniform2ui64vNV(int, int, ulong*) public static extern void glUniform2ui64vNV(int location, int count, ulong* value) Parameters location int count int value ulong* glUniform2uiEXT(int, uint, uint) public static extern void glUniform2uiEXT(int location, uint v0, uint v1) Parameters location int v0 uint v1 uint glUniform2uiv(int, int, uint*) public static extern void glUniform2uiv(int location, int count, uint* value) Parameters location int count int value uint* glUniform2uivEXT(int, int, uint*) public static extern void glUniform2uivEXT(int location, int count, uint* value) Parameters location int count int value uint* glUniform3d(int, double, double, double) public static extern void glUniform3d(int location, double x, double y, double z) Parameters location int x double y double z double glUniform3dv(int, int, double*) public static extern void glUniform3dv(int location, int count, double* value) Parameters location int count int value double* glUniform3f(int, float, float, float) public static extern void glUniform3f(int location, float v0, float v1, float v2) Parameters location int v0 float v1 float v2 float glUniform3fARB(int, float, float, float) public static extern void glUniform3fARB(int location, float v0, float v1, float v2) Parameters location int v0 float v1 float v2 float glUniform3fv(int, int, float*) public static extern void glUniform3fv(int location, int count, float* value) Parameters location int count int value float* glUniform3fvARB(int, int, float*) public static extern void glUniform3fvARB(int location, int count, float* value) Parameters location int count int value float* glUniform3i(int, int, int, int) public static extern void glUniform3i(int location, int v0, int v1, int v2) Parameters location int v0 int v1 int v2 int glUniform3i64NV(int, long, long, long) public static extern void glUniform3i64NV(int location, long x, long y, long z) Parameters location int x long y long z long glUniform3i64vNV(int, int, long*) public static extern void glUniform3i64vNV(int location, int count, long* value) Parameters location int count int value long* glUniform3iARB(int, int, int, int) public static extern void glUniform3iARB(int location, int v0, int v1, int v2) Parameters location int v0 int v1 int v2 int glUniform3iv(int, int, int*) public static extern void glUniform3iv(int location, int count, int* value) Parameters location int count int value int* glUniform3ivARB(int, int, int*) public static extern void glUniform3ivARB(int location, int count, int* value) Parameters location int count int value int* glUniform3ui(int, uint, uint, uint) public static extern void glUniform3ui(int location, uint v0, uint v1, uint v2) Parameters location int v0 uint v1 uint v2 uint glUniform3ui64NV(int, ulong, ulong, ulong) public static extern void glUniform3ui64NV(int location, ulong x, ulong y, ulong z) Parameters location int x ulong y ulong z ulong glUniform3ui64vNV(int, int, ulong*) public static extern void glUniform3ui64vNV(int location, int count, ulong* value) Parameters location int count int value ulong* glUniform3uiEXT(int, uint, uint, uint) public static extern void glUniform3uiEXT(int location, uint v0, uint v1, uint v2) Parameters location int v0 uint v1 uint v2 uint glUniform3uiv(int, int, uint*) public static extern void glUniform3uiv(int location, int count, uint* value) Parameters location int count int value uint* glUniform3uivEXT(int, int, uint*) public static extern void glUniform3uivEXT(int location, int count, uint* value) Parameters location int count int value uint* glUniform4d(int, double, double, double, double) public static extern void glUniform4d(int location, double x, double y, double z, double w) Parameters location int x double y double z double w double glUniform4dv(int, int, double*) public static extern void glUniform4dv(int location, int count, double* value) Parameters location int count int value double* glUniform4f(int, float, float, float, float) public static extern void glUniform4f(int location, float v0, float v1, float v2, float v3) Parameters location int v0 float v1 float v2 float v3 float glUniform4fARB(int, float, float, float, float) public static extern void glUniform4fARB(int location, float v0, float v1, float v2, float v3) Parameters location int v0 float v1 float v2 float v3 float glUniform4fv(int, int, float*) public static extern void glUniform4fv(int location, int count, float* value) Parameters location int count int value float* glUniform4fvARB(int, int, float*) public static extern void glUniform4fvARB(int location, int count, float* value) Parameters location int count int value float* glUniform4i(int, int, int, int, int) public static extern void glUniform4i(int location, int v0, int v1, int v2, int v3) Parameters location int v0 int v1 int v2 int v3 int glUniform4i64NV(int, long, long, long, long) public static extern void glUniform4i64NV(int location, long x, long y, long z, long w) Parameters location int x long y long z long w long glUniform4i64vNV(int, int, long*) public static extern void glUniform4i64vNV(int location, int count, long* value) Parameters location int count int value long* glUniform4iARB(int, int, int, int, int) public static extern void glUniform4iARB(int location, int v0, int v1, int v2, int v3) Parameters location int v0 int v1 int v2 int v3 int glUniform4iv(int, int, int*) public static extern void glUniform4iv(int location, int count, int* value) Parameters location int count int value int* glUniform4ivARB(int, int, int*) public static extern void glUniform4ivARB(int location, int count, int* value) Parameters location int count int value int* glUniform4ui(int, uint, uint, uint, uint) public static extern void glUniform4ui(int location, uint v0, uint v1, uint v2, uint v3) Parameters location int v0 uint v1 uint v2 uint v3 uint glUniform4ui64NV(int, ulong, ulong, ulong, ulong) public static extern void glUniform4ui64NV(int location, ulong x, ulong y, ulong z, ulong w) Parameters location int x ulong y ulong z ulong w ulong glUniform4ui64vNV(int, int, ulong*) public static extern void glUniform4ui64vNV(int location, int count, ulong* value) Parameters location int count int value ulong* glUniform4uiEXT(int, uint, uint, uint, uint) public static extern void glUniform4uiEXT(int location, uint v0, uint v1, uint v2, uint v3) Parameters location int v0 uint v1 uint v2 uint v3 uint glUniform4uiv(int, int, uint*) public static extern void glUniform4uiv(int location, int count, uint* value) Parameters location int count int value uint* glUniform4uivEXT(int, int, uint*) public static extern void glUniform4uivEXT(int location, int count, uint* value) Parameters location int count int value uint* glUniformBlockBinding(uint, uint, uint) public static extern void glUniformBlockBinding(uint program, uint uniformBlockIndex, uint uniformBlockBinding) Parameters program uint uniformBlockIndex uint uniformBlockBinding uint glUniformBufferEXT(uint, int, uint) public static extern void glUniformBufferEXT(uint program, int location, uint buffer) Parameters program uint location int buffer uint glUniformMatrix2dv(int, int, bool, double*) public static extern void glUniformMatrix2dv(int location, int count, bool transpose, double* value) Parameters location int count int transpose bool value double* glUniformMatrix2fv(int, int, bool, float*) public static extern void glUniformMatrix2fv(int location, int count, bool transpose, float* value) Parameters location int count int transpose bool value float* glUniformMatrix2fvARB(int, int, bool, float*) public static extern void glUniformMatrix2fvARB(int location, int count, bool transpose, float* value) Parameters location int count int transpose bool value float* glUniformMatrix2x3dv(int, int, bool, double*) public static extern void glUniformMatrix2x3dv(int location, int count, bool transpose, double* value) Parameters location int count int transpose bool value double* glUniformMatrix2x3fv(int, int, bool, float*) public static extern void glUniformMatrix2x3fv(int location, int count, bool transpose, float* value) Parameters location int count int transpose bool value float* glUniformMatrix2x4dv(int, int, bool, double*) public static extern void glUniformMatrix2x4dv(int location, int count, bool transpose, double* value) Parameters location int count int transpose bool value double* glUniformMatrix2x4fv(int, int, bool, float*) public static extern void glUniformMatrix2x4fv(int location, int count, bool transpose, float* value) Parameters location int count int transpose bool value float* glUniformMatrix3dv(int, int, bool, double*) public static extern void glUniformMatrix3dv(int location, int count, bool transpose, double* value) Parameters location int count int transpose bool value double* glUniformMatrix3fv(int, int, bool, float*) public static extern void glUniformMatrix3fv(int location, int count, bool transpose, float* value) Parameters location int count int transpose bool value float* glUniformMatrix3fvARB(int, int, bool, float*) public static extern void glUniformMatrix3fvARB(int location, int count, bool transpose, float* value) Parameters location int count int transpose bool value float* glUniformMatrix3x2dv(int, int, bool, double*) public static extern void glUniformMatrix3x2dv(int location, int count, bool transpose, double* value) Parameters location int count int transpose bool value double* glUniformMatrix3x2fv(int, int, bool, float*) public static extern void glUniformMatrix3x2fv(int location, int count, bool transpose, float* value) Parameters location int count int transpose bool value float* glUniformMatrix3x4dv(int, int, bool, double*) public static extern void glUniformMatrix3x4dv(int location, int count, bool transpose, double* value) Parameters location int count int transpose bool value double* glUniformMatrix3x4fv(int, int, bool, float*) public static extern void glUniformMatrix3x4fv(int location, int count, bool transpose, float* value) Parameters location int count int transpose bool value float* glUniformMatrix4dv(int, int, bool, double*) public static extern void glUniformMatrix4dv(int location, int count, bool transpose, double* value) Parameters location int count int transpose bool value double* glUniformMatrix4fv(int, int, bool, float*) public static extern void glUniformMatrix4fv(int location, int count, bool transpose, float* value) Parameters location int count int transpose bool value float* glUniformMatrix4fvARB(int, int, bool, float*) public static extern void glUniformMatrix4fvARB(int location, int count, bool transpose, float* value) Parameters location int count int transpose bool value float* glUniformMatrix4x2dv(int, int, bool, double*) public static extern void glUniformMatrix4x2dv(int location, int count, bool transpose, double* value) Parameters location int count int transpose bool value double* glUniformMatrix4x2fv(int, int, bool, float*) public static extern void glUniformMatrix4x2fv(int location, int count, bool transpose, float* value) Parameters location int count int transpose bool value float* glUniformMatrix4x3dv(int, int, bool, double*) public static extern void glUniformMatrix4x3dv(int location, int count, bool transpose, double* value) Parameters location int count int transpose bool value double* glUniformMatrix4x3fv(int, int, bool, float*) public static extern void glUniformMatrix4x3fv(int location, int count, bool transpose, float* value) Parameters location int count int transpose bool value float* glUniformSubroutinesuiv(uint, int, uint*) public static extern void glUniformSubroutinesuiv(uint shadertype, int count, uint* indices) Parameters shadertype uint count int indices uint* glUniformui64NV(int, ulong) public static extern void glUniformui64NV(int location, ulong value) Parameters location int value ulong glUniformui64vNV(int, int, ulong*) public static extern void glUniformui64vNV(int location, int count, ulong* value) Parameters location int count int value ulong* glUnlockArraysEXT() public static extern void glUnlockArraysEXT() glUnmapBuffer(uint) public static extern int glUnmapBuffer(uint target) Parameters target uint Returns int glUnmapBufferARB(uint) public static extern int glUnmapBufferARB(uint target) Parameters target uint Returns int glUnmapNamedBufferEXT(uint) public static extern int glUnmapNamedBufferEXT(uint buffer) Parameters buffer uint Returns int glUnmapObjectBufferATI(uint) public static extern void glUnmapObjectBufferATI(uint buffer) Parameters buffer uint glUpdateObjectBufferATI(uint, uint, int, nint, uint) public static extern void glUpdateObjectBufferATI(uint buffer, uint offset, int size, nint pointer, uint preserve) Parameters buffer uint offset uint size int pointer nint preserve uint glUseProgram(uint) public static extern void glUseProgram(uint program) Parameters program uint glUseProgramObjectARB(uint) public static extern void glUseProgramObjectARB(uint programObj) Parameters programObj uint glUseProgramStages(uint, uint, uint) public static extern void glUseProgramStages(uint pipeline, uint stages, uint program) Parameters pipeline uint stages uint program uint glUseShaderProgramEXT(uint, uint) public static extern void glUseShaderProgramEXT(uint type, uint program) Parameters type uint program uint glVDPAUFiniNV() public static extern void glVDPAUFiniNV() glVDPAUGetSurfaceivNV(nint, uint, int, int*, int*) public static extern void glVDPAUGetSurfaceivNV(nint surface, uint pname, int bufSize, int* length, int* values) Parameters surface nint pname uint bufSize int length int* values int* glVDPAUInitNV(nint, nint) public static extern void glVDPAUInitNV(nint vdpDevice, nint getProcAddress) Parameters vdpDevice nint getProcAddress nint glVDPAUIsSurfaceNV(nint) public static extern void glVDPAUIsSurfaceNV(nint surface) Parameters surface nint glVDPAUMapSurfacesNV(int, nint*) public static extern void glVDPAUMapSurfacesNV(int numSurfaces, nint* surfaces) Parameters numSurfaces int surfaces nint* glVDPAURegisterOutputSurfaceNV(nint, uint, int, uint*) public static extern nint glVDPAURegisterOutputSurfaceNV(nint vdpSurface, uint target, int numTextureNames, uint* textureNames) Parameters vdpSurface nint target uint numTextureNames int textureNames uint* Returns nint glVDPAURegisterVideoSurfaceNV(nint, uint, int, uint*) public static extern nint glVDPAURegisterVideoSurfaceNV(nint vdpSurface, uint target, int numTextureNames, uint* textureNames) Parameters vdpSurface nint target uint numTextureNames int textureNames uint* Returns nint glVDPAUSurfaceAccessNV(nint, uint) public static extern void glVDPAUSurfaceAccessNV(nint surface, uint access) Parameters surface nint access uint glVDPAUUnmapSurfacesNV(int, nint*) public static extern void glVDPAUUnmapSurfacesNV(int numSurface, nint* surfaces) Parameters numSurface int surfaces nint* glVDPAUUnregisterSurfaceNV(nint) public static extern void glVDPAUUnregisterSurfaceNV(nint surface) Parameters surface nint glValidateProgram(uint) public static extern void glValidateProgram(uint program) Parameters program uint glValidateProgramARB(uint) public static extern void glValidateProgramARB(uint programObj) Parameters programObj uint glValidateProgramPipeline(uint) public static extern void glValidateProgramPipeline(uint pipeline) Parameters pipeline uint glVertexArrayVertexAttribLOffsetEXT(uint, uint, uint, int, uint, int, nint) public static extern void glVertexArrayVertexAttribLOffsetEXT(uint vaobj, uint buffer, uint index, int size, uint type, int stride, nint offset) Parameters vaobj uint buffer uint index uint size int type uint stride int offset nint glVertexAttrib1d(uint, double) public static extern void glVertexAttrib1d(uint index, double x) Parameters index uint x double glVertexAttrib1dARB(uint, double) public static extern void glVertexAttrib1dARB(uint index, double x) Parameters index uint x double glVertexAttrib1dNV(uint, double) public static extern void glVertexAttrib1dNV(uint index, double x) Parameters index uint x double glVertexAttrib1dv(uint, double*) public static extern void glVertexAttrib1dv(uint index, double* v) Parameters index uint v double* glVertexAttrib1dvARB(uint, double*) public static extern void glVertexAttrib1dvARB(uint index, double* v) Parameters index uint v double* glVertexAttrib1dvNV(uint, double*) public static extern void glVertexAttrib1dvNV(uint index, double* v) Parameters index uint v double* glVertexAttrib1f(uint, float) public static extern void glVertexAttrib1f(uint index, float x) Parameters index uint x float glVertexAttrib1fARB(uint, float) public static extern void glVertexAttrib1fARB(uint index, float x) Parameters index uint x float glVertexAttrib1fNV(uint, float) public static extern void glVertexAttrib1fNV(uint index, float x) Parameters index uint x float glVertexAttrib1fv(uint, float*) public static extern void glVertexAttrib1fv(uint index, float* v) Parameters index uint v float* glVertexAttrib1fvARB(uint, float*) public static extern void glVertexAttrib1fvARB(uint index, float* v) Parameters index uint v float* glVertexAttrib1fvNV(uint, float*) public static extern void glVertexAttrib1fvNV(uint index, float* v) Parameters index uint v float* glVertexAttrib1hNV(uint, ushort) public static extern void glVertexAttrib1hNV(uint index, ushort x) Parameters index uint x ushort glVertexAttrib1hvNV(uint, ushort*) public static extern void glVertexAttrib1hvNV(uint index, ushort* v) Parameters index uint v ushort* glVertexAttrib1s(uint, short) public static extern void glVertexAttrib1s(uint index, short x) Parameters index uint x short glVertexAttrib1sARB(uint, short) public static extern void glVertexAttrib1sARB(uint index, short x) Parameters index uint x short glVertexAttrib1sNV(uint, short) public static extern void glVertexAttrib1sNV(uint index, short x) Parameters index uint x short glVertexAttrib1sv(uint, short*) public static extern void glVertexAttrib1sv(uint index, short* v) Parameters index uint v short* glVertexAttrib1svARB(uint, short*) public static extern void glVertexAttrib1svARB(uint index, short* v) Parameters index uint v short* glVertexAttrib1svNV(uint, short*) public static extern void glVertexAttrib1svNV(uint index, short* v) Parameters index uint v short* glVertexAttrib2d(uint, double, double) public static extern void glVertexAttrib2d(uint index, double x, double y) Parameters index uint x double y double glVertexAttrib2dARB(uint, double, double) public static extern void glVertexAttrib2dARB(uint index, double x, double y) Parameters index uint x double y double glVertexAttrib2dNV(uint, double, double) public static extern void glVertexAttrib2dNV(uint index, double x, double y) Parameters index uint x double y double glVertexAttrib2dv(uint, double*) public static extern void glVertexAttrib2dv(uint index, double* v) Parameters index uint v double* glVertexAttrib2dvARB(uint, double*) public static extern void glVertexAttrib2dvARB(uint index, double* v) Parameters index uint v double* glVertexAttrib2dvNV(uint, double*) public static extern void glVertexAttrib2dvNV(uint index, double* v) Parameters index uint v double* glVertexAttrib2f(uint, float, float) public static extern void glVertexAttrib2f(uint index, float x, float y) Parameters index uint x float y float glVertexAttrib2fARB(uint, float, float) public static extern void glVertexAttrib2fARB(uint index, float x, float y) Parameters index uint x float y float glVertexAttrib2fNV(uint, float, float) public static extern void glVertexAttrib2fNV(uint index, float x, float y) Parameters index uint x float y float glVertexAttrib2fv(uint, float*) public static extern void glVertexAttrib2fv(uint index, float* v) Parameters index uint v float* glVertexAttrib2fvARB(uint, float*) public static extern void glVertexAttrib2fvARB(uint index, float* v) Parameters index uint v float* glVertexAttrib2fvNV(uint, float*) public static extern void glVertexAttrib2fvNV(uint index, float* v) Parameters index uint v float* glVertexAttrib2hNV(uint, ushort, ushort) public static extern void glVertexAttrib2hNV(uint index, ushort x, ushort y) Parameters index uint x ushort y ushort glVertexAttrib2hvNV(uint, ushort*) public static extern void glVertexAttrib2hvNV(uint index, ushort* v) Parameters index uint v ushort* glVertexAttrib2s(uint, short, short) public static extern void glVertexAttrib2s(uint index, short x, short y) Parameters index uint x short y short glVertexAttrib2sARB(uint, short, short) public static extern void glVertexAttrib2sARB(uint index, short x, short y) Parameters index uint x short y short glVertexAttrib2sNV(uint, short, short) public static extern void glVertexAttrib2sNV(uint index, short x, short y) Parameters index uint x short y short glVertexAttrib2sv(uint, short*) public static extern void glVertexAttrib2sv(uint index, short* v) Parameters index uint v short* glVertexAttrib2svARB(uint, short*) public static extern void glVertexAttrib2svARB(uint index, short* v) Parameters index uint v short* glVertexAttrib2svNV(uint, short*) public static extern void glVertexAttrib2svNV(uint index, short* v) Parameters index uint v short* glVertexAttrib3d(uint, double, double, double) public static extern void glVertexAttrib3d(uint index, double x, double y, double z) Parameters index uint x double y double z double glVertexAttrib3dARB(uint, double, double, double) public static extern void glVertexAttrib3dARB(uint index, double x, double y, double z) Parameters index uint x double y double z double glVertexAttrib3dNV(uint, double, double, double) public static extern void glVertexAttrib3dNV(uint index, double x, double y, double z) Parameters index uint x double y double z double glVertexAttrib3dv(uint, double*) public static extern void glVertexAttrib3dv(uint index, double* v) Parameters index uint v double* glVertexAttrib3dvARB(uint, double*) public static extern void glVertexAttrib3dvARB(uint index, double* v) Parameters index uint v double* glVertexAttrib3dvNV(uint, double*) public static extern void glVertexAttrib3dvNV(uint index, double* v) Parameters index uint v double* glVertexAttrib3f(uint, float, float, float) public static extern void glVertexAttrib3f(uint index, float x, float y, float z) Parameters index uint x float y float z float glVertexAttrib3fARB(uint, float, float, float) public static extern void glVertexAttrib3fARB(uint index, float x, float y, float z) Parameters index uint x float y float z float glVertexAttrib3fNV(uint, float, float, float) public static extern void glVertexAttrib3fNV(uint index, float x, float y, float z) Parameters index uint x float y float z float glVertexAttrib3fv(uint, float*) public static extern void glVertexAttrib3fv(uint index, float* v) Parameters index uint v float* glVertexAttrib3fvARB(uint, float*) public static extern void glVertexAttrib3fvARB(uint index, float* v) Parameters index uint v float* glVertexAttrib3fvNV(uint, float*) public static extern void glVertexAttrib3fvNV(uint index, float* v) Parameters index uint v float* glVertexAttrib3hNV(uint, ushort, ushort, ushort) public static extern void glVertexAttrib3hNV(uint index, ushort x, ushort y, ushort z) Parameters index uint x ushort y ushort z ushort glVertexAttrib3hvNV(uint, ushort*) public static extern void glVertexAttrib3hvNV(uint index, ushort* v) Parameters index uint v ushort* glVertexAttrib3s(uint, short, short, short) public static extern void glVertexAttrib3s(uint index, short x, short y, short z) Parameters index uint x short y short z short glVertexAttrib3sARB(uint, short, short, short) public static extern void glVertexAttrib3sARB(uint index, short x, short y, short z) Parameters index uint x short y short z short glVertexAttrib3sNV(uint, short, short, short) public static extern void glVertexAttrib3sNV(uint index, short x, short y, short z) Parameters index uint x short y short z short glVertexAttrib3sv(uint, short*) public static extern void glVertexAttrib3sv(uint index, short* v) Parameters index uint v short* glVertexAttrib3svARB(uint, short*) public static extern void glVertexAttrib3svARB(uint index, short* v) Parameters index uint v short* glVertexAttrib3svNV(uint, short*) public static extern void glVertexAttrib3svNV(uint index, short* v) Parameters index uint v short* glVertexAttrib4Nbv(uint, sbyte*) public static extern void glVertexAttrib4Nbv(uint index, sbyte* v) Parameters index uint v sbyte* glVertexAttrib4NbvARB(uint, sbyte*) public static extern void glVertexAttrib4NbvARB(uint index, sbyte* v) Parameters index uint v sbyte* glVertexAttrib4Niv(uint, int*) public static extern void glVertexAttrib4Niv(uint index, int* v) Parameters index uint v int* glVertexAttrib4NivARB(uint, int*) public static extern void glVertexAttrib4NivARB(uint index, int* v) Parameters index uint v int* glVertexAttrib4Nsv(uint, short*) public static extern void glVertexAttrib4Nsv(uint index, short* v) Parameters index uint v short* glVertexAttrib4NsvARB(uint, short*) public static extern void glVertexAttrib4NsvARB(uint index, short* v) Parameters index uint v short* glVertexAttrib4Nub(uint, byte, byte, byte, byte) public static extern void glVertexAttrib4Nub(uint index, byte x, byte y, byte z, byte w) Parameters index uint x byte y byte z byte w byte glVertexAttrib4NubARB(uint, byte, byte, byte, byte) public static extern void glVertexAttrib4NubARB(uint index, byte x, byte y, byte z, byte w) Parameters index uint x byte y byte z byte w byte glVertexAttrib4Nubv(uint, byte*) public static extern void glVertexAttrib4Nubv(uint index, byte* v) Parameters index uint v byte* glVertexAttrib4NubvARB(uint, byte*) public static extern void glVertexAttrib4NubvARB(uint index, byte* v) Parameters index uint v byte* glVertexAttrib4Nuiv(uint, uint*) public static extern void glVertexAttrib4Nuiv(uint index, uint* v) Parameters index uint v uint* glVertexAttrib4NuivARB(uint, uint*) public static extern void glVertexAttrib4NuivARB(uint index, uint* v) Parameters index uint v uint* glVertexAttrib4Nusv(uint, ushort*) public static extern void glVertexAttrib4Nusv(uint index, ushort* v) Parameters index uint v ushort* glVertexAttrib4NusvARB(uint, ushort*) public static extern void glVertexAttrib4NusvARB(uint index, ushort* v) Parameters index uint v ushort* glVertexAttrib4bv(uint, sbyte*) public static extern void glVertexAttrib4bv(uint index, sbyte* v) Parameters index uint v sbyte* glVertexAttrib4bvARB(uint, sbyte*) public static extern void glVertexAttrib4bvARB(uint index, sbyte* v) Parameters index uint v sbyte* glVertexAttrib4d(uint, double, double, double, double) public static extern void glVertexAttrib4d(uint index, double x, double y, double z, double w) Parameters index uint x double y double z double w double glVertexAttrib4dARB(uint, double, double, double, double) public static extern void glVertexAttrib4dARB(uint index, double x, double y, double z, double w) Parameters index uint x double y double z double w double glVertexAttrib4dNV(uint, double, double, double, double) public static extern void glVertexAttrib4dNV(uint index, double x, double y, double z, double w) Parameters index uint x double y double z double w double glVertexAttrib4dv(uint, double*) public static extern void glVertexAttrib4dv(uint index, double* v) Parameters index uint v double* glVertexAttrib4dvARB(uint, double*) public static extern void glVertexAttrib4dvARB(uint index, double* v) Parameters index uint v double* glVertexAttrib4dvNV(uint, double*) public static extern void glVertexAttrib4dvNV(uint index, double* v) Parameters index uint v double* glVertexAttrib4f(uint, float, float, float, float) public static extern void glVertexAttrib4f(uint index, float x, float y, float z, float w) Parameters index uint x float y float z float w float glVertexAttrib4fARB(uint, float, float, float, float) public static extern void glVertexAttrib4fARB(uint index, float x, float y, float z, float w) Parameters index uint x float y float z float w float glVertexAttrib4fNV(uint, float, float, float, float) public static extern void glVertexAttrib4fNV(uint index, float x, float y, float z, float w) Parameters index uint x float y float z float w float glVertexAttrib4fv(uint, float*) public static extern void glVertexAttrib4fv(uint index, float* v) Parameters index uint v float* glVertexAttrib4fvARB(uint, float*) public static extern void glVertexAttrib4fvARB(uint index, float* v) Parameters index uint v float* glVertexAttrib4fvNV(uint, float*) public static extern void glVertexAttrib4fvNV(uint index, float* v) Parameters index uint v float* glVertexAttrib4hNV(uint, ushort, ushort, ushort, ushort) public static extern void glVertexAttrib4hNV(uint index, ushort x, ushort y, ushort z, ushort w) Parameters index uint x ushort y ushort z ushort w ushort glVertexAttrib4hvNV(uint, ushort*) public static extern void glVertexAttrib4hvNV(uint index, ushort* v) Parameters index uint v ushort* glVertexAttrib4iv(uint, int*) public static extern void glVertexAttrib4iv(uint index, int* v) Parameters index uint v int* glVertexAttrib4ivARB(uint, int*) public static extern void glVertexAttrib4ivARB(uint index, int* v) Parameters index uint v int* glVertexAttrib4s(uint, short, short, short, short) public static extern void glVertexAttrib4s(uint index, short x, short y, short z, short w) Parameters index uint x short y short z short w short glVertexAttrib4sARB(uint, short, short, short, short) public static extern void glVertexAttrib4sARB(uint index, short x, short y, short z, short w) Parameters index uint x short y short z short w short glVertexAttrib4sNV(uint, short, short, short, short) public static extern void glVertexAttrib4sNV(uint index, short x, short y, short z, short w) Parameters index uint x short y short z short w short glVertexAttrib4sv(uint, short*) public static extern void glVertexAttrib4sv(uint index, short* v) Parameters index uint v short* glVertexAttrib4svARB(uint, short*) public static extern void glVertexAttrib4svARB(uint index, short* v) Parameters index uint v short* glVertexAttrib4svNV(uint, short*) public static extern void glVertexAttrib4svNV(uint index, short* v) Parameters index uint v short* glVertexAttrib4ubNV(uint, byte, byte, byte, byte) public static extern void glVertexAttrib4ubNV(uint index, byte x, byte y, byte z, byte w) Parameters index uint x byte y byte z byte w byte glVertexAttrib4ubv(uint, byte*) public static extern void glVertexAttrib4ubv(uint index, byte* v) Parameters index uint v byte* glVertexAttrib4ubvARB(uint, byte*) public static extern void glVertexAttrib4ubvARB(uint index, byte* v) Parameters index uint v byte* glVertexAttrib4ubvNV(uint, byte*) public static extern void glVertexAttrib4ubvNV(uint index, byte* v) Parameters index uint v byte* glVertexAttrib4uiv(uint, uint*) public static extern void glVertexAttrib4uiv(uint index, uint* v) Parameters index uint v uint* glVertexAttrib4uivARB(uint, uint*) public static extern void glVertexAttrib4uivARB(uint index, uint* v) Parameters index uint v uint* glVertexAttrib4usv(uint, ushort*) public static extern void glVertexAttrib4usv(uint index, ushort* v) Parameters index uint v ushort* glVertexAttrib4usvARB(uint, ushort*) public static extern void glVertexAttrib4usvARB(uint index, ushort* v) Parameters index uint v ushort* glVertexAttribArrayObjectATI(uint, int, uint, bool, int, uint, uint) public static extern void glVertexAttribArrayObjectATI(uint index, int size, uint type, bool normalized, int stride, uint buffer, uint offset) Parameters index uint size int type uint normalized bool stride int buffer uint offset uint glVertexAttribDivisor(uint, uint) public static extern void glVertexAttribDivisor(uint index, uint divisor) Parameters index uint divisor uint glVertexAttribDivisorARB(uint, uint) public static extern void glVertexAttribDivisorARB(uint index, uint divisor) Parameters index uint divisor uint glVertexAttribFormatNV(uint, int, uint, bool, int) public static extern void glVertexAttribFormatNV(uint index, int size, uint type, bool normalized, int stride) Parameters index uint size int type uint normalized bool stride int glVertexAttribI1i(uint, int) public static extern void glVertexAttribI1i(uint index, int x) Parameters index uint x int glVertexAttribI1iEXT(uint, int) public static extern void glVertexAttribI1iEXT(uint index, int x) Parameters index uint x int glVertexAttribI1iv(uint, int*) public static extern void glVertexAttribI1iv(uint index, int* v) Parameters index uint v int* glVertexAttribI1ivEXT(uint, int*) public static extern void glVertexAttribI1ivEXT(uint index, int* v) Parameters index uint v int* glVertexAttribI1ui(uint, uint) public static extern void glVertexAttribI1ui(uint index, uint x) Parameters index uint x uint glVertexAttribI1uiEXT(uint, uint) public static extern void glVertexAttribI1uiEXT(uint index, uint x) Parameters index uint x uint glVertexAttribI1uiv(uint, uint*) public static extern void glVertexAttribI1uiv(uint index, uint* v) Parameters index uint v uint* glVertexAttribI1uivEXT(uint, uint*) public static extern void glVertexAttribI1uivEXT(uint index, uint* v) Parameters index uint v uint* glVertexAttribI2i(uint, int, int) public static extern void glVertexAttribI2i(uint index, int x, int y) Parameters index uint x int y int glVertexAttribI2iEXT(uint, int, int) public static extern void glVertexAttribI2iEXT(uint index, int x, int y) Parameters index uint x int y int glVertexAttribI2iv(uint, int*) public static extern void glVertexAttribI2iv(uint index, int* v) Parameters index uint v int* glVertexAttribI2ivEXT(uint, int*) public static extern void glVertexAttribI2ivEXT(uint index, int* v) Parameters index uint v int* glVertexAttribI2ui(uint, uint, uint) public static extern void glVertexAttribI2ui(uint index, uint x, uint y) Parameters index uint x uint y uint glVertexAttribI2uiEXT(uint, uint, uint) public static extern void glVertexAttribI2uiEXT(uint index, uint x, uint y) Parameters index uint x uint y uint glVertexAttribI2uiv(uint, uint*) public static extern void glVertexAttribI2uiv(uint index, uint* v) Parameters index uint v uint* glVertexAttribI2uivEXT(uint, uint*) public static extern void glVertexAttribI2uivEXT(uint index, uint* v) Parameters index uint v uint* glVertexAttribI3i(uint, int, int, int) public static extern void glVertexAttribI3i(uint index, int x, int y, int z) Parameters index uint x int y int z int glVertexAttribI3iEXT(uint, int, int, int) public static extern void glVertexAttribI3iEXT(uint index, int x, int y, int z) Parameters index uint x int y int z int glVertexAttribI3iv(uint, int*) public static extern void glVertexAttribI3iv(uint index, int* v) Parameters index uint v int* glVertexAttribI3ivEXT(uint, int*) public static extern void glVertexAttribI3ivEXT(uint index, int* v) Parameters index uint v int* glVertexAttribI3ui(uint, uint, uint, uint) public static extern void glVertexAttribI3ui(uint index, uint x, uint y, uint z) Parameters index uint x uint y uint z uint glVertexAttribI3uiEXT(uint, uint, uint, uint) public static extern void glVertexAttribI3uiEXT(uint index, uint x, uint y, uint z) Parameters index uint x uint y uint z uint glVertexAttribI3uiv(uint, uint*) public static extern void glVertexAttribI3uiv(uint index, uint* v) Parameters index uint v uint* glVertexAttribI3uivEXT(uint, uint*) public static extern void glVertexAttribI3uivEXT(uint index, uint* v) Parameters index uint v uint* glVertexAttribI4bv(uint, sbyte*) public static extern void glVertexAttribI4bv(uint index, sbyte* v) Parameters index uint v sbyte* glVertexAttribI4bvEXT(uint, sbyte*) public static extern void glVertexAttribI4bvEXT(uint index, sbyte* v) Parameters index uint v sbyte* glVertexAttribI4i(uint, int, int, int, int) public static extern void glVertexAttribI4i(uint index, int x, int y, int z, int w) Parameters index uint x int y int z int w int glVertexAttribI4iEXT(uint, int, int, int, int) public static extern void glVertexAttribI4iEXT(uint index, int x, int y, int z, int w) Parameters index uint x int y int z int w int glVertexAttribI4iv(uint, int*) public static extern void glVertexAttribI4iv(uint index, int* v) Parameters index uint v int* glVertexAttribI4ivEXT(uint, int*) public static extern void glVertexAttribI4ivEXT(uint index, int* v) Parameters index uint v int* glVertexAttribI4sv(uint, short*) public static extern void glVertexAttribI4sv(uint index, short* v) Parameters index uint v short* glVertexAttribI4svEXT(uint, short*) public static extern void glVertexAttribI4svEXT(uint index, short* v) Parameters index uint v short* glVertexAttribI4ubv(uint, byte*) public static extern void glVertexAttribI4ubv(uint index, byte* v) Parameters index uint v byte* glVertexAttribI4ubvEXT(uint, byte*) public static extern void glVertexAttribI4ubvEXT(uint index, byte* v) Parameters index uint v byte* glVertexAttribI4ui(uint, uint, uint, uint, uint) public static extern void glVertexAttribI4ui(uint index, uint x, uint y, uint z, uint w) Parameters index uint x uint y uint z uint w uint glVertexAttribI4uiEXT(uint, uint, uint, uint, uint) public static extern void glVertexAttribI4uiEXT(uint index, uint x, uint y, uint z, uint w) Parameters index uint x uint y uint z uint w uint glVertexAttribI4uiv(uint, uint*) public static extern void glVertexAttribI4uiv(uint index, uint* v) Parameters index uint v uint* glVertexAttribI4uivEXT(uint, uint*) public static extern void glVertexAttribI4uivEXT(uint index, uint* v) Parameters index uint v uint* glVertexAttribI4usv(uint, ushort*) public static extern void glVertexAttribI4usv(uint index, ushort* v) Parameters index uint v ushort* glVertexAttribI4usvEXT(uint, ushort*) public static extern void glVertexAttribI4usvEXT(uint index, ushort* v) Parameters index uint v ushort* glVertexAttribIFormatNV(uint, int, uint, int) public static extern void glVertexAttribIFormatNV(uint index, int size, uint type, int stride) Parameters index uint size int type uint stride int glVertexAttribIPointer(uint, int, uint, int, nint) public static extern void glVertexAttribIPointer(uint index, int size, uint type, int stride, nint pointer) Parameters index uint size int type uint stride int pointer nint glVertexAttribIPointerEXT(uint, int, uint, int, nint) public static extern void glVertexAttribIPointerEXT(uint index, int size, uint type, int stride, nint pointer) Parameters index uint size int type uint stride int pointer nint glVertexAttribL1d(uint, double) public static extern void glVertexAttribL1d(uint index, double x) Parameters index uint x double glVertexAttribL1dEXT(uint, double) public static extern void glVertexAttribL1dEXT(uint index, double x) Parameters index uint x double glVertexAttribL1dv(uint, double*) public static extern void glVertexAttribL1dv(uint index, double* v) Parameters index uint v double* glVertexAttribL1dvEXT(uint, double*) public static extern void glVertexAttribL1dvEXT(uint index, double* v) Parameters index uint v double* glVertexAttribL1i64NV(uint, long) public static extern void glVertexAttribL1i64NV(uint index, long x) Parameters index uint x long glVertexAttribL1i64vNV(uint, long*) public static extern void glVertexAttribL1i64vNV(uint index, long* v) Parameters index uint v long* glVertexAttribL1ui64NV(uint, ulong) public static extern void glVertexAttribL1ui64NV(uint index, ulong x) Parameters index uint x ulong glVertexAttribL1ui64vNV(uint, ulong*) public static extern void glVertexAttribL1ui64vNV(uint index, ulong* v) Parameters index uint v ulong* glVertexAttribL2d(uint, double, double) public static extern void glVertexAttribL2d(uint index, double x, double y) Parameters index uint x double y double glVertexAttribL2dEXT(uint, double, double) public static extern void glVertexAttribL2dEXT(uint index, double x, double y) Parameters index uint x double y double glVertexAttribL2dv(uint, double*) public static extern void glVertexAttribL2dv(uint index, double* v) Parameters index uint v double* glVertexAttribL2dvEXT(uint, double*) public static extern void glVertexAttribL2dvEXT(uint index, double* v) Parameters index uint v double* glVertexAttribL2i64NV(uint, long, long) public static extern void glVertexAttribL2i64NV(uint index, long x, long y) Parameters index uint x long y long glVertexAttribL2i64vNV(uint, long*) public static extern void glVertexAttribL2i64vNV(uint index, long* v) Parameters index uint v long* glVertexAttribL2ui64NV(uint, ulong, ulong) public static extern void glVertexAttribL2ui64NV(uint index, ulong x, ulong y) Parameters index uint x ulong y ulong glVertexAttribL2ui64vNV(uint, ulong*) public static extern void glVertexAttribL2ui64vNV(uint index, ulong* v) Parameters index uint v ulong* glVertexAttribL3d(uint, double, double, double) public static extern void glVertexAttribL3d(uint index, double x, double y, double z) Parameters index uint x double y double z double glVertexAttribL3dEXT(uint, double, double, double) public static extern void glVertexAttribL3dEXT(uint index, double x, double y, double z) Parameters index uint x double y double z double glVertexAttribL3dv(uint, double*) public static extern void glVertexAttribL3dv(uint index, double* v) Parameters index uint v double* glVertexAttribL3dvEXT(uint, double*) public static extern void glVertexAttribL3dvEXT(uint index, double* v) Parameters index uint v double* glVertexAttribL3i64NV(uint, long, long, long) public static extern void glVertexAttribL3i64NV(uint index, long x, long y, long z) Parameters index uint x long y long z long glVertexAttribL3i64vNV(uint, long*) public static extern void glVertexAttribL3i64vNV(uint index, long* v) Parameters index uint v long* glVertexAttribL3ui64NV(uint, ulong, ulong, ulong) public static extern void glVertexAttribL3ui64NV(uint index, ulong x, ulong y, ulong z) Parameters index uint x ulong y ulong z ulong glVertexAttribL3ui64vNV(uint, ulong*) public static extern void glVertexAttribL3ui64vNV(uint index, ulong* v) Parameters index uint v ulong* glVertexAttribL4d(uint, double, double, double, double) public static extern void glVertexAttribL4d(uint index, double x, double y, double z, double w) Parameters index uint x double y double z double w double glVertexAttribL4dEXT(uint, double, double, double, double) public static extern void glVertexAttribL4dEXT(uint index, double x, double y, double z, double w) Parameters index uint x double y double z double w double glVertexAttribL4dv(uint, double*) public static extern void glVertexAttribL4dv(uint index, double* v) Parameters index uint v double* glVertexAttribL4dvEXT(uint, double*) public static extern void glVertexAttribL4dvEXT(uint index, double* v) Parameters index uint v double* glVertexAttribL4i64NV(uint, long, long, long, long) public static extern void glVertexAttribL4i64NV(uint index, long x, long y, long z, long w) Parameters index uint x long y long z long w long glVertexAttribL4i64vNV(uint, long*) public static extern void glVertexAttribL4i64vNV(uint index, long* v) Parameters index uint v long* glVertexAttribL4ui64NV(uint, ulong, ulong, ulong, ulong) public static extern void glVertexAttribL4ui64NV(uint index, ulong x, ulong y, ulong z, ulong w) Parameters index uint x ulong y ulong z ulong w ulong glVertexAttribL4ui64vNV(uint, ulong*) public static extern void glVertexAttribL4ui64vNV(uint index, ulong* v) Parameters index uint v ulong* glVertexAttribLFormatNV(uint, int, uint, int) public static extern void glVertexAttribLFormatNV(uint index, int size, uint type, int stride) Parameters index uint size int type uint stride int glVertexAttribLPointer(uint, int, uint, int, nint) public static extern void glVertexAttribLPointer(uint index, int size, uint type, int stride, nint pointer) Parameters index uint size int type uint stride int pointer nint glVertexAttribLPointerEXT(uint, int, uint, int, nint) public static extern void glVertexAttribLPointerEXT(uint index, int size, uint type, int stride, nint pointer) Parameters index uint size int type uint stride int pointer nint glVertexAttribP1ui(uint, uint, bool, uint) public static extern void glVertexAttribP1ui(uint index, uint type, bool normalized, uint value) Parameters index uint type uint normalized bool value uint glVertexAttribP1uiv(uint, uint, bool, uint*) public static extern void glVertexAttribP1uiv(uint index, uint type, bool normalized, uint* value) Parameters index uint type uint normalized bool value uint* glVertexAttribP2ui(uint, uint, bool, uint) public static extern void glVertexAttribP2ui(uint index, uint type, bool normalized, uint value) Parameters index uint type uint normalized bool value uint glVertexAttribP2uiv(uint, uint, bool, uint*) public static extern void glVertexAttribP2uiv(uint index, uint type, bool normalized, uint* value) Parameters index uint type uint normalized bool value uint* glVertexAttribP3ui(uint, uint, bool, uint) public static extern void glVertexAttribP3ui(uint index, uint type, bool normalized, uint value) Parameters index uint type uint normalized bool value uint glVertexAttribP3uiv(uint, uint, bool, uint*) public static extern void glVertexAttribP3uiv(uint index, uint type, bool normalized, uint* value) Parameters index uint type uint normalized bool value uint* glVertexAttribP4ui(uint, uint, bool, uint) public static extern void glVertexAttribP4ui(uint index, uint type, bool normalized, uint value) Parameters index uint type uint normalized bool value uint glVertexAttribP4uiv(uint, uint, bool, uint*) public static extern void glVertexAttribP4uiv(uint index, uint type, bool normalized, uint* value) Parameters index uint type uint normalized bool value uint* glVertexAttribPointer(uint, int, uint, bool, int, nint) public static extern void glVertexAttribPointer(uint index, int size, uint type, bool normalized, int stride, nint pointer) Parameters index uint size int type uint normalized bool stride int pointer nint glVertexAttribPointerARB(uint, int, uint, bool, int, nint) public static extern void glVertexAttribPointerARB(uint index, int size, uint type, bool normalized, int stride, nint pointer) Parameters index uint size int type uint normalized bool stride int pointer nint glVertexAttribPointerNV(uint, int, uint, int, nint) public static extern void glVertexAttribPointerNV(uint index, int fsize, uint type, int stride, nint pointer) Parameters index uint fsize int type uint stride int pointer nint glVertexAttribs1dvNV(uint, int, double*) public static extern void glVertexAttribs1dvNV(uint index, int count, double* v) Parameters index uint count int v double* glVertexAttribs1fvNV(uint, int, float*) public static extern void glVertexAttribs1fvNV(uint index, int count, float* v) Parameters index uint count int v float* glVertexAttribs1hvNV(uint, int, ushort*) public static extern void glVertexAttribs1hvNV(uint index, int n, ushort* v) Parameters index uint n int v ushort* glVertexAttribs1svNV(uint, int, short*) public static extern void glVertexAttribs1svNV(uint index, int count, short* v) Parameters index uint count int v short* glVertexAttribs2dvNV(uint, int, double*) public static extern void glVertexAttribs2dvNV(uint index, int count, double* v) Parameters index uint count int v double* glVertexAttribs2fvNV(uint, int, float*) public static extern void glVertexAttribs2fvNV(uint index, int count, float* v) Parameters index uint count int v float* glVertexAttribs2hvNV(uint, int, ushort*) public static extern void glVertexAttribs2hvNV(uint index, int n, ushort* v) Parameters index uint n int v ushort* glVertexAttribs2svNV(uint, int, short*) public static extern void glVertexAttribs2svNV(uint index, int count, short* v) Parameters index uint count int v short* glVertexAttribs3dvNV(uint, int, double*) public static extern void glVertexAttribs3dvNV(uint index, int count, double* v) Parameters index uint count int v double* glVertexAttribs3fvNV(uint, int, float*) public static extern void glVertexAttribs3fvNV(uint index, int count, float* v) Parameters index uint count int v float* glVertexAttribs3hvNV(uint, int, ushort*) public static extern void glVertexAttribs3hvNV(uint index, int n, ushort* v) Parameters index uint n int v ushort* glVertexAttribs3svNV(uint, int, short*) public static extern void glVertexAttribs3svNV(uint index, int count, short* v) Parameters index uint count int v short* glVertexAttribs4dvNV(uint, int, double*) public static extern void glVertexAttribs4dvNV(uint index, int count, double* v) Parameters index uint count int v double* glVertexAttribs4fvNV(uint, int, float*) public static extern void glVertexAttribs4fvNV(uint index, int count, float* v) Parameters index uint count int v float* glVertexAttribs4hvNV(uint, int, ushort*) public static extern void glVertexAttribs4hvNV(uint index, int n, ushort* v) Parameters index uint n int v ushort* glVertexAttribs4svNV(uint, int, short*) public static extern void glVertexAttribs4svNV(uint index, int count, short* v) Parameters index uint count int v short* glVertexAttribs4ubvNV(uint, int, byte*) public static extern void glVertexAttribs4ubvNV(uint index, int count, byte* v) Parameters index uint count int v byte* glVertexFormatNV(int, uint, int) public static extern void glVertexFormatNV(int size, uint type, int stride) Parameters size int type uint stride int glVertexPointerListIBM(int, uint, int, nint, int) public static extern void glVertexPointerListIBM(int size, uint type, int stride, nint pointer, int ptrstride) Parameters size int type uint stride int pointer nint ptrstride int glVertexPointervINTEL(int, uint, nint) public static extern void glVertexPointervINTEL(int size, uint type, nint pointer) Parameters size int type uint pointer nint glVertexStream1dATI(uint, double) public static extern void glVertexStream1dATI(uint stream, double x) Parameters stream uint x double glVertexStream1dvATI(uint, double*) public static extern void glVertexStream1dvATI(uint stream, double* coords) Parameters stream uint coords double* glVertexStream1fATI(uint, float) public static extern void glVertexStream1fATI(uint stream, float x) Parameters stream uint x float glVertexStream1fvATI(uint, float*) public static extern void glVertexStream1fvATI(uint stream, float* coords) Parameters stream uint coords float* glVertexStream1iATI(uint, int) public static extern void glVertexStream1iATI(uint stream, int x) Parameters stream uint x int glVertexStream1ivATI(uint, int*) public static extern void glVertexStream1ivATI(uint stream, int* coords) Parameters stream uint coords int* glVertexStream1sATI(uint, short) public static extern void glVertexStream1sATI(uint stream, short x) Parameters stream uint x short glVertexStream1svATI(uint, short*) public static extern void glVertexStream1svATI(uint stream, short* coords) Parameters stream uint coords short* glVertexStream2dATI(uint, double, double) public static extern void glVertexStream2dATI(uint stream, double x, double y) Parameters stream uint x double y double glVertexStream2dvATI(uint, double*) public static extern void glVertexStream2dvATI(uint stream, double* coords) Parameters stream uint coords double* glVertexStream2fATI(uint, float, float) public static extern void glVertexStream2fATI(uint stream, float x, float y) Parameters stream uint x float y float glVertexStream2fvATI(uint, float*) public static extern void glVertexStream2fvATI(uint stream, float* coords) Parameters stream uint coords float* glVertexStream2iATI(uint, int, int) public static extern void glVertexStream2iATI(uint stream, int x, int y) Parameters stream uint x int y int glVertexStream2ivATI(uint, int*) public static extern void glVertexStream2ivATI(uint stream, int* coords) Parameters stream uint coords int* glVertexStream2sATI(uint, short, short) public static extern void glVertexStream2sATI(uint stream, short x, short y) Parameters stream uint x short y short glVertexStream2svATI(uint, short*) public static extern void glVertexStream2svATI(uint stream, short* coords) Parameters stream uint coords short* glVertexStream3dATI(uint, double, double, double) public static extern void glVertexStream3dATI(uint stream, double x, double y, double z) Parameters stream uint x double y double z double glVertexStream3dvATI(uint, double*) public static extern void glVertexStream3dvATI(uint stream, double* coords) Parameters stream uint coords double* glVertexStream3fATI(uint, float, float, float) public static extern void glVertexStream3fATI(uint stream, float x, float y, float z) Parameters stream uint x float y float z float glVertexStream3fvATI(uint, float*) public static extern void glVertexStream3fvATI(uint stream, float* coords) Parameters stream uint coords float* glVertexStream3iATI(uint, int, int, int) public static extern void glVertexStream3iATI(uint stream, int x, int y, int z) Parameters stream uint x int y int z int glVertexStream3ivATI(uint, int*) public static extern void glVertexStream3ivATI(uint stream, int* coords) Parameters stream uint coords int* glVertexStream3sATI(uint, short, short, short) public static extern void glVertexStream3sATI(uint stream, short x, short y, short z) Parameters stream uint x short y short z short glVertexStream3svATI(uint, short*) public static extern void glVertexStream3svATI(uint stream, short* coords) Parameters stream uint coords short* glVertexStream4dATI(uint, double, double, double, double) public static extern void glVertexStream4dATI(uint stream, double x, double y, double z, double w) Parameters stream uint x double y double z double w double glVertexStream4dvATI(uint, double*) public static extern void glVertexStream4dvATI(uint stream, double* coords) Parameters stream uint coords double* glVertexStream4fATI(uint, float, float, float, float) public static extern void glVertexStream4fATI(uint stream, float x, float y, float z, float w) Parameters stream uint x float y float z float w float glVertexStream4fvATI(uint, float*) public static extern void glVertexStream4fvATI(uint stream, float* coords) Parameters stream uint coords float* glVertexStream4iATI(uint, int, int, int, int) public static extern void glVertexStream4iATI(uint stream, int x, int y, int z, int w) Parameters stream uint x int y int z int w int glVertexStream4ivATI(uint, int*) public static extern void glVertexStream4ivATI(uint stream, int* coords) Parameters stream uint coords int* glVertexStream4sATI(uint, short, short, short, short) public static extern void glVertexStream4sATI(uint stream, short x, short y, short z, short w) Parameters stream uint x short y short z short w short glVertexStream4svATI(uint, short*) public static extern void glVertexStream4svATI(uint stream, short* coords) Parameters stream uint coords short* glVideoCaptureNV(uint, uint*, ulong*) public static extern uint glVideoCaptureNV(uint video_capture_slot, uint* sequence_num, ulong* capture_time) Parameters video_capture_slot uint sequence_num uint* capture_time ulong* Returns uint glVideoCaptureStreamParameterdvNV(uint, uint, uint, double*) public static extern void glVideoCaptureStreamParameterdvNV(uint video_capture_slot, uint stream, uint pname, double* @params) Parameters video_capture_slot uint stream uint pname uint params double* glVideoCaptureStreamParameterfvNV(uint, uint, uint, float*) public static extern void glVideoCaptureStreamParameterfvNV(uint video_capture_slot, uint stream, uint pname, float* @params) Parameters video_capture_slot uint stream uint pname uint params float* glVideoCaptureStreamParameterivNV(uint, uint, uint, int*) public static extern void glVideoCaptureStreamParameterivNV(uint video_capture_slot, uint stream, uint pname, int* @params) Parameters video_capture_slot uint stream uint pname uint params int* glViewport(int, int, int, int) public static extern void glViewport(int x, int y, int width, int height) Parameters x int y int width int height int glViewportArrayv(uint, int, float*) public static extern void glViewportArrayv(uint first, int count, float* v) Parameters first uint count int v float* glViewportIndexedf(uint, float, float, float, float) public static extern void glViewportIndexedf(uint index, float x, float y, float w, float h) Parameters index uint x float y float w float h float glViewportIndexedfv(uint, float*) public static extern void glViewportIndexedfv(uint index, float* v) Parameters index uint v float* glWaitSync(nint, uint, ulong) public static extern void glWaitSync(nint sync, uint flags, ulong timeout) Parameters sync nint flags uint timeout ulong glWriteMaskEXT(uint, uint, uint, uint, uint, uint) public static extern void glWriteMaskEXT(uint res, uint @in, uint outX, uint outY, uint outZ, uint outW) Parameters res uint in uint outX uint outY uint outZ uint outW uint"
  },
  "api/Hi.Disp.IDisplayee.html": {
    "href": "api/Hi.Disp.IDisplayee.html",
    "title": "Interface IDisplayee | HiAPI-C# 2025",
    "summary": "Interface IDisplayee Namespace Hi.Disp Assembly HiDisp.dll An object which can be displayed in DispEngine. public interface IDisplayee : IExpandToBox3d Inherited Members IExpandToBox3d.ExpandToBox3d(Box3d) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) DispUtil.Display(IDisplayee, Bind, Mat4d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods Display(Bind) Display function called in DispEngine rendering loop. void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind."
  },
  "api/Hi.Disp.IGetDispEngine.html": {
    "href": "api/Hi.Disp.IGetDispEngine.html",
    "title": "Interface IGetDispEngine | HiAPI-C# 2025",
    "summary": "Interface IGetDispEngine Namespace Hi.Disp Assembly HiDisp.dll Interface fo getting DispEngine. public interface IGetDispEngine Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetDispEngine() Get DispEngine. DispEngine GetDispEngine() Returns DispEngine DispEngine"
  },
  "api/Hi.Disp.IGetPickable.html": {
    "href": "api/Hi.Disp.IGetPickable.html",
    "title": "Interface IGetPickable | HiAPI-C# 2025",
    "summary": "Interface IGetPickable Namespace Hi.Disp Assembly HiDisp.dll Get Pickable interface. public interface IGetPickable Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetPickable() Get Pickable Pickable GetPickable() Returns Pickable pickable"
  },
  "api/Hi.Disp.IGlContextDirver.html": {
    "href": "api/Hi.Disp.IGlContextDirver.html",
    "title": "Interface IGlContextDirver | HiAPI-C# 2025",
    "summary": "Interface IGlContextDirver Namespace Hi.Disp Assembly HiDisp.dll Bridge of Native OpenGL Context. public interface IGlContextDirver : IDisposable Inherited Members IDisposable.Dispose() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods FreeCurrent() OpenGL context free current. void FreeCurrent() MakeCurrent() OpenGL context make current. void MakeCurrent() Resize(double, double) Resize the opengl context. void Resize(double width, double height) Parameters width double viewport width height double viewport height SwapBuffers() OpenGL context swap buffers. void SwapBuffers()"
  },
  "api/Hi.Disp.MatStack.ItemDisposable.html": {
    "href": "api/Hi.Disp.MatStack.ItemDisposable.html",
    "title": "Class MatStack.ItemDisposable | HiAPI-C# 2025",
    "summary": "Class MatStack.ItemDisposable Namespace Hi.Disp Assembly HiDisp.dll A disposable class that manages push and pop operations on a matrix stack. public class MatStack.ItemDisposable : IDisposable Inheritance object MatStack.ItemDisposable Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ItemDisposable(MatStack) Initializes a new instance of the MatStack.ItemDisposable class. public ItemDisposable(MatStack stack) Parameters stack MatStack The matrix stack to manage. Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose()"
  },
  "api/Hi.Disp.MatStack.html": {
    "href": "api/Hi.Disp.MatStack.html",
    "title": "Class MatStack | HiAPI-C# 2025",
    "summary": "Class MatStack Namespace Hi.Disp Assembly HiDisp.dll Stack-based Matrix. public class MatStack Inheritance object MatStack Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Current Equal to Last. public Mat4d Current { get; } Property Value Mat4d ID ID. The ID equals to the count of manipulation. public int ID { get; } Property Value int Last Top matrix. public Mat4d Last { get; } Property Value Mat4d Methods ~MatStack() protected ~MatStack() GenPush() Generates a disposable object that pushes the matrix stack on creation and pops it on disposal. public MatStack.ItemDisposable GenPush() Returns MatStack.ItemDisposable A disposable object that manages the push/pop operations. Load(Mat4d) Set the top matrix to mat. public void Load(Mat4d mat) Parameters mat Mat4d matrix LoadIdt() Set the top matrix to identity. public void LoadIdt() Mul(Mat4d) Multiply the matrix to the top level matrix. Which is Last() = mat * Last(); public void Mul(Mat4d mat) Parameters mat Mat4d Pop() Pop top matrix. public void Pop() See Also Push() Push() Copy and push the top matrix to the stack. public void Push() See Also Pop() PushMul(Mat4d) Call Push() and then call Mul(Mat4d) with mat. public void PushMul(Mat4d mat) Parameters mat Mat4d the pushed and multiplied matrix Reset() Reset/Clean matrix stack. public void Reset() Rotate(AxisAngle4d) Rotate the top matrix. public void Rotate(AxisAngle4d aa) Parameters aa AxisAngle4d axis angle Rotate(Vec3d, double) Rotate the top matrix. public void Rotate(Vec3d axis, double rad) Parameters axis Vec3d rotation axis rad double angle in radian Scale(double) Multiply the scale matrix to the top level matrix. public void Scale(double s) Parameters s double scale Scale(double, double, double) Multiply the scale matrix by three axises to the top level matrix. public void Scale(double x, double y, double z) Parameters x double x-axis scale y double y-axis scale z double z-axis scale Trans(Vec3d) Translate the top matrix. public void Trans(Vec3d v) Parameters v Vec3d translation Trans(double, double, double) Translate the top matrix. public void Trans(double x, double y, double z) Parameters x double x y double y z double z"
  },
  "api/Hi.Disp.MvpBoxRelation.html": {
    "href": "api/Hi.Disp.MvpBoxRelation.html",
    "title": "Enum MvpBoxRelation | HiAPI-C# 2025",
    "summary": "Enum MvpBoxRelation Namespace Hi.Disp Assembly HiDisp.dll Relation between mvpBox and an AABB public enum MvpBoxRelation Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields INSIDE = 2 The AABB is inside mvpBox. NO_OVERLAPPED = 0 No overlapped PARTIAL_OVERLAPPED = 1 Partial overlapped."
  },
  "api/Hi.Disp.Pickable.html": {
    "href": "api/Hi.Disp.Pickable.html",
    "title": "Class Pickable | HiAPI-C# 2025",
    "summary": "Class Pickable Namespace Hi.Disp Assembly HiDisp.dll Picking event handler for rendering. Note that it has to be disposed manually or the object occurs memory leak. public class Pickable : IGetPickable, IDisposable Inheritance object Pickable Implements IGetPickable IDisposable Derived CbtrPickable ShowEventPickable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Pickable() Ctor. public Pickable() Fields mark Internal only. protected picking_mark_t* mark Field Value picking_mark_t* Properties Pickables public static ConcurrentDictionary<Pickable, Pickable> Pickables { get; } Property Value ConcurrentDictionary<Pickable, Pickable> Remarks Design Concern: Substitude of ConcurrentSet. PickingID ID of picking event. public int PickingID { get; } Property Value int Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ~Pickable() protected ~Pickable() GetPickable() Get Pickable public Pickable GetPickable() Returns Pickable pickable OnKeyDown(key_event_t, DispEngine) Behavior on key down. public virtual void OnKeyDown(key_event_t e, DispEngine dispEngine) Parameters e key_event_t event dispEngine DispEngine display engine OnKeyUp(key_event_t, DispEngine) Behavior on key up public virtual void OnKeyUp(key_event_t e, DispEngine dispEngine) Parameters e key_event_t event dispEngine DispEngine display engine OnMouseDown(mouse_button_event_t, DispEngine) Behavior on mouse down public virtual void OnMouseDown(mouse_button_event_t e, DispEngine dispEngine) Parameters e mouse_button_event_t event dispEngine DispEngine display engine OnMouseEnter(ui_event_type, DispEngine) Behavior on mouse enter public virtual void OnMouseEnter(ui_event_type e, DispEngine dispEngine) Parameters e ui_event_type event type dispEngine DispEngine display engine OnMouseLeave(ui_event_type, DispEngine) Behavior on mouse leave public virtual void OnMouseLeave(ui_event_type e, DispEngine dispEngine) Parameters e ui_event_type event type dispEngine DispEngine display engine OnMouseMove(mouse_move_event_t, DispEngine) Behavior on mouse move public virtual void OnMouseMove(mouse_move_event_t e, DispEngine dispEngine) Parameters e mouse_move_event_t event dispEngine DispEngine display engine OnMouseUp(mouse_button_event_t, DispEngine) Behavior on mouse up public virtual void OnMouseUp(mouse_button_event_t e, DispEngine dispEngine) Parameters e mouse_button_event_t event dispEngine DispEngine display engine OnMouseWheel(mouse_wheel_event_t, DispEngine) Behavior on mouse wheel public virtual void OnMouseWheel(mouse_wheel_event_t e, DispEngine dispEngine) Parameters e mouse_wheel_event_t event dispEngine DispEngine display engine"
  },
  "api/Hi.Disp.PopModelMat.html": {
    "href": "api/Hi.Disp.PopModelMat.html",
    "title": "Class PopModelMat | HiAPI-C# 2025",
    "summary": "Class PopModelMat Namespace Hi.Disp Assembly HiDisp.dll Call Pop() for Hi.Disp.Bind.modelMatStack in Display(Bind). This function is only for test purpose. Since the ExpandToBox3d(Box3d) just expand the translation part of the mat to the target box. This function should be use with PushModelMat. public class PopModelMat : IDisplayee, IExpandToBox3d Inheritance object PopModelMat Implements IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors PopModelMat() Initializes a new instance of the PopModelMat class. public PopModelMat() Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box"
  },
  "api/Hi.Disp.PushModelMat.html": {
    "href": "api/Hi.Disp.PushModelMat.html",
    "title": "Class PushModelMat | HiAPI-C# 2025",
    "summary": "Class PushModelMat Namespace Hi.Disp Assembly HiDisp.dll Call Push() for Hi.Disp.Bind.modelMatStack in Display(Bind). This function is only for test purpose. Since the ExpandToBox3d(Box3d) just expand the translation part of the mat to the target box. This function should be use with PopModelMat. public class PushModelMat : IDisplayee, IExpandToBox3d Inheritance object PushModelMat Implements IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors PushModelMat() Initializes a new instance of the PushModelMat class. public PushModelMat() Properties Mat Pushed matrix. public Mat4d Mat { get; set; } Property Value Mat4d Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box"
  },
  "api/Hi.Disp.Segment3dDispUtil.html": {
    "href": "api/Hi.Disp.Segment3dDispUtil.html",
    "title": "Class Segment3dDispUtil | HiAPI-C# 2025",
    "summary": "Class Segment3dDispUtil Namespace Hi.Disp Assembly HiDisp.dll Utilities for converting geometry segments to renderable drawings. public static class Segment3dDispUtil Inheritance object Segment3dDispUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods ToDrawing(IEnumerable<Segment3d>) Converts a sequence of 3D segments to a line drawing. Null endpoints are skipped. The resulting drawing uses GL_LINES with stamp V. public static Drawing ToDrawing(this IEnumerable<Segment3d> segments) Parameters segments IEnumerable<Segment3d> Input segments to convert. Returns Drawing A drawing that renders the provided segments."
  },
  "api/Hi.Disp.ShowEventPickable.html": {
    "href": "api/Hi.Disp.ShowEventPickable.html",
    "title": "Class ShowEventPickable | HiAPI-C# 2025",
    "summary": "Class ShowEventPickable Namespace Hi.Disp Assembly HiDisp.dll Show pick events in console. public class ShowEventPickable : Pickable, IGetPickable, IDisposable Inheritance object Pickable ShowEventPickable Implements IGetPickable IDisposable Inherited Members Pickable.Pickables Pickable.mark Pickable.PickingID Pickable.GetPickable() Pickable.Dispose(bool) Pickable.Dispose() object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ShowEventPickable() ctor. public ShowEventPickable() Properties Tag Tag shows in pick events. public object Tag { get; set; } Property Value object Methods OnKeyDown(key_event_t, DispEngine) Behavior on key down. public override void OnKeyDown(key_event_t e, DispEngine dispEngine) Parameters e key_event_t event dispEngine DispEngine display engine OnKeyUp(key_event_t, DispEngine) Behavior on key up public override void OnKeyUp(key_event_t e, DispEngine dispEngine) Parameters e key_event_t event dispEngine DispEngine display engine OnMouseDown(mouse_button_event_t, DispEngine) Behavior on mouse down public override void OnMouseDown(mouse_button_event_t e, DispEngine dispEngine) Parameters e mouse_button_event_t event dispEngine DispEngine display engine OnMouseEnter(ui_event_type, DispEngine) Behavior on mouse enter public override void OnMouseEnter(ui_event_type e, DispEngine dispEngine) Parameters e ui_event_type event type dispEngine DispEngine display engine OnMouseLeave(ui_event_type, DispEngine) Behavior on mouse leave public override void OnMouseLeave(ui_event_type e, DispEngine dispEngine) Parameters e ui_event_type event type dispEngine DispEngine display engine OnMouseMove(mouse_move_event_t, DispEngine) Behavior on mouse move public override void OnMouseMove(mouse_move_event_t e, DispEngine dispEngine) Parameters e mouse_move_event_t event dispEngine DispEngine display engine OnMouseUp(mouse_button_event_t, DispEngine) Behavior on mouse up public override void OnMouseUp(mouse_button_event_t e, DispEngine dispEngine) Parameters e mouse_button_event_t event dispEngine DispEngine display engine OnMouseWheel(mouse_wheel_event_t, DispEngine) Behavior on mouse wheel public override void OnMouseWheel(mouse_wheel_event_t e, DispEngine dispEngine) Parameters e mouse_wheel_event_t event dispEngine DispEngine display engine"
  },
  "api/Hi.Disp.Stamp.html": {
    "href": "api/Hi.Disp.Stamp.html",
    "title": "Enum Stamp | HiAPI-C# 2025",
    "summary": "Enum Stamp Namespace Hi.Disp Assembly HiDisp.dll Data scope of the double array for Drawing. public enum Stamp Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields CNV = 3 Points data in sequence of Color(3), Normal(3), Vertex(3), repetitively. CV = 2 Points data in sequence of Color(3), Vertex(3), repetitively. NV = 1 Points data in sequence of Normal(3), Vertex(3), repetitively. PCNV = 7 Points data in sequence of Pick(1), Color(3), Normal(3), Vertex(3), repetitively. PCV = 6 Points data in sequence of Pick(1), Color(3), Vertex(3), repetitively. PNV = 5 Points data in sequence of Pick(1), Normal(3), Vertex(3), repetitively. PV = 4 Points data in sequence of Pick(1), Vertex(3), repetitively. V = 0 Points data in sequence of Vertex(3), repetitively."
  },
  "api/Hi.Disp.StringDrawing.html": {
    "href": "api/Hi.Disp.StringDrawing.html",
    "title": "Class StringDrawing | HiAPI-C# 2025",
    "summary": "Class StringDrawing Namespace Hi.Disp Assembly HiDisp.dll An IDisplayee to draw string. Multi-line text is supported: ‘\\n’ starts a new line. public class StringDrawing : IDisplayee, IExpandToBox3d, IDisposable Inheritance object StringDrawing Implements IDisplayee IExpandToBox3d IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors StringDrawing(string) Constructor. public StringDrawing(string text) Parameters text string text Fields text Text to draw. public readonly string text Field Value string Properties Height Gets the height of the string drawing in pixels. public int Height { get; } Property Value int IsAlwaysOnTop Is text always on top. public bool IsAlwaysOnTop { get; set; } Property Value bool Width Gets the width of the string drawing in pixels. public int Width { get; } Property Value int Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. Display(Bind, Vec3d, bool) Display at p. public void Display(Bind bind, Vec3d p, bool isAlwaysOnTop = false) Parameters bind Bind bind p Vec3d position isAlwaysOnTop bool is always on top Display(Bind, string, Vec3d, bool) Display text at p. public static void Display(Bind bind, string text, Vec3d p = null, bool isAlwaysOnTop = false) Parameters bind Bind bind text string text p Vec3d position isAlwaysOnTop bool is always on top Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box ~StringDrawing() protected ~StringDrawing()"
  },
  "api/Hi.Disp.Treat.LineWidthSwap.html": {
    "href": "api/Hi.Disp.Treat.LineWidthSwap.html",
    "title": "Class LineWidthSwap | HiAPI-C# 2025",
    "summary": "Class LineWidthSwap Namespace Hi.Disp.Treat Assembly HiDisp.dll A utility class for temporarily changing the line width and restoring it when disposed. public class LineWidthSwap : IDisposable Inheritance object LineWidthSwap Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors LineWidthSwap(double) Initializes a new instance of the LineWidthSwap class. public LineWidthSwap(double lineWidth) Parameters lineWidth double The new line width to set. Properties PreLineWidth Gets the previous line width value that will be restored on disposal. public float PreLineWidth { get; } Property Value float Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool"
  },
  "api/Hi.Disp.Treat.LineWidthTreat.html": {
    "href": "api/Hi.Disp.Treat.LineWidthTreat.html",
    "title": "Class LineWidthTreat | HiAPI-C# 2025",
    "summary": "Class LineWidthTreat Namespace Hi.Disp.Treat Assembly HiDisp.dll Object for set line width of opengl drawing. public class LineWidthTreat : IDisplayee, IExpandToBox3d Inheritance object LineWidthTreat Implements IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors LineWidthTreat(float) Initializes a new instance of the LineWidthTreat class. public LineWidthTreat(float lineWidth) Parameters lineWidth float The line width to set. Properties LineWidth Gets or sets the line width value. public float LineWidth { get; set; } Property Value float Methods Display(Bind) Sets the line width in the OpenGL context. public void Display(Bind bind) Parameters bind Bind The binding context. ExpandToBox3d(Box3d) This implementation does nothing as line width does not affect bounding box. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d The destination box to expand."
  },
  "api/Hi.Disp.Treat.PointSizeSwap.html": {
    "href": "api/Hi.Disp.Treat.PointSizeSwap.html",
    "title": "Class PointSizeSwap | HiAPI-C# 2025",
    "summary": "Class PointSizeSwap Namespace Hi.Disp.Treat Assembly HiDisp.dll A utility class for temporarily changing the point size and restoring it when disposed. public class PointSizeSwap : IDisposable Inheritance object PointSizeSwap Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors PointSizeSwap(double) Initializes a new instance of the PointSizeSwap class. public PointSizeSwap(double pointSize) Parameters pointSize double The new point size to set. Properties PrePointSize Gets the previous point size value that will be restored on disposal. public float PrePointSize { get; } Property Value float Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool"
  },
  "api/Hi.Disp.Treat.PointSizeTreat.html": {
    "href": "api/Hi.Disp.Treat.PointSizeTreat.html",
    "title": "Class PointSizeTreat | HiAPI-C# 2025",
    "summary": "Class PointSizeTreat Namespace Hi.Disp.Treat Assembly HiDisp.dll Object for set point size of opengl drawing. public class PointSizeTreat : IDisplayee, IExpandToBox3d Inheritance object PointSizeTreat Implements IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors PointSizeTreat(int) Initializes a new instance of the PointSizeTreat class. public PointSizeTreat(int pointSize) Parameters pointSize int The point size to set. Properties PointSize Gets or sets the point size value. public int PointSize { get; set; } Property Value int Methods Display(Bind) Sets the point size in the OpenGL context. public void Display(Bind bind) Parameters bind Bind The binding context. ExpandToBox3d(Box3d) This implementation does nothing as point size does not affect bounding box. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d The destination box to expand."
  },
  "api/Hi.Disp.Treat.RgbSwap.html": {
    "href": "api/Hi.Disp.Treat.RgbSwap.html",
    "title": "Class RgbSwap | HiAPI-C# 2025",
    "summary": "Class RgbSwap Namespace Hi.Disp.Treat Assembly HiDisp.dll A utility class for temporarily changing the RGB color and restoring it when disposed. public class RgbSwap : IDisposable Inheritance object RgbSwap Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors RgbSwap(Bind, Vec3d) Initializes a new instance of the RgbSwap class. public RgbSwap(Bind bind, Vec3d rgb) Parameters bind Bind The binding context. rgb Vec3d The new RGB color to set. Properties PreRgb Gets the previous RGB color value that will be restored on disposal. public Vec3d PreRgb { get; } Property Value Vec3d Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool"
  },
  "api/Hi.Disp.Treat.RgbTreat.html": {
    "href": "api/Hi.Disp.Treat.RgbTreat.html",
    "title": "Class RgbTreat | HiAPI-C# 2025",
    "summary": "Class RgbTreat Namespace Hi.Disp.Treat Assembly HiDisp.dll A displayee that sets the RGB color in the binding context. public class RgbTreat : IDisplayee, IExpandToBox3d Inheritance object RgbTreat Implements IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors RgbTreat(Vec3d) Initializes a new instance of the RgbTreat class. public RgbTreat(Vec3d rgb = null) Parameters rgb Vec3d The RGB color vector to set. RgbTreat(double, double, double) Initializes a new instance of the RgbTreat class with RGB component values. public RgbTreat(double r, double g, double b) Parameters r double The red component (0.0 to 1.0). g double The green component (0.0 to 1.0). b double The blue component (0.0 to 1.0). Properties Rgb Gets or sets the RGB color vector. public Vec3d Rgb { get; set; } Property Value Vec3d Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box"
  },
  "api/Hi.Disp.Treat.RgbWrapper.html": {
    "href": "api/Hi.Disp.Treat.RgbWrapper.html",
    "title": "Class RgbWrapper | HiAPI-C# 2025",
    "summary": "Class RgbWrapper Namespace Hi.Disp.Treat Assembly HiDisp.dll A wrapper displayee that applies an RGB color to the wrapped displayee. public class RgbWrapper : IDisplayee, IExpandToBox3d Inheritance object RgbWrapper Implements IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors RgbWrapper() Initializes a new instance of the RgbWrapper class. public RgbWrapper() RgbWrapper(IDisplayee, Vec3d) Initializes a new instance of the RgbWrapper class with a displayee and RGB color. public RgbWrapper(IDisplayee displayee, Vec3d rgb = null) Parameters displayee IDisplayee The displayee to be wrapped. rgb Vec3d The RGB color to apply to the wrapped displayee. Properties Displayee Gets or sets the displayee to be wrapped. public IDisplayee Displayee { get; set; } Property Value IDisplayee Rgb Gets or sets the RGB color to apply to the wrapped displayee. public Vec3d Rgb { get; set; } Property Value Vec3d Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box"
  },
  "api/Hi.Disp.Treat.TransformationWrapper.html": {
    "href": "api/Hi.Disp.Treat.TransformationWrapper.html",
    "title": "Class TransformationWrapper | HiAPI-C# 2025",
    "summary": "Class TransformationWrapper Namespace Hi.Disp.Treat Assembly HiDisp.dll A wrapper displayee that applies a transformation matrix to the wrapped displayees. public class TransformationWrapper : IDisplayee, IExpandToBox3d Inheritance object TransformationWrapper Implements IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors TransformationWrapper(Mat4d, params IDisplayee[]) Initializes a new instance of the TransformationWrapper class. public TransformationWrapper(Mat4d mat, params IDisplayee[] displayees) Parameters mat Mat4d The transformation matrix to apply. displayees IDisplayee[] The displayees to be transformed. Properties Displayees Gets or sets the collection of displayees to be transformed. public SynList<IDisplayee> Displayees { get; set; } Property Value SynList<IDisplayee> TransformingMat Gets or sets the transformation matrix to apply to the wrapped displayees. public Mat4d TransformingMat { get; set; } Property Value Mat4d Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box"
  },
  "api/Hi.Disp.Treat.html": {
    "href": "api/Hi.Disp.Treat.html",
    "title": "Namespace Hi.Disp.Treat | HiAPI-C# 2025",
    "summary": "Namespace Hi.Disp.Treat Classes LineWidthSwap A utility class for temporarily changing the line width and restoring it when disposed. LineWidthTreat Object for set line width of opengl drawing. PointSizeSwap A utility class for temporarily changing the point size and restoring it when disposed. PointSizeTreat Object for set point size of opengl drawing. RgbSwap A utility class for temporarily changing the RGB color and restoring it when disposed. RgbTreat A displayee that sets the RGB color in the binding context. RgbWrapper A wrapper displayee that applies an RGB color to the wrapped displayee. TransformationWrapper A wrapper displayee that applies a transformation matrix to the wrapped displayees."
  },
  "api/Hi.Disp.Tri3dDispUtil.html": {
    "href": "api/Hi.Disp.Tri3dDispUtil.html",
    "title": "Class Tri3dDispUtil | HiAPI-C# 2025",
    "summary": "Class Tri3dDispUtil Namespace Hi.Disp Assembly HiDisp.dll Utility and Extension of Tri3d. public static class Tri3dDispUtil Inheritance object Tri3dDispUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods Display(Tri3d, Bind) Display the face of src. public static void Display(this Tri3d src, Bind bind) Parameters src Tri3d triangle bind Bind Bind GetFaceDrawing(IEnumerable<Tri3d>) Get ccw faces draw of tris. public static Drawing GetFaceDrawing(this IEnumerable<Tri3d> tris) Parameters tris IEnumerable<Tri3d> triangles Returns Drawing Drawing ToDrawing(Tri3d) Equivalent to ToFaceDrawing(Tri3d) public static Drawing ToDrawing(this Tri3d src) Parameters src Tri3d src Returns Drawing Drawing ToFaceBuf(Tri3d, double[], ref int) set n,p0,n,p1,n,p2 to double array. Where n is normal. public static int ToFaceBuf(this Tri3d src, double[] dst, ref int p) Parameters src Tri3d src dst double[] dst array p int current array position Returns int pushed double size:18 ToFaceDrawing(Tri3d) To Face Drawing. public static Drawing ToFaceDrawing(this Tri3d src) Parameters src Tri3d src Returns Drawing Face Drawing ToLineBuf(Tri3d, double[], ref int) Put lines array to the dst. The lines array contains 3 edges x 2 end points. public static int ToLineBuf(this Tri3d src, double[] dst, ref int p) Parameters src Tri3d src dst double[] dst p int position of the dst Returns int Which is pushed length, in number of double ToLineDrawing(Tri3d) To Line Drawing. public static Drawing ToLineDrawing(this Tri3d src) Parameters src Tri3d src Returns Drawing Line Drawing ToLineDrawing(IEnumerable<Tri3d>) Get lines draw of the tris. public static Drawing ToLineDrawing(this IEnumerable<Tri3d> tris) Parameters tris IEnumerable<Tri3d> triangles Returns Drawing Drawing ToSparkleLineBuf(Tri3d, double[], ref int) Writes the sparkle line representation of a triangle (with normals) into a buffer. public static int ToSparkleLineBuf(this Tri3d src, double[] dst, ref int p) Parameters src Tri3d The source triangle. dst double[] The destination buffer. p int The current write position in the buffer, updated after writing. Returns int The number of elements written. ToSparkleLineDrawing(IEnumerable<Tri3d>) Get lines draw of the tris. public static Drawing ToSparkleLineDrawing(this IEnumerable<Tri3d> tris) Parameters tris IEnumerable<Tri3d> triangles Returns Drawing Drawing"
  },
  "api/Hi.Disp.Vec3dDispUtil.html": {
    "href": "api/Hi.Disp.Vec3dDispUtil.html",
    "title": "Class Vec3dDispUtil | HiAPI-C# 2025",
    "summary": "Class Vec3dDispUtil Namespace Hi.Disp Assembly HiDisp.dll Utility and Extension of Vec3d. public static class Vec3dDispUtil Inheritance object Vec3dDispUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods Display(Bind, IList<Vec3d>, Stamp, int) Display by the src. src will be expand to an array and then call Display(Bind, double[], Stamp, int). public static void Display(Bind bind, IList<Vec3d> src, Stamp stamp, int glPrimitive) Parameters bind Bind bind src IList<Vec3d> src stamp Stamp stamp glPrimitive int gl primitive Display(Vec3d, Bind) Display a point. public static void Display(this Vec3d src, Bind bind) Parameters src Vec3d point bind Bind bind ToLineStripDrawing(IList<Vec3d>) Creates a line strip drawing from a list of points. public static Drawing ToLineStripDrawing(this IList<Vec3d> points) Parameters points IList<Vec3d> The list of points to draw as a line strip. Returns Drawing A Drawing object representing the line strip."
  },
  "api/Hi.Disp.WrappedDisplayee.html": {
    "href": "api/Hi.Disp.WrappedDisplayee.html",
    "title": "Class WrappedDisplayee | HiAPI-C# 2025",
    "summary": "Class WrappedDisplayee Namespace Hi.Disp Assembly HiDisp.dll A wrapper class for IDisplayee that allows customizing display and bounding box behavior. public class WrappedDisplayee : IDisplayee, IExpandToBox3d Inheritance object WrappedDisplayee Implements IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors WrappedDisplayee() Initializes a new instance of the WrappedDisplayee class. public WrappedDisplayee() WrappedDisplayee(IDisplayee, Action<IDisplayee, Bind>, Action<IDisplayee, Box3d>) Initializes a new instance of the WrappedDisplayee class with specified displayee and delegates. public WrappedDisplayee(IDisplayee displayee, Action<IDisplayee, Bind> displayDelegate, Action<IDisplayee, Box3d> expandToBox3dDelegate) Parameters displayee IDisplayee The displayee to wrap. displayDelegate Action<IDisplayee, Bind> The delegate for custom display behavior. expandToBox3dDelegate Action<IDisplayee, Box3d> The delegate for custom bounding box expansion behavior. Properties DisplayDelegate Gets or sets the delegate for custom display behavior. public Action<IDisplayee, Bind> DisplayDelegate { get; set; } Property Value Action<IDisplayee, Bind> Displayee Gets or sets the wrapped displayee object. public IDisplayee Displayee { get; set; } Property Value IDisplayee ExpandToBox3dDelegate Gets or sets the delegate for custom bounding box expansion behavior. public Action<IDisplayee, Box3d> ExpandToBox3dDelegate { get; set; } Property Value Action<IDisplayee, Box3d> Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box"
  },
  "api/Hi.Disp.html": {
    "href": "api/Hi.Disp.html",
    "title": "Namespace Hi.Disp | HiAPI-C# 2025",
    "summary": "Namespace Hi.Disp Classes Bind Runtime rendering data for each iteration in rendering loop. It manipulates geometry transformation, such as moving, rotatingand scaling. It also deal with color and picking. A bind_t object is generated by rendering in the every beginning of each rendering iteration. Box3dDispUtil Utility and Extension of Box3d. DelegateFuncDisplayee A displayee implementation that delegates display functionality to a function. DispEngine HiAPI display engine. DispEngineConfig Configuration class for display engine. DispFrameUtil Utility class for display frame management. DispList A combination of IDisplayee and SynList<T>. DispUtil Display Utility Drawing The most efficient elemental 3D rendering unit. FuncDisplayee A displayee implementation that delegates display functionality to function delegates. GL Native opengl functions wrapper. MatStack Stack-based Matrix. MatStack.ItemDisposable A disposable class that manages push and pop operations on a matrix stack. Pickable Picking event handler for rendering. Note that it has to be disposed manually or the object occurs memory leak. PopModelMat Call Pop() for Hi.Disp.Bind.modelMatStack in Display(Bind). This function is only for test purpose. Since the ExpandToBox3d(Box3d) just expand the translation part of the mat to the target box. This function should be use with PushModelMat. PushModelMat Call Push() for Hi.Disp.Bind.modelMatStack in Display(Bind). This function is only for test purpose. Since the ExpandToBox3d(Box3d) just expand the translation part of the mat to the target box. This function should be use with PopModelMat. Segment3dDispUtil Utilities for converting geometry segments to renderable drawings. ShowEventPickable Show pick events in console. StringDrawing An IDisplayee to draw string. Multi-line text is supported: ‘\\n’ starts a new line. Tri3dDispUtil Utility and Extension of Tri3d. Vec3dDispUtil Utility and Extension of Vec3d. WrappedDisplayee A wrapper class for IDisplayee that allows customizing display and bounding box behavior. Interfaces IDisplayee An object which can be displayed in DispEngine. IGetDispEngine Interface fo getting DispEngine. IGetPickable Get Pickable interface. IGlContextDirver Bridge of Native OpenGL Context. Enums MvpBoxRelation Relation between mvpBox and an AABB Stamp Data scope of the double array for Drawing. Delegates Box3dDispUtil.BoxableExpandToBox3dDel Delegate for expanding a native boxable object to a box3d. DispEngine.ImageRequestedDelegate For ImageRequestAfterBufferSwapped."
  },
  "api/Hi.Fanuc.FanucVarTable.html": {
    "href": "api/Hi.Fanuc.FanucVarTable.html",
    "title": "Class FanucVarTable | HiAPI-C# 2025",
    "summary": "Class FanucVarTable Namespace Hi.Fanuc Assembly HiUniNc.dll Represents a table of Fanuc variables used for CNC machine control. public class FanucVarTable Inheritance object FanucVarTable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FanucVarTable() Initializes a new instance of the FanucVarTable class. public FanucVarTable() Properties TLB For tool lenght compensation (G43, G44) ‘true’ value is not supported. public bool TLB { get; } Property Value bool TLC For tool lenght compensation (G43, G44) ‘true’ value is not supported. public bool TLC { get; } Property Value bool Var5001 For tool lenght compensation (G43, G44) bit1(TLB),bit0(TLC) public int Var5001 { get; } Property Value int"
  },
  "api/Hi.Fanuc.FanucVarValue.html": {
    "href": "api/Hi.Fanuc.FanucVarValue.html",
    "title": "Struct FanucVarValue | HiAPI-C# 2025",
    "summary": "Struct FanucVarValue Namespace Hi.Fanuc Assembly HiUniNc.dll Represents a value for Fanuc variable that can be interpreted as either an integer or a double. public struct FanucVarValue Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DoubleValue Gets or sets the double precision floating point representation of the variable value. public double DoubleValue { get; set; } Property Value double IntValue Gets or sets the integer representation of the variable value. public int IntValue { get; set; } Property Value int"
  },
  "api/Hi.Fanuc.html": {
    "href": "api/Hi.Fanuc.html",
    "title": "Namespace Hi.Fanuc | HiAPI-C# 2025",
    "summary": "Namespace Hi.Fanuc Classes FanucVarTable Represents a table of Fanuc variables used for CNC machine control. Structs FanucVarValue Represents a value for Fanuc variable that can be interpreted as either an integer or a double."
  },
  "api/Hi.Geom.ArrayUtil.html": {
    "href": "api/Hi.Geom.ArrayUtil.html",
    "title": "Class ArrayUtil | HiAPI-C# 2025",
    "summary": "Class ArrayUtil Namespace Hi.Geom Assembly HiGeom.dll Utility class for array operations. public static class ArrayUtil Inheritance object ArrayUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetColumn<T>(T[,], int) Extracts a column from a 2D array. public static T[] GetColumn<T>(this T[,] src, int columnIndex) Parameters src T[,] The source 2D array columnIndex int The index of the column to extract Returns T[] A 1D array containing the elements of the specified column Type Parameters T The type of elements in the array GetRow<T>(T[,], int) Extracts a row from a 2D array. public static T[] GetRow<T>(this T[,] src, int rowIndex) Parameters src T[,] The source 2D array rowIndex int The index of the row to extract Returns T[] A 1D array containing the elements of the specified row Type Parameters T The type of elements in the array GetRows<T>(T[,]) Converts a 2D array to a jagged array of rows. public static T[][] GetRows<T>(this T[,] src) Parameters src T[,] The source 2D array Returns T[][] A jagged array where each inner array represents a row from the source array Type Parameters T The type of elements in the array"
  },
  "api/Hi.Geom.AxisAngle4d.html": {
    "href": "api/Hi.Geom.AxisAngle4d.html",
    "title": "Class AxisAngle4d | HiAPI-C# 2025",
    "summary": "Class AxisAngle4d Namespace Hi.Geom Assembly HiGeom.dll Axis(3d) and angle(1d) public class AxisAngle4d : IFormattable Inheritance object AxisAngle4d Implements IFormattable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors AxisAngle4d(Vec3d, double) Initializes a new instance of the AxisAngle4d class with the specified axis and angle. public AxisAngle4d(Vec3d axis, double angle_rad) Parameters axis Vec3d The rotation axis. angle_rad double The rotation angle in radians. AxisAngle4d(string) Initializes a new instance of the AxisAngle4d class from a string representation. public AxisAngle4d(string s) Parameters s string The string representation of the axis-angle in the format \"(axis,angle)\". Properties Angle_rad Angle in radian. public double Angle_rad { get; set; } Property Value double Axis Gets or sets the rotation axis. public Vec3d Axis { get; set; } Property Value Vec3d Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. ToString(string, IFormatProvider) Formats the value of the current instance using the specified format. public string ToString(string format, IFormatProvider formatProvider) Parameters format string The format to use. -or- A null reference (Nothing in Visual Basic) to use the default format defined for the type of the IFormattable implementation. formatProvider IFormatProvider The provider to use to format the value. -or- A null reference (Nothing in Visual Basic) to obtain the numeric format information from the current locale setting of the operating system. Returns string The value of the current instance in the specified format."
  },
  "api/Hi.Geom.Box2d.NoInit.html": {
    "href": "api/Hi.Geom.Box2d.NoInit.html",
    "title": "Class Box2d.NoInit | HiAPI-C# 2025",
    "summary": "Class Box2d.NoInit Namespace Hi.Geom Assembly HiGeom.dll Flag for calling Box2d(NoInit). public class Box2d.NoInit Inheritance object Box2d.NoInit Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Geom.Box2d.html": {
    "href": "api/Hi.Geom.Box2d.html",
    "title": "Class Box2d | HiAPI-C# 2025",
    "summary": "Class Box2d Namespace Hi.Geom Assembly HiGeom.dll Lightweight 2d box. An orthogonal box which the edges are all parallel with Cartesian Coordinate. The data contains in a Box2d is Min and Max. public class Box2d : IExpandToBox2d, IEquatable<Box2d>, IBinaryIo, IWriteBin, IFormattable Inheritance object Box2d Implements IExpandToBox2d IEquatable<Box2d> IBinaryIo IWriteBin IFormattable Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods BinIoUtil.ToBytes(IWriteBin) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Box2d() Ctor. public Box2d() Box2d(NoInit) Ctor. The Ctor keeps Min and Max to null. public Box2d(Box2d.NoInit noInit) Parameters noInit Box2d.NoInit Box2d(params IExpandToBox2d[]) Initializes a new instance of the Box2d class that encompasses all the specified objects. public Box2d(params IExpandToBox2d[] src) Parameters src IExpandToBox2d[] The objects to include in the box. Box2d(Vec2d, Vec2d) Ctor. public Box2d(Vec2d min, Vec2d max) Parameters min Vec2d Min max Vec2d Max Box2d(box2d) Ctor. public Box2d(box2d src) Parameters src box2d src Box2d(IEnumerable<IExpandToBox2d>) Initializes a new instance of the Box2d class that encompasses all the objects in the specified collection. public Box2d(IEnumerable<IExpandToBox2d> src) Parameters src IEnumerable<IExpandToBox2d> The collection of objects to include in the box. Box2d(double, double, double, double) Initializes a new instance of the Box2d class with the specified minimum and maximum coordinates. public Box2d(double minx, double miny, double maxx, double maxy) Parameters minx double The minimum X coordinate. miny double The minimum Y coordinate. maxx double The maximum X coordinate. maxy double The maximum Y coordinate. Box2d(BinaryReader) Initializes a new instance of the Box2d class from binary data. public Box2d(BinaryReader reader) Parameters reader BinaryReader The binary reader to read the data from. Box2d(XElement) Ctor. public Box2d(XElement src) Parameters src XElement XML Properties Center Center public Vec2d Center { get; } Property Value Vec2d CenterUnitBox Generate a center unit box which min~max is (-0.5,-0.5,-0.5)~(-0.5,0.5,0.5). public static Box2d CenterUnitBox { get; } Property Value Box2d DiagonalLength Diagonal length. public double DiagonalLength { get; } Property Value double Dim Dimension. public Vec2d Dim { get; } Property Value Vec2d HasVolume Gets a value indicating whether this box has a non-zero volume. public bool HasVolume { get; } Property Value bool IsAllNaN Determines whether all coordinates of this box are NaN. public bool IsAllNaN { get; } Property Value bool IsFinite True if the box is finite. public bool IsFinite { get; } Property Value bool IsReversedPoleBox True if the box is ReversedPoleBox public bool IsReversedPoleBox { get; } Property Value bool Max Maximum point of the box. public Vec2d Max { get; set; } Property Value Vec2d Min Minimum point of the box. public Vec2d Min { get; set; } Property Value Vec2d NaN Generate a nan box which min~max is (nan,nan,nan)~(nan,nan,nan). public static Box2d NaN { get; } Property Value Box2d NativeByteSize Gets the size in bytes of the native representation of this box. public static int NativeByteSize { get; } Property Value int ReversedPoleBox Generate a reversed pole box which min~max is (∞,∞,∞)~(-∞,-∞,-∞). public static Box2d ReversedPoleBox { get; } Property Value Box2d UnitBox Generate a unit box which min~max is (0,0,0)~(1,1,1). public static Box2d UnitBox { get; } Property Value Box2d Volume Gets the volume (area) of this box. public double Volume { get; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string ZeroBox Generate a zero box which min~max is (0,0,0)~(0,0,0). public static Box2d ZeroBox { get; } Property Value Box2d Methods ApexAt(int) Get Apex at the box. public Vec2d ApexAt(int index) Parameters index int index 0~7. all of 8 apex. Returns Vec2d Equals(Box2d) Indicates whether the current object is equal to another object of the same type. public bool Equals(Box2d other) Parameters other Box2d An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. Expand(Box2d) Expands this box to include the specified box. public Box2d Expand(Box2d src) Parameters src Box2d The box to include. Returns Box2d This box instance after expansion. Expand(Vec2d) Expands this box to include the specified point. public Box2d Expand(Vec2d p) Parameters p Vec2d The point to include in the box. Returns Box2d This box instance after expansion. ExpandToBox2d(Box2d) Expands the specified destination box to include this box. public void ExpandToBox2d(Box2d dst) Parameters dst Box2d The destination box to expand. GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. IsOverlapped(Box2d) Is the box overlapped to otherBox. public bool IsOverlapped(Box2d otherBox) Parameters otherBox Box2d other box Returns bool is overlapped MakeXmlSource(string) public XElement MakeXmlSource(string baseDirectory) Parameters baseDirectory string Returns XElement ReadBin(BinaryReader) Reads binary data to initialize the object. public void ReadBin(BinaryReader reader) Parameters reader BinaryReader The binary reader to read from Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Scale(double) Scale the box from the coordinate origin. The operation is equal to: Min *= s; Max *= s; public Box2d Scale(double s) Parameters s double scale Returns Box2d this ScaleFromCenter(double) Scales this box from its center by the specified factor. public Box2d ScaleFromCenter(double s) Parameters s double The scale factor. Returns Box2d This box instance after scaling. Set(Box2d) Copy the src. The Min and Max are kept the same object. Only the double values changed. public Box2d Set(Box2d src) Parameters src Box2d src Returns Box2d this Set(box2d) Copy the src. The Min and Max are kept the same object. Only the double values changed. public Box2d Set(box2d src) Parameters src box2d src Returns Box2d this Set(double, double, double, double) Sets the minimum and maximum coordinates of this box. public Box2d Set(double minx, double miny, double maxx, double maxy) Parameters minx double The minimum X coordinate. miny double The minimum Y coordinate. maxx double The maximum X coordinate. maxy double The maximum Y coordinate. Returns Box2d This box instance. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. ToString(string, IFormatProvider) Returns a string representation of the box formatted according to the specified format. public string ToString(string format, IFormatProvider formatProvider) Parameters format string The format to use for each component formatProvider IFormatProvider The format provider to use Returns string A formatted string representation of the box Translate(Vec2d) Translate the box. public Box2d Translate(Vec2d vec) Parameters vec Vec2d translation vector Returns Box2d this WriteBin(BinaryWriter) Writes the box data to a binary writer. public void WriteBin(BinaryWriter writer) Parameters writer BinaryWriter The binary writer to write the data to."
  },
  "api/Hi.Geom.Box3d.NoInit.html": {
    "href": "api/Hi.Geom.Box3d.NoInit.html",
    "title": "Class Box3d.NoInit | HiAPI-C# 2025",
    "summary": "Class Box3d.NoInit Namespace Hi.Geom Assembly HiGeom.dll Flag for calling Box3d(NoInit). public class Box3d.NoInit Inheritance object Box3d.NoInit Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Geom.Box3d.html": {
    "href": "api/Hi.Geom.Box3d.html",
    "title": "Class Box3d | HiAPI-C# 2025",
    "summary": "Class Box3d Namespace Hi.Geom Assembly HiGeom.dll Lightweight 3d box. An orthogonal box which the edges are all parallel with Cartesian Coordinate. The data contains in a Box3d is Min and Max. public class Box3d : IExpandToBox3d, IEquatable<Box3d>, IStlSource, IGetStl, IMakeXmlSource, IBinaryIo, IWriteBin, IDuplicate, IFormattable, IToPresentDto Inheritance object Box3d Implements IExpandToBox3d IEquatable<Box3d> IStlSource IGetStl IMakeXmlSource IBinaryIo IWriteBin IDuplicate IFormattable IToPresentDto Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods BinIoUtil.ToBytes(IWriteBin) XmlUtil.MakeXmlSourceToFile(IMakeXmlSource, string, bool) XmlUtil.MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) XmlUtil.SaveToByteArrayAsync(IMakeXmlSource, string) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) GeomUtil.ExpandToBox3d(IExpandToBox3d, Mat4d, Box3d) GeomUtil.GetBox3d(IExpandToBox3d) PairZrUtil.GetZrList(IGetStl) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Box3d() Ctor. public Box3d() Box3d(NoInit) Ctor. The Ctor keeps Min and Max to null. public Box3d(Box3d.NoInit noInit) Parameters noInit Box3d.NoInit Box3d(params IExpandToBox3d[]) Creates a box that encompasses all the provided expandable objects. public Box3d(params IExpandToBox3d[] src) Parameters src IExpandToBox3d[] Array of objects that can expand to a box Box3d(Vec3d, Vec3d) Ctor. public Box3d(Vec3d min, Vec3d max) Parameters min Vec3d Min max Vec3d Max Box3d(box3d) Ctor. public Box3d(box3d src) Parameters src box3d src Box3d(IEnumerable<IExpandToBox3d>) Creates a box that encompasses all the provided expandable objects. public Box3d(IEnumerable<IExpandToBox3d> src) Parameters src IEnumerable<IExpandToBox3d> Collection of objects that can expand to a box Box3d(double, double, double, double, double, double) Creates a box with the specified minimum and maximum coordinates. public Box3d(double minx, double miny, double minz, double maxx, double maxy, double maxz) Parameters minx double Minimum X coordinate miny double Minimum Y coordinate minz double Minimum Z coordinate maxx double Maximum X coordinate maxy double Maximum Y coordinate maxz double Maximum Z coordinate Box3d(BinaryReader) Creates a box from binary data. public Box3d(BinaryReader reader) Parameters reader BinaryReader Binary reader to read the box data from Box3d(XElement) Ctor. public Box3d(XElement src) Parameters src XElement XML Properties BottomCenter Center of the bottom surface. public Vec3d BottomCenter { get; } Property Value Vec3d BottomView Gets a transformation matrix for viewing the box from the bottom. public Mat4d BottomView { get; } Property Value Mat4d Center Center public Vec3d Center { get; } Property Value Vec3d CenterUnitBox Generate a center unit box which min~max is (-0.5,-0.5,-0.5)~(0.5,0.5,0.5). public static Box3d CenterUnitBox { get; } Property Value Box3d DiagonalLength Diagonal length. public double DiagonalLength { get; } Property Value double Dim Dimension. public Vec3d Dim { get; } Property Value Vec3d FrontView Gets a transformation matrix for viewing the box from the front. public Mat4d FrontView { get; } Property Value Mat4d HasVolume Checks if the box has a positive volume (all dimensions are greater than zero). public bool HasVolume { get; } Property Value bool InfiniteBox Generate a infinite box which min~max is (-∞,-∞,-∞)~(∞,∞,∞). public static Box3d InfiniteBox { get; } Property Value Box3d IsAllNaN True if all components of Min and Max are NaN. public bool IsAllNaN { get; } Property Value bool IsFinite True if the box is finite. public bool IsFinite { get; } Property Value bool IsReversedPoleBox True if the box is ReversedPoleBox public bool IsReversedPoleBox { get; } Property Value bool IsometricView Gets a transformation matrix for viewing the box from an isometric perspective. public Mat4d IsometricView { get; } Property Value Mat4d LeftSideView Gets a transformation matrix for viewing the box from the left side. public Mat4d LeftSideView { get; } Property Value Mat4d Max Maximum point of the box. public Vec3d Max { get; set; } Property Value Vec3d Min Minimum point of the box. public Vec3d Min { get; set; } Property Value Vec3d NaN Generate a nan box which min~max is (nan,nan,nan)~(nan,nan,nan). public static Box3d NaN { get; } Property Value Box3d NativeByteSize Gets the native byte size of a Box3d (2 Vec3d objects). public static int NativeByteSize { get; } Property Value int RearView Gets a transformation matrix for viewing the box from the rear. public Mat4d RearView { get; } Property Value Mat4d ReversedPoleBox Generate a reversed pole box which min~max is (∞,∞,∞)~(-∞,-∞,-∞). public static Box3d ReversedPoleBox { get; } Property Value Box3d RightSideView Gets a transformation matrix for viewing the box from the right side. public Mat4d RightSideView { get; } Property Value Mat4d TopCenter Center of the top surface. public Vec3d TopCenter { get; } Property Value Vec3d TopView Gets a transformation matrix for viewing the box from the top. public Mat4d TopView { get; } Property Value Mat4d UnitBox Generate a unit box which min~max is (0,0,0)~(1,1,1). public static Box3d UnitBox { get; } Property Value Box3d Volume Gets the volume of the box. public double Volume { get; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string ZeroBox Generate a zero box which min~max is (0,0,0)~(0,0,0). public static Box3d ZeroBox { get; } Property Value Box3d Methods ApexAt(int) Get Apex at the box. public Vec3d ApexAt(int index) Parameters index int index 0~7. all of 8 apex. Returns Vec3d Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object Equals(Box3d) Indicates whether the current object is equal to another object of the same type. public bool Equals(Box3d other) Parameters other Box3d An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. Expand(Box3d) Expands this box to include another box. public Box3d Expand(Box3d src) Parameters src Box3d The box to include Returns Box3d This box after expansion Expand(Vec3d) Expands the box to include the specified point. public Box3d Expand(Vec3d p) Parameters p Vec3d Point to include in the box Returns Box3d This box after expansion Expand(IEnumerable<Vec3d>) Expands the box to include all specified points. public Box3d Expand(IEnumerable<Vec3d> ps) Parameters ps IEnumerable<Vec3d> The points to include in the box. Returns Box3d This box after expansion. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. GetStl() Generate Stl. public Stl GetStl() Returns Stl stl GetTransformedBoundingBox(Mat4d) Get the bounding box of the transformed box. public Box3d GetTransformedBoundingBox(Mat4d mat) Parameters mat Mat4d matrix Returns Box3d GetTris(ICollection<Tri3d>) Generates triangles representing the box's surfaces. public int GetTris(ICollection<Tri3d> dst) Parameters dst ICollection<Tri3d> Collection to add the triangles to Returns int The number of triangles added (12) IsOverlapped(Box3d) Is the box overlapped to otherBox. public bool IsOverlapped(Box3d otherBox) Parameters otherBox Box3d other box Returns bool is overlapped MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. MemberAt(int) Get member at the location. public Vec3d MemberAt(int iter) Parameters iter int iterator Returns Vec3d Minif iter is 0; otherwise, return Max ReadBin(BinaryReader) Reads box data from a binary reader. public void ReadBin(BinaryReader reader) Parameters reader BinaryReader Binary reader to read the box data from Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ScaleFromCenter(double) Scales the box from its center point. public Box3d ScaleFromCenter(double s) Parameters s double Scale factor Returns Box3d This box after scaling Set(Box3d) Copy the src. The Min and Max are kept the same object. Only the double values changed. public Box3d Set(Box3d src) Parameters src Box3d src Returns Box3d this Set(box3d) Copy the src. The Min and Max are kept the same object. Only the double values changed. public Box3d Set(box3d src) Parameters src box3d src Returns Box3d this Set(double, double, double, double, double, double) Sets the box coordinates to the specified values. public Box3d Set(double minx, double miny, double minz, double maxx, double maxy, double maxz) Parameters minx double Minimum X coordinate miny double Minimum Y coordinate minz double Minimum Z coordinate maxx double Maximum X coordinate maxy double Maximum Y coordinate maxz double Maximum Z coordinate Returns Box3d This box after modification SetToTransformedBoundingBox(Mat4d) Set the box to the bounding box of the matrix-transformed box. public Box3d SetToTransformedBoundingBox(Mat4d mat) Parameters mat Mat4d matrix Returns Box3d this ToPresentDto() Convert Box3d to presentation DTO (Data Transfer Object) for JSON serialization. The returned object includes type metadata for web API presentation. public object ToPresentDto() Returns object DTO dictionary with Type, Min, Max keys ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. ToString(string, IFormatProvider) Returns a string representation of the box formatted according to the specified format. public string ToString(string format, IFormatProvider formatProvider) Parameters format string The format to use for each component formatProvider IFormatProvider The format provider to use Returns string A formatted string representation of the box Translate(Vec3d) Translate the box. public Box3d Translate(Vec3d vec) Parameters vec Vec3d translation vector Returns Box3d this WriteBin(BinaryWriter) Writes box data to a binary writer. public void WriteBin(BinaryWriter writer) Parameters writer BinaryWriter Binary writer to write the box data to"
  },
  "api/Hi.Geom.Cylindroid.html": {
    "href": "api/Hi.Geom.Cylindroid.html",
    "title": "Class Cylindroid | HiAPI-C# 2025",
    "summary": "Class Cylindroid Namespace Hi.Geom Assembly HiGeom.dll 3d Geometry of Cylindroid. public class Cylindroid : IStlSource, IGetStl, IMakeXmlSource, IExpandToBox3d, IGetZrContour, IDuplicate, IGetZrList, IGenStl, IToPresentDto Inheritance object Cylindroid Implements IStlSource IGetStl IMakeXmlSource IExpandToBox3d IGetZrContour IDuplicate IGetZrList IGenStl IToPresentDto Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods XmlUtil.MakeXmlSourceToFile(IMakeXmlSource, string, bool) XmlUtil.MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) XmlUtil.SaveToByteArrayAsync(IMakeXmlSource, string) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) GeomUtil.ExpandToBox3d(IExpandToBox3d, Mat4d, Box3d) GeomUtil.GetBox3d(IExpandToBox3d) PairZrUtil.GetZrList(IGetStl) PairZrUtil.GetVolume(IGetZrList) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Cylindroid() Initializes a new instance of the Cylindroid class with an empty list of PairZr objects. public Cylindroid() Cylindroid(Cylindroid) Initializes a new instance of the Cylindroid class by copying another Cylindroid. public Cylindroid(Cylindroid src) Parameters src Cylindroid The source Cylindroid to copy from. Cylindroid(params PairZr[]) Ctor. The order of z values should be from small to large in general case. public Cylindroid(params PairZr[] pairZRs) Parameters pairZRs PairZr[] See PairZrs. Cylindroid(XElement) Ctor. public Cylindroid(XElement src) Parameters src XElement XML Fields ProfileTolerance_mm Profile snapping tolerance (mm) used by GenStl(IPolarResolution2d): a radius within it is the axis, and a point within it of the previous kept point is a duplicate. Authoring tools emit such points — e.g. a chamfer tip stored as (0, 0), (0, 4.4e-16) — and a duplicate would revolve into a ring of zero-area triangles. The exact-arithmetic sweep in the native core cannot orient a zero-area triangle (its cross product reduces to the zero vector) and aborts the process, so the mesh must never carry one. public const double ProfileTolerance_mm = 1E-09 Field Value double Properties DefaultPolarResolution2d Default polar resolution. public static IPolarResolution2d DefaultPolarResolution2d { get; set; } Property Value IPolarResolution2d PairZrs ZR values. The order of z values should be from small to large in general case. public List<PairZr> PairZrs { get; set; } Property Value List<PairZr> UnitCylinder Generate a cylindroid that height is 1 and radius is 0.5. public static Cylindroid UnitCylinder { get; } Property Value Cylindroid XName Name for XML IO. public static string XName { get; } Property Value string Methods Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GenCylinder(double, double) Generates a cylinder with the specified height and radius. public static Cylindroid GenCylinder(double height, double r) Parameters height double The height of the cylinder. r double The radius of the cylinder. Returns Cylindroid A new Cylindroid representing the cylinder. GenStl(IPolarResolution2d) Generates a new STL. public Stl GenStl(IPolarResolution2d resolution) Parameters resolution IPolarResolution2d Polar resolution Returns Stl A newly created STL. GetStl() Gets the STL mesh at DefaultPolarResolution2d. Resolution-aware callers pass their value through GenStl(IPolarResolution2d) instead. public Stl GetStl() Returns Stl The STL mesh at the default resolution. GetZrContour(double) Gets Z-R contour data as a list of PairZr objects. The Z values should generally be ordered from smallest to largest. public IList<PairZr> GetZrContour(double latitudeAngleResolution_rad) Parameters latitudeAngleResolution_rad double Resolution of latitude angle in radians Returns IList<PairZr> Z-R contour data as a list of PairZr objects GetZrList() Gets a list of Z-R coordinate pairs. public List<PairZr> GetZrList() Returns List<PairZr> A list of PairZr objects representing Z-R coordinates. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. NormalizeProfile(IEnumerable<PairZr>) Returns src with radii within ProfileTolerance_mm of the axis snapped to 0 and consecutive points within that tolerance of each other merged. public static List<PairZr> NormalizeProfile(IEnumerable<PairZr> src) Parameters src IEnumerable<PairZr> Returns List<PairZr> Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToPresentDto() Convert Cylindroid to presentation DTO (Data Transfer Object) for JSON serialization. The returned object includes type metadata for web API presentation. public object ToPresentDto() Returns object DTO dictionary with Type and PairZrs keys"
  },
  "api/Hi.Geom.DVec3d.html": {
    "href": "api/Hi.Geom.DVec3d.html",
    "title": "Class DVec3d | HiAPI-C# 2025",
    "summary": "Class DVec3d Namespace Hi.Geom Assembly HiGeom.dll Dual Vec3d with p(Vec3d) and n(Vec3d). public class DVec3d : IEquatable<DVec3d>, IWriteBin, IEqualityOperators<DVec3d, DVec3d, bool>, IAdditionOperators<DVec3d, DVec3d, DVec3d>, ISubtractionOperators<DVec3d, DVec3d, DVec3d>, IMultiplyOperators<DVec3d, double, DVec3d>, IMultiplyOperators<DVec3d, Mat4d, DVec3d>, IDivisionOperators<DVec3d, double, DVec3d>, IVec<double>, IFormattable Inheritance object DVec3d Implements IEquatable<DVec3d> IWriteBin IEqualityOperators<DVec3d, DVec3d, bool> IAdditionOperators<DVec3d, DVec3d, DVec3d> ISubtractionOperators<DVec3d, DVec3d, DVec3d> IMultiplyOperators<DVec3d, double, DVec3d> IMultiplyOperators<DVec3d, Mat4d, DVec3d> IDivisionOperators<DVec3d, double, DVec3d> IVec<double> IFormattable Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods BinIoUtil.ToBytes(IWriteBin) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors DVec3d() Ctor. The members are initialized to null. public DVec3d() DVec3d(DVec3d, bool) Initializes a new instance of the DVec3d class by copying another DVec3d. public DVec3d(DVec3d src, bool shareFields = false) Parameters src DVec3d The source DVec3d to copy from. shareFields bool If true, references to the source Point and Normal are used; otherwise, new instances are created with copied values. DVec3d(Mat4d) Ctor. set mat[12] to Point.x; set mat[13] to Point.y; set mat[14] to Point.z; set mat[8] to Normal.x; set mat[9] to Normal.y; set mat[10] to Normal.z; public DVec3d(Mat4d mat) Parameters mat Mat4d matrix DVec3d(Vec3d, Vec3d) Ctor. public DVec3d(Vec3d p, Vec3d n) Parameters p Vec3d Point n Vec3d Normal DVec3d(IEnumerable<double>) Initializes a new instance of the DVec3d class from an enumerable collection of doubles. public DVec3d(IEnumerable<double> src) Parameters src IEnumerable<double> The source collection containing at least 6 double values. The first 3 values initialize the Point, and the last 3 values initialize the Normal. DVec3d(double, double, double, double, double, double) Ctor. public DVec3d(double px, double py, double pz, double nx, double ny, double nz) Parameters px double Point.x py double Point.y pz double Point.z nx double Normal.x ny double Normal.y nz double Normal.z DVec3d(double[]) Ctor. public DVec3d(double[] src) Parameters src double[] Array elements 0,1,2 initialize Point x,y,z; Array elements 3,4,5 initialize Point x,y,z DVec3d(Func<int, double>) Initializes a new instance of the DVec3d class using a function that maps indices to values. public DVec3d(Func<int, double> dirToValueFunc) Parameters dirToValueFunc Func<int, double> A function that takes an index (0-5) and returns the corresponding coordinate value. Indices 0-2 are for Point coordinates, and 3-5 are for Normal coordinates. DVec3d(BinaryReader) Initializes a new instance of the DVec3d class from binary data. public DVec3d(BinaryReader reader) Parameters reader BinaryReader The binary reader to read the data from. DVec3d(string) Ctor. The reading format is ((x,y,z),(x,y,z)), the first xyz is for Point; the second xyz is for Normal. public DVec3d(string str) Parameters str string string See Also ToString() Properties ElementNum Element number: 6 for (Point(x,y,z),Normal(x,y,z)). public static int ElementNum { get; } Property Value int IsAllNaN Gets a value indicating whether all components of both Point and Normal are NaN. public bool IsAllNaN { get; } Property Value bool IsFinite Gets a value indicating whether all components of both Point and Normal are finite. public bool IsFinite { get; } Property Value bool this[int] Gets or sets the element at the specified index. public double this[int index] { get; set; } Parameters index int The zero-based index of the element to get or set. Property Value double The element at the specified index. NaN Gets a DVec3d with all components set to NaN. public static DVec3d NaN { get; } Property Value DVec3d Normal Normal. public Vec3d Normal { get; set; } Property Value Vec3d Point Point. public Vec3d Point { get; set; } Property Value Vec3d Rank Dimension (i.e. Size) of the Vector. public int Rank { get; } Property Value int Zero Gets a DVec3d with all components set to zero. public static DVec3d Zero { get; } Property Value DVec3d Methods At(int) Gets a reference to the component at the specified index. public ref double At(int dir) Parameters dir int The index of the component to access (0-5). Indices 0-2 access Point coordinates (x,y,z), and indices 3-5 access Normal coordinates (x,y,z). Returns double A reference to the specified component. Enumerate() For each. Point first. Normal second. public IEnumerable<double> Enumerate() Returns IEnumerable<double> Equals(DVec3d) Indicates whether the current object is equal to another object of the same type. public bool Equals(DVec3d other) Parameters other DVec3d An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. GenNaN() Creates a new DVec3d with all components set to NaN. public static DVec3d GenNaN() Returns DVec3d A new DVec3d with all components set to NaN. GenZero() Creates a new DVec3d with all components set to zero. public static DVec3d GenZero() Returns DVec3d A new DVec3d with all components set to zero. GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. Interpolate(DVec3d, DVec3d, double) Interpolates between two DVec3d instances. public static DVec3d Interpolate(DVec3d a, DVec3d b, double ratio) Parameters a DVec3d The first DVec3d. b DVec3d The second DVec3d. ratio double The interpolation ratio (0.0 to 1.0). Returns DVec3d A new DVec3d interpolated between a and b. Set(DVec3d, bool) Sets the values of this instance from another DVec3d. public void Set(DVec3d src, bool shareFields = false) Parameters src DVec3d The source DVec3d to copy values from. shareFields bool If true, references to the source Point and Normal are used; otherwise, their values are copied. Set(double, double, double, double, double, double) Call Point.Set(double, double, double) and Normal.Set(double, double, double) to set the values. public void Set(double px, double py, double pz, double nx, double ny, double nz) Parameters px double Point.x py double Point.y pz double Point.z nx double Normal.x ny double Normal.y nz double Normal.z Remarks If the Point or Normal is null, the function will corrupt. SetEachValueAbs() Sets each component of both Point and Normal to its absolute value. public DVec3d SetEachValueAbs() Returns DVec3d This instance after the operation. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. ToString(string) Returns a string representation of this DVec3d using the specified format for component values. public string ToString(string format) Parameters format string The format string to use for component values. Returns string A string representation of this DVec3d. ToString(string, IFormatProvider) Returns a string representation of the dual vector formatted according to the specified format. public string ToString(string format, IFormatProvider formatProvider) Parameters format string The format to use for each component formatProvider IFormatProvider The format provider to use Returns string A formatted string representation of the dual vector WriteBin(BinaryWriter) Writes the object's data to a binary stream. public void WriteBin(BinaryWriter writer) Parameters writer BinaryWriter The binary writer to write to Operators operator +(DVec3d, DVec3d) Adds two values together to compute their sum. public static DVec3d operator +(DVec3d a, DVec3d b) Parameters a DVec3d b DVec3d Returns DVec3d The sum of left and right. operator /(DVec3d, double) Divides one value by another to compute their quotient. public static DVec3d operator /(DVec3d src, double s) Parameters src DVec3d s double Returns DVec3d The quotient of left divided by right. operator ==(DVec3d, DVec3d) Compares two values to determine equality. public static bool operator ==(DVec3d left, DVec3d right) Parameters left DVec3d The value to compare with right. right DVec3d The value to compare with left. Returns bool true if left is equal to right; otherwise, false. operator !=(DVec3d, DVec3d) Compares two values to determine inequality. public static bool operator !=(DVec3d left, DVec3d right) Parameters left DVec3d The value to compare with right. right DVec3d The value to compare with left. Returns bool true if left is not equal to right; otherwise, false. operator *(DVec3d, Mat4d) Multiplies two values together to compute their product. public static DVec3d operator *(DVec3d a, Mat4d b) Parameters a DVec3d b Mat4d Returns DVec3d The product of left multiplied by right. operator *(DVec3d, double) Multiplies two values together to compute their product. public static DVec3d operator *(DVec3d src, double s) Parameters src DVec3d s double Returns DVec3d The product of left multiplied by right. operator -(DVec3d, DVec3d) Subtracts two values to compute their difference. public static DVec3d operator -(DVec3d a, DVec3d b) Parameters a DVec3d b DVec3d Returns DVec3d The value of right subtracted from left. operator -(DVec3d) Create a negate DVec3d. The field objects are created, i.e. the field objects are not shared with this. public static DVec3d operator -(DVec3d src) Parameters src DVec3d src Returns DVec3d negate DVec3d"
  },
  "api/Hi.Geom.Dir.html": {
    "href": "api/Hi.Geom.Dir.html",
    "title": "Enum Dir | HiAPI-C# 2025",
    "summary": "Enum Dir Namespace Hi.Geom Assembly HiGeom.dll Enumeration of coordinate axis directions in 3D space. public enum Dir Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields X = 0 X-axis direction (index 0). Y = 1 Y-axis direction (index 1). Z = 2 Z-axis direction (index 2)."
  },
  "api/Hi.Geom.ExtendedCylinder.html": {
    "href": "api/Hi.Geom.ExtendedCylinder.html",
    "title": "Class ExtendedCylinder | HiAPI-C# 2025",
    "summary": "Class ExtendedCylinder Namespace Hi.Geom Assembly HiGeom.dll An extensible cylinder geometry that generates a corresponding Cylindroid by the start section and the total length. public class ExtendedCylinder : IStlSource, IGetStl, IExpandToBox3d, IGetZrContour, IDuplicate, IGetZrList, IGenStl, IMakeXmlSource, IToXElement Inheritance object ExtendedCylinder Implements IStlSource IGetStl IExpandToBox3d IGetZrContour IDuplicate IGetZrList IGenStl IMakeXmlSource IToXElement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods XmlUtil.MakeXmlSourceToFile(IMakeXmlSource, string, bool) XmlUtil.MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) XmlUtil.SaveToByteArrayAsync(IMakeXmlSource, string) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) GeomUtil.ExpandToBox3d(IExpandToBox3d, Mat4d, Box3d) GeomUtil.GetBox3d(IExpandToBox3d) PairZrUtil.GetZrList(IGetStl) PairZrUtil.GetVolume(IGetZrList) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ExtendedCylinder() Initializes a new instance of the ExtendedCylinder class. public ExtendedCylinder() ExtendedCylinder(double, Func<PairZr>) Initializes a new instance with the specified total length and start section provider. public ExtendedCylinder(double fullLength, Func<PairZr> beginPairZrSource = null) Parameters fullLength double Total length beginPairZrSource Func<PairZr> Start section provider ExtendedCylinder(XElement) Initializes a new instance of the ExtendedCylinder class from XML data. public ExtendedCylinder(XElement src) Parameters src XElement The XML element containing extended cylinder data. Properties BeginPairZrSource The provider of the starting ZR section. public Func<PairZr> BeginPairZrSource { get; set; } Property Value Func<PairZr> Cylindroid Returns a Cylindroid view generated from current settings. public Cylindroid Cylindroid { get; } Property Value Cylindroid FullLength The total length of the cylinder along the Z-axis. public double FullLength { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GenStl(IPolarResolution2d) Generates a new STL. public Stl GenStl(IPolarResolution2d resolution) Parameters resolution IPolarResolution2d Polar resolution Returns Stl A newly created STL. GetStl() Gets the STL mesh at the generated cylindroid's default resolution. Resolution-aware callers pass their value through GenStl(IPolarResolution2d) instead. public Stl GetStl() Returns Stl The STL mesh at the default resolution. GetZrContour(double) Gets Z-R contour data as a list of PairZr objects. The Z values should generally be ordered from smallest to largest. public IList<PairZr> GetZrContour(double latitudeAngleResolution_rad) Parameters latitudeAngleResolution_rad double Resolution of latitude angle in radians Returns IList<PairZr> Z-R contour data as a list of PairZr objects GetZrList() Gets a list of Z-R coordinate pairs. public List<PairZr> GetZrList() Returns List<PairZr> A list of PairZr objects representing Z-R coordinates. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.Geom.Flat3d.html": {
    "href": "api/Hi.Geom.Flat3d.html",
    "title": "Class Flat3d | HiAPI-C# 2025",
    "summary": "Class Flat3d Namespace Hi.Geom Assembly HiGeom.dll Represents a 3D plane defined by a unit normal vector and its signed distance from the origin. The plane equation is: Ax + By + Cz + d = 0, where (A,B,C) is the normal vector and d is the distance to origin. public class Flat3d : IFlat3d, IBinaryIo, IWriteBin, IEquatable<Flat3d> Inheritance object Flat3d Implements IFlat3d IBinaryIo IWriteBin IEquatable<Flat3d> Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods BinIoUtil.ToBytes(IWriteBin) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Flat3d() Initializes a new instance of the Flat3d class. public Flat3d() Flat3d(IFlat3d) Copy constructor. public Flat3d(IFlat3d src) Parameters src IFlat3d Source plane Flat3d(Vec3d, double) Initializes a new instance of the Flat3d class with a normal vector and distance to origin. public Flat3d(Vec3d normal, double distanceToOrigin) Parameters normal Vec3d The unit normal vector of the plane. distanceToOrigin double The signed distance from origin to the plane. Properties DistanceToOrigin The signed distance from the origin (0,0,0) to this plane. A positive distance means the origin is on the same side as the normal vector. public double DistanceToOrigin { get; set; } Property Value double Normal The unit normal to the plane. public Vec3d Normal { get; set; } Property Value Vec3d Methods DistanceTo(Vec3d) Gets the distance from a point to this plane. public double DistanceTo(Vec3d point) Parameters point Vec3d The point to calculate distance to. Returns double The signed distance from the point to the plane. Equals(Flat3d) Indicates whether the current object is equal to another object of the same type. public bool Equals(Flat3d other) Parameters other Flat3d An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. FromPointAndNormal(Vec3d, Vec3d) Creates a plane from a point and normal vector. public static Flat3d FromPointAndNormal(Vec3d point, Vec3d normal) Parameters point Vec3d A point on the plane. normal Vec3d The normal vector of the plane. Returns Flat3d A new plane instance. GetDistanceToOrigin() Signed Distance To Origin. public double GetDistanceToOrigin() Returns double Signed Distance To Origin. GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. GetLocate() Gets a point on the plane closest to the origin. public Vec3d GetLocate() Returns Vec3d GetNormal() Gets the normal vector of the flat surface. public Vec3d GetNormal() Returns Vec3d The unit normal vector ProjectPoint(Vec3d) Projects a point onto this plane. public Vec3d ProjectPoint(Vec3d point) Parameters point Vec3d The point to project. Returns Vec3d The projected point on the plane. ReadBin(BinaryReader) Reads binary data to initialize the object. public void ReadBin(BinaryReader reader) Parameters reader BinaryReader The binary reader to read from ToString() Returns a string representation of the plane. public override string ToString() Returns string WriteBin(BinaryWriter) Writes the object's data to a binary stream. public void WriteBin(BinaryWriter writer) Parameters writer BinaryWriter The binary writer to write to"
  },
  "api/Hi.Geom.Fraction-1.html": {
    "href": "api/Hi.Geom.Fraction-1.html",
    "title": "Struct Fraction<TEva> | HiAPI-C# 2025",
    "summary": "Struct Fraction<TEva> Namespace Hi.Geom Assembly HiDisp.dll Pure C# unlimited precision fraction. public struct Fraction<TEva> : IComparable<Fraction<TEva>>, IEquatable<Fraction<TEva>> where TEva : struct, INumber<TEva> Type Parameters TEva Evaluated floating point type (e.g. double, decimal). Implements IComparable<Fraction<TEva>> IEquatable<Fraction<TEva>> Inherited Members object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) MathUtil.Clamp<T>(T, T, T) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks A fraction consists of a numerator and denominator using BigInteger. The fraction may be not packed or not evaluated. However, all fraction numerator and denominator are singular managed and denominator is never negative. Design mirrors geom::fraction_t<0, EvaType> in CppCore. Constructors Fraction() Initializes a zero fraction (0/0, status=None). public Fraction() Fraction(long) Initializes a fraction with integer value. public Fraction(long num) Parameters num long The integer value. Fraction(long, long) Initializes a fraction with numerator and denominator. public Fraction(long num, long den) Parameters num long The numerator. den long The denominator. Fraction(BigInteger) Initializes a fraction with integer value. public Fraction(BigInteger num) Parameters num BigInteger The integer value. Fraction(BigInteger, BigInteger) Initializes a fraction with numerator and denominator. public Fraction(BigInteger num, BigInteger den) Parameters num BigInteger The numerator. den BigInteger The denominator. Properties CeilInt Gets the ceiling integer value. public readonly int CeilInt { get; } Property Value int Denominator Gets or sets the denominator. public BigInteger Denominator { readonly get; set; } Property Value BigInteger FloorInt Gets the floor integer value. public readonly int FloorInt { get; } Property Value int IsEvaluated Gets whether the fraction value has been evaluated. public readonly bool IsEvaluated { get; } Property Value bool IsFinite Gets whether the fraction is finite (denominator != 0). public readonly bool IsFinite { get; } Property Value bool IsNaN Gets whether the fraction is NaN (0/0). public readonly bool IsNaN { get; } Property Value bool IsPacked Gets whether the fraction is packed (reduced to irreducible form). public readonly bool IsPacked { get; } Property Value bool IsZero Gets whether the fraction is zero (numerator == 0 and denominator != 0). public readonly bool IsZero { get; } Property Value bool NaN NaN fraction (0/0). public static Fraction<TEva> NaN { get; } Property Value Fraction<TEva> NegativeInf Negative infinity fraction (-1/0). public static Fraction<TEva> NegativeInf { get; } Property Value Fraction<TEva> Numerator Gets or sets the numerator. public BigInteger Numerator { readonly get; set; } Property Value BigInteger One One fraction (1/1). public static Fraction<TEva> One { get; } Property Value Fraction<TEva> PositiveInf Positive infinity fraction (1/0). public static Fraction<TEva> PositiveInf { get; } Property Value Fraction<TEva> RoughValue Gets the roughly evaluated value. If the data has not been reduced, the return value is not evaluated by the reduced numbers. public TEva RoughValue { get; } Property Value TEva Sign Gets the sign of the fraction (-1, 0, or 1). public readonly int Sign { get; } Property Value int Status Gets the status flags. public readonly FractionStatus Status { get; } Property Value FractionStatus Value Gets the evaluated value. Computes the value if not yet evaluated. public TEva Value { get; } Property Value TEva Zero Zero fraction (0/1). public static Fraction<TEva> Zero { get; } Property Value Fraction<TEva> Methods Abs() Gets the absolute value as a new fraction. public readonly Fraction<TEva> Abs() Returns Fraction<TEva> CompareTo(Fraction<TEva>) Compares this fraction with another. public readonly int CompareTo(Fraction<TEva> other) Parameters other Fraction<TEva> The other fraction. Returns int -1 if less, 0 if equal, 1 if greater. Equals(Fraction<TEva>) Indicates whether the current object is equal to another object of the same type. public readonly bool Equals(Fraction<TEva> other) Parameters other Fraction<TEva> An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Indicates whether this instance and a specified object are equal. public override readonly bool Equals(object obj) Parameters obj object The object to compare with the current instance. Returns bool true if obj and this instance are the same type and represent the same value; otherwise, false. Evaluate() Evaluates the value if not already evaluated. public Fraction<TEva> Evaluate() Returns Fraction<TEva> This instance for chaining. GetHashCode() Returns the hash code for this instance. public override int GetHashCode() Returns int A 32-bit signed integer that is the hash code for this instance. Negate() Negates this fraction in place. public Fraction<TEva> Negate() Returns Fraction<TEva> This instance for chaining. Pack() Packs (reduces) the fraction to irreducible form if not already packed. public Fraction<TEva> Pack() Returns Fraction<TEva> This instance for chaining. PerformanceTest(int, int) Performance test for Fraction (pure C#). Test 1: Accumulative += with Val (bounded, linear growth). Test 2: Bounded arithmetic (converging average). public static void PerformanceTest(int iterations = 128, int rounds = 16) Parameters iterations int Number of steps per round. rounds int Number of rounds to average timing. Reciprocal() Gets the reciprocal as a new fraction. public readonly Fraction<TEva> Reciprocal() Returns Fraction<TEva> SetAbs() Sets this fraction to its absolute value. public Fraction<TEva> SetAbs() Returns Fraction<TEva> This instance for chaining. SetReciprocal() Sets this fraction to its reciprocal. public Fraction<TEva> SetReciprocal() Returns Fraction<TEva> This instance for chaining. SetSquare() Sets this fraction to its square. public Fraction<TEva> SetSquare() Returns Fraction<TEva> This instance for chaining. Simplify(TEva) Simplifies the fraction to the specified resolution using Stern-Brocot binary search. public Fraction<TEva> Simplify(TEva resolution) Parameters resolution TEva The resolution tolerance. Returns Fraction<TEva> This instance for chaining. Square() Gets the square as a new fraction. public readonly Fraction<TEva> Square() Returns Fraction<TEva> Test() Test function for Fraction. public static void Test() ToString() Returns the fully qualified type name of this instance. public override readonly string ToString() Returns string The fully qualified type name. Val(TEva, TEva) Creates a fraction by approximating a double value with specified resolution. Uses Stern-Brocot binary search. public static Fraction<TEva> Val(TEva val, TEva resolution) Parameters val TEva The double value to approximate. resolution TEva The resolution tolerance. Returns Fraction<TEva> The approximated fraction. Operators operator +(Fraction<TEva>, Fraction<TEva>) Addition: fraction + fraction. public static Fraction<TEva> operator +(Fraction<TEva> a, Fraction<TEva> b) Parameters a Fraction<TEva> b Fraction<TEva> Returns Fraction<TEva> operator +(Fraction<TEva>, long) Addition: fraction + integer. public static Fraction<TEva> operator +(Fraction<TEva> a, long b) Parameters a Fraction<TEva> b long Returns Fraction<TEva> operator +(long, Fraction<TEva>) Addition: integer + fraction. public static Fraction<TEva> operator +(long a, Fraction<TEva> b) Parameters a long b Fraction<TEva> Returns Fraction<TEva> operator /(Fraction<TEva>, Fraction<TEva>) Division: fraction / fraction. public static Fraction<TEva> operator /(Fraction<TEva> a, Fraction<TEva> b) Parameters a Fraction<TEva> b Fraction<TEva> Returns Fraction<TEva> operator /(Fraction<TEva>, long) Division: fraction / integer. public static Fraction<TEva> operator /(Fraction<TEva> a, long b) Parameters a Fraction<TEva> b long Returns Fraction<TEva> operator /(long, Fraction<TEva>) Division: integer / fraction. public static Fraction<TEva> operator /(long a, Fraction<TEva> b) Parameters a long b Fraction<TEva> Returns Fraction<TEva> operator ==(Fraction<TEva>, Fraction<TEva>) Equality operator. public static bool operator ==(Fraction<TEva> a, Fraction<TEva> b) Parameters a Fraction<TEva> b Fraction<TEva> Returns bool operator ==(Fraction<TEva>, long) Equality with integer. public static bool operator ==(Fraction<TEva> a, long b) Parameters a Fraction<TEva> b long Returns bool explicit operator double(Fraction<TEva>) Explicit conversion to double. public static explicit operator double(Fraction<TEva> f) Parameters f Fraction<TEva> Returns double operator >(Fraction<TEva>, Fraction<TEva>) Greater than operator. public static bool operator >(Fraction<TEva> a, Fraction<TEva> b) Parameters a Fraction<TEva> b Fraction<TEva> Returns bool operator >(Fraction<TEva>, long) Greater than integer. public static bool operator >(Fraction<TEva> a, long b) Parameters a Fraction<TEva> b long Returns bool operator >=(Fraction<TEva>, Fraction<TEva>) Greater than or equal operator. public static bool operator >=(Fraction<TEva> a, Fraction<TEva> b) Parameters a Fraction<TEva> b Fraction<TEva> Returns bool operator >=(Fraction<TEva>, long) Greater than or equal to integer. public static bool operator >=(Fraction<TEva> a, long b) Parameters a Fraction<TEva> b long Returns bool implicit operator Fraction<TEva>(int) Implicit conversion from int. public static implicit operator Fraction<TEva>(int v) Parameters v int Returns Fraction<TEva> implicit operator Fraction<TEva>(long) Implicit conversion from long. public static implicit operator Fraction<TEva>(long v) Parameters v long Returns Fraction<TEva> operator !=(Fraction<TEva>, Fraction<TEva>) Inequality operator. public static bool operator !=(Fraction<TEva> a, Fraction<TEva> b) Parameters a Fraction<TEva> b Fraction<TEva> Returns bool operator !=(Fraction<TEva>, long) Inequality with integer. public static bool operator !=(Fraction<TEva> a, long b) Parameters a Fraction<TEva> b long Returns bool operator <(Fraction<TEva>, Fraction<TEva>) Less than operator. public static bool operator <(Fraction<TEva> a, Fraction<TEva> b) Parameters a Fraction<TEva> b Fraction<TEva> Returns bool operator <(Fraction<TEva>, long) Less than integer. public static bool operator <(Fraction<TEva> a, long b) Parameters a Fraction<TEva> b long Returns bool operator <=(Fraction<TEva>, Fraction<TEva>) Less than or equal operator. public static bool operator <=(Fraction<TEva> a, Fraction<TEva> b) Parameters a Fraction<TEva> b Fraction<TEva> Returns bool operator <=(Fraction<TEva>, long) Less than or equal to integer. public static bool operator <=(Fraction<TEva> a, long b) Parameters a Fraction<TEva> b long Returns bool operator *(Fraction<TEva>, Fraction<TEva>) Multiplication: fraction * fraction. public static Fraction<TEva> operator *(Fraction<TEva> a, Fraction<TEva> b) Parameters a Fraction<TEva> b Fraction<TEva> Returns Fraction<TEva> operator *(Fraction<TEva>, long) Multiplication: fraction * integer. public static Fraction<TEva> operator *(Fraction<TEva> a, long b) Parameters a Fraction<TEva> b long Returns Fraction<TEva> operator *(long, Fraction<TEva>) Multiplication: integer * fraction. public static Fraction<TEva> operator *(long a, Fraction<TEva> b) Parameters a long b Fraction<TEva> Returns Fraction<TEva> operator -(Fraction<TEva>, Fraction<TEva>) Subtraction: fraction - fraction. public static Fraction<TEva> operator -(Fraction<TEva> a, Fraction<TEva> b) Parameters a Fraction<TEva> b Fraction<TEva> Returns Fraction<TEva> operator -(Fraction<TEva>, long) Subtraction: fraction - integer. public static Fraction<TEva> operator -(Fraction<TEva> a, long b) Parameters a Fraction<TEva> b long Returns Fraction<TEva> operator -(long, Fraction<TEva>) Subtraction: integer - fraction. public static Fraction<TEva> operator -(long a, Fraction<TEva> b) Parameters a long b Fraction<TEva> Returns Fraction<TEva> operator -(Fraction<TEva>) Negation operator. public static Fraction<TEva> operator -(Fraction<TEva> a) Parameters a Fraction<TEva> Returns Fraction<TEva>"
  },
  "api/Hi.Geom.FractionStatus.html": {
    "href": "api/Hi.Geom.FractionStatus.html",
    "title": "Enum FractionStatus | HiAPI-C# 2025",
    "summary": "Enum FractionStatus Namespace Hi.Geom Assembly HiDisp.dll Status flags for Fraction and NativeFraction. Corresponds to IS_PACKED_MASK and IS_EVALUATED_MASK in C++ fraction_base_t. [Flags] public enum FractionStatus : short Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields IsEvaluated = 2 The fraction's double value has been evaluated and cached. IsPacked = 1 The fraction has been packed (reduced to irreducible form). None = 0 No flags set. The fraction is neither packed nor evaluated."
  },
  "api/Hi.Geom.GenStlFuncHost.html": {
    "href": "api/Hi.Geom.GenStlFuncHost.html",
    "title": "Class GenStlFuncHost | HiAPI-C# 2025",
    "summary": "Class GenStlFuncHost Namespace Hi.Geom Assembly HiGeom.dll A class that hosts a function to generate STL geometry at a caller-chosen resolution. public class GenStlFuncHost : IGetStl, IGenStl Inheritance object GenStlFuncHost Implements IGetStl IGenStl Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) PairZrUtil.GetZrList(IGetStl) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors GenStlFuncHost() Default constructor. public GenStlFuncHost() GenStlFuncHost(Func<IPolarResolution2d, Stl>) Constructor with STL generator function. public GenStlFuncHost(Func<IPolarResolution2d, Stl> genStlFunc) Parameters genStlFunc Func<IPolarResolution2d, Stl> Function that generates an STL object for a given resolution Properties GenStlFunc Gets or sets the function that generates the STL object. The resolution argument may be null; the generator then applies its own default. public Func<IPolarResolution2d, Stl> GenStlFunc { get; set; } Property Value Func<IPolarResolution2d, Stl> Methods GenStl(IPolarResolution2d) Generates a new STL. public Stl GenStl(IPolarResolution2d resolution) Parameters resolution IPolarResolution2d Polar resolution Returns Stl A newly created STL. GetStl() Gets the STL geometry at the generator's default resolution. public Stl GetStl() Returns Stl The generated STL object"
  },
  "api/Hi.Geom.GeomCombination.html": {
    "href": "api/Hi.Geom.GeomCombination.html",
    "title": "Class GeomCombination | HiAPI-C# 2025",
    "summary": "Class GeomCombination Namespace Hi.Geom Assembly HiGeom.dll A class that manages multiple STL sources as a single source. public class GeomCombination : IStlSource, IGetStl, IMakeXmlSource, IGenStl, IExpandToBox3d Inheritance object GeomCombination Implements IStlSource IGetStl IMakeXmlSource IGenStl IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods XmlUtil.MakeXmlSourceToFile(IMakeXmlSource, string, bool) XmlUtil.MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) XmlUtil.SaveToByteArrayAsync(IMakeXmlSource, string) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) GeomUtil.ExpandToBox3d(IExpandToBox3d, Mat4d, Box3d) GeomUtil.GetBox3d(IExpandToBox3d) PairZrUtil.GetZrList(IGetStl) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors GeomCombination() Default constructor that initializes an empty collection of STL sources. public GeomCombination() GeomCombination(params IStlSource[]) Initializes a new instance with a set of STL sources. public GeomCombination(params IStlSource[] stlSources) Parameters stlSources IStlSource[] A set of STL sources GeomCombination(XElement, string, string, IProgress<IMessage>) Ctor. public GeomCombination(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress) Parameters src XElement XML baseDirectory string Base directory path relFile string Relative file path progress IProgress<IMessage> Optional progress reporter for the XML parsing chain Properties StlSources Collection of STL sources managed by this instance. public List<IStlSource> StlSources { get; } Property Value List<IStlSource> XName Name for XML IO. public static string XName { get; } Property Value string Methods CleanStlCache() Clears the cached STL data, forcing it to be regenerated on the next request. public void CleanStlCache() Duplicate(params object[]) public object Duplicate(params object[] res) Parameters res object[] Returns object ExpandToBox3d(Box3d) Expands the given box by the sources' own boxes. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d The box to expand. Remarks A rough, quick operation: bounds queries never generate a mesh, so a source without IExpandToBox3d support contributes nothing. GenStl(IPolarResolution2d) Generates a new STL. public Stl GenStl(IPolarResolution2d resolution) Parameters resolution IPolarResolution2d Polar resolution Returns Stl A newly created STL. GetStl() Gets the combined STL mesh with each source at its own default resolution. Resolution-aware callers pass their value through GenStl(IPolarResolution2d) instead. public Stl GetStl() Returns Stl The combined STL mesh. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Geom.GeomUtil.html": {
    "href": "api/Hi.Geom.GeomUtil.html",
    "title": "Class GeomUtil | HiAPI-C# 2025",
    "summary": "Class GeomUtil Namespace Hi.Geom Assembly HiGeom.dll Utility of Geometry. public static class GeomUtil Inheritance object GeomUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods ExpandToBox3d(IExpandToBox3d, Mat4d, Box3d) Expands the destination bounding box with the transformed bounding box of source under matrix mat. public static void ExpandToBox3d(this IExpandToBox3d src, Mat4d mat, Box3d dst) Parameters src IExpandToBox3d The source geometry mat Mat4d The transformation matrix dst Box3d The destination bounding box GetBox3d(IExpandToBox3d) Gets a Box3d representation of the specified object that implements IExpandToBox3d. public static Box3d GetBox3d(this IExpandToBox3d src) Parameters src IExpandToBox3d The source object that implements IExpandToBox3d. Returns Box3d A Box3d representation of the source object. GetNearestPointOnLineSegment(Vec2d, Vec2d, Vec2d) Get the nearest point on a line segment to a given point. public static Vec2d GetNearestPointOnLineSegment(Vec2d point, Vec2d lineStart, Vec2d lineEnd) Parameters point Vec2d The point to find the nearest point from lineStart Vec2d Start point of the line segment lineEnd Vec2d End point of the line segment Returns Vec2d The nearest point on the line segment GetNearestPointOnLineSegment(Vec3d, Vec3d, Vec3d) Get the nearest point on a line segment to a given point. public static Vec3d GetNearestPointOnLineSegment(Vec3d point, Vec3d lineStart, Vec3d lineEnd) Parameters point Vec3d The point to find the nearest point from lineStart Vec3d Start point of the line segment lineEnd Vec3d End point of the line segment Returns Vec3d The nearest point on the line segment GetRayIntersection(Vec3d, Vec3d, Vec3d, Vec3d) Calculates the intersection point of two rays in 3D space. public static Vec3d GetRayIntersection(Vec3d rayABegin, Vec3d rayAVec, Vec3d rayBBegin, Vec3d rayBVec) Parameters rayABegin Vec3d The starting point of the first ray. rayAVec Vec3d The direction vector of the first ray. rayBBegin Vec3d The starting point of the second ray. rayBVec Vec3d The direction vector of the second ray. Returns Vec3d The intersection point of the two rays, or null if they don't intersect. IntersectLineSegmentCircle(Vec2d, Vec2d, double, out Vec2d, out Vec2d) Intersect line segment and circle. public static double IntersectLineSegmentCircle(Vec2d p0, Vec2d p1, double rr, out Vec2d pA, out Vec2d pB) Parameters p0 Vec2d line segment begin point p1 Vec2d line segment end point rr double radius*radius pA Vec2d first intersect point along p0 to p1 pB Vec2d second intersect point along p0 to p1 Returns double determinant"
  },
  "api/Hi.Geom.IExpandToBox2d.html": {
    "href": "api/Hi.Geom.IExpandToBox2d.html",
    "title": "Interface IExpandToBox2d | HiAPI-C# 2025",
    "summary": "Interface IExpandToBox2d Namespace Hi.Geom Assembly HiGeom.dll Object that can be expanded to a Box2d. public interface IExpandToBox2d Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods ExpandToBox2d(Box2d) Expands the destination box. This function is usually used to compute the bounding box of elements. void ExpandToBox2d(Box2d dst) Parameters dst Box2d Destination box"
  },
  "api/Hi.Geom.IExpandToBox3d.html": {
    "href": "api/Hi.Geom.IExpandToBox3d.html",
    "title": "Interface IExpandToBox3d | HiAPI-C# 2025",
    "summary": "Interface IExpandToBox3d Namespace Hi.Geom Assembly HiGeom.dll Object that can be expanded to a Box3d. public interface IExpandToBox3d Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) GeomUtil.ExpandToBox3d(IExpandToBox3d, Mat4d, Box3d) GeomUtil.GetBox3d(IExpandToBox3d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box"
  },
  "api/Hi.Geom.IFlat3d.html": {
    "href": "api/Hi.Geom.IFlat3d.html",
    "title": "Interface IFlat3d | HiAPI-C# 2025",
    "summary": "Interface IFlat3d Namespace Hi.Geom Assembly HiGeom.dll Interface for a 3D plane that provides an anchor point and a normal vector. public interface IFlat3d Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetDistanceToOrigin() Signed Distance To Origin. double GetDistanceToOrigin() Returns double Signed Distance To Origin. GetLocate() Gets an anchor point on this flat surface. Vec3d GetLocate() Returns Vec3d A point on the flat surface GetLocate(Vec3d, double) Gets an anchor point from a normal vector and signed distance to origin. public static Vec3d GetLocate(Vec3d normal, double distanceToOrigin) Parameters normal Vec3d The unit normal vector. distanceToOrigin double Signed distance to origin. Returns Vec3d The anchor point on the plane. GetNormal() Gets the normal vector of the flat surface. Vec3d GetNormal() Returns Vec3d The unit normal vector"
  },
  "api/Hi.Geom.IGenStl.html": {
    "href": "api/Hi.Geom.IGenStl.html",
    "title": "Interface IGenStl | HiAPI-C# 2025",
    "summary": "Interface IGenStl Namespace Hi.Geom Assembly HiGeom.dll Interface for generating STL geometry with a resolution. public interface IGenStl Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GenStl(IPolarResolution2d) Generates a new STL. Stl GenStl(IPolarResolution2d resolution) Parameters resolution IPolarResolution2d Polar resolution Returns Stl A newly created STL."
  },
  "api/Hi.Geom.IGeomProperty.html": {
    "href": "api/Hi.Geom.IGeomProperty.html",
    "title": "Interface IGeomProperty | HiAPI-C# 2025",
    "summary": "Interface IGeomProperty Namespace Hi.Geom Assembly HiGeom.dll Interface for objects that have a geometry property. public interface IGeomProperty Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Geom Gets or sets the geometry associated with this object. IGetStl Geom { get; set; } Property Value IGetStl"
  },
  "api/Hi.Geom.IGetStl.html": {
    "href": "api/Hi.Geom.IGetStl.html",
    "title": "Interface IGetStl | HiAPI-C# 2025",
    "summary": "Interface IGetStl Namespace Hi.Geom Assembly HiGeom.dll Interface for retrieving STL geometry data. public interface IGetStl Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) PairZrUtil.GetZrList(IGetStl) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetStl() Gets the STL geometry data. Stl GetStl() Returns Stl The STL geometry object"
  },
  "api/Hi.Geom.IGetZrContour.html": {
    "href": "api/Hi.Geom.IGetZrContour.html",
    "title": "Interface IGetZrContour | HiAPI-C# 2025",
    "summary": "Interface IGetZrContour Namespace Hi.Geom Assembly HiGeom.dll Interface for retrieving Z-R contour data for rotational geometries. public interface IGetZrContour Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetZrContour(double) Gets Z-R contour data as a list of PairZr objects. The Z values should generally be ordered from smallest to largest. IList<PairZr> GetZrContour(double latitudeAngleResolution_rad) Parameters latitudeAngleResolution_rad double Resolution of latitude angle in radians Returns IList<PairZr> Z-R contour data as a list of PairZr objects"
  },
  "api/Hi.Geom.IGetZrList.html": {
    "href": "api/Hi.Geom.IGetZrList.html",
    "title": "Interface IGetZrList | HiAPI-C# 2025",
    "summary": "Interface IGetZrList Namespace Hi.Geom Assembly HiGeom.dll Interface for getting a list of Z-R pairs. public interface IGetZrList Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) PairZrUtil.GetVolume(IGetZrList) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetZrList() Gets a list of Z-R coordinate pairs. List<PairZr> GetZrList() Returns List<PairZr> A list of PairZr objects representing Z-R coordinates."
  },
  "api/Hi.Geom.IStlSource.html": {
    "href": "api/Hi.Geom.IStlSource.html",
    "title": "Interface IStlSource | HiAPI-C# 2025",
    "summary": "Interface IStlSource Namespace Hi.Geom Assembly HiGeom.dll Stl provider with xml support. public interface IStlSource : IGetStl, IMakeXmlSource Inherited Members IGetStl.GetStl() IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods XmlUtil.MakeXmlSourceToFile(IMakeXmlSource, string, bool) XmlUtil.MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) XmlUtil.SaveToByteArrayAsync(IMakeXmlSource, string) PairZrUtil.GetZrList(IGetStl) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Geom.ITri3d.html": {
    "href": "api/Hi.Geom.ITri3d.html",
    "title": "Interface ITri3d | HiAPI-C# 2025",
    "summary": "Interface ITri3d Namespace Hi.Geom Assembly HiGeom.dll Interface for 3D triangles. public interface ITri3d : IFlat3d, IExpandToBox3d Inherited Members IFlat3d.GetDistanceToOrigin() IFlat3d.GetLocate() IFlat3d.GetNormal() IFlat3d.GetLocate(Vec3d, double) IExpandToBox3d.ExpandToBox3d(Box3d) Extension Methods GeomUtil.ExpandToBox3d(IExpandToBox3d, Mat4d, Box3d) GeomUtil.GetBox3d(IExpandToBox3d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetApex(int) Gets the specified vertex (apex) of this triangle. Vec3d GetApex(int i) Parameters i int Index of the vertex (0-2) Returns Vec3d The position of the specified vertex"
  },
  "api/Hi.Geom.IVec-1.html": {
    "href": "api/Hi.Geom.IVec-1.html",
    "title": "Interface IVec<T> | HiAPI-C# 2025",
    "summary": "Interface IVec<T> Namespace Hi.Geom Assembly HiGeom.dll Interface for vector types with generic element type. public interface IVec<T> Type Parameters T The type of elements in the vector Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties this[int] Gets or sets the element at the specified index. T this[int index] { get; set; } Parameters index int The zero-based index of the element to get or set. Property Value T The element at the specified index. Rank Dimension (i.e. Size) of the Vector. int Rank { get; } Property Value int"
  },
  "api/Hi.Geom.IZrListSourceProperty.html": {
    "href": "api/Hi.Geom.IZrListSourceProperty.html",
    "title": "Interface IZrListSourceProperty | HiAPI-C# 2025",
    "summary": "Interface IZrListSourceProperty Namespace Hi.Geom Assembly HiGeom.dll Provides a source for obtaining an IGetZrList. public interface IZrListSourceProperty Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties ZrListSource The provider for IGetZrList. Func<IGetZrList> ZrListSource { get; set; } Property Value Func<IGetZrList>"
  },
  "api/Hi.Geom.Mat4d.IndexFlag.html": {
    "href": "api/Hi.Geom.Mat4d.IndexFlag.html",
    "title": "Enum Mat4d.IndexFlag | HiAPI-C# 2025",
    "summary": "Enum Mat4d.IndexFlag Namespace Hi.Geom Assembly HiGeom.dll Specifies the indexing method for matrix construction from vectors. public enum Mat4d.IndexFlag Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields ByColumn = 0 Vectors are used as columns in the matrix. ByRow = 1 Vectors are used as rows in the matrix."
  },
  "api/Hi.Geom.Mat4d.html": {
    "href": "api/Hi.Geom.Mat4d.html",
    "title": "Class Mat4d | HiAPI-C# 2025",
    "summary": "Class Mat4d Namespace Hi.Geom Assembly HiGeom.dll 4x4 Matrix. public class Mat4d : IEquatable<Mat4d>, IBinaryIo, IWriteBin Inheritance object Mat4d Implements IEquatable<Mat4d> IBinaryIo IWriteBin Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods BinIoUtil.ToBytes(IWriteBin) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Mat4d() Initializes a new instance of the Mat4d class. public Mat4d() Mat4d(AxisAngle4d) Set this matrix to rotation matrix. The matrix is rotate along axis with given radian. public Mat4d(AxisAngle4d src) Parameters src AxisAngle4d src Mat4d(AxisAngle4d, Vec3d) Set this matrix to rotation matrix. The matrix is rotate along axis with given radian. public Mat4d(AxisAngle4d src, Vec3d pivot) Parameters src AxisAngle4d src pivot Vec3d rotation pivot Mat4d(Mat4d) copy constructor public Mat4d(Mat4d src) Parameters src Mat4d src Mat4d(Vec3d) Set this matrix to translation matrix. m(3,0)=trans.x; m(3,1)=trans.y; m(3,2)=trans.z. public Mat4d(Vec3d trans) Parameters trans Vec3d translation Mat4d(Vec3d, Vec3d, Vec3d, IndexFlag) Initializes a new instance of the Mat4d class from three vectors. public Mat4d(Vec3d v0, Vec3d v1, Vec3d v2, Mat4d.IndexFlag indexFlag = IndexFlag.ByColumn) Parameters v0 Vec3d The first vector. v1 Vec3d The second vector. v2 Vec3d The third vector. indexFlag Mat4d.IndexFlag Determines whether vectors are used as columns or rows in the matrix. Mat4d(Vec3d, double) Set this matrix to rotation matrix. The matrix is rotate along axis with given radian. public Mat4d(Vec3d axis, double rad) Parameters axis Vec3d rotation axis rad double radian Mat4d(Vec3d, double, Vec3d) A matrix rotate at pivot along axis by angle rad. public Mat4d(Vec3d axis, double rad, Vec3d pivot) Parameters axis Vec3d rotate axis rad double angle pivot Vec3d rotate pivot Mat4d(mat4d) Ctor by Set(mat4d). public Mat4d(mat4d src) Parameters src mat4d src Mat4d(IEnumerable<double>) Initializes a new instance of the Mat4d class from an enumerable of double values. Takes the first 16 values from the enumerable. public Mat4d(IEnumerable<double> src) Parameters src IEnumerable<double> The enumerable collection of double values. Mat4d(double) a scale matrix which is I*scale. Where I is an identity matrix. public Mat4d(double scale) Parameters scale double scale Mat4d(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double) constructor public Mat4d(double m00, double m01, double m02, double m03, double m10, double m11, double m12, double m13, double m20, double m21, double m22, double m23, double m30, double m31, double m32, double m33) Parameters m00 double value at (0,0) m01 double value at (0,1) m02 double value at (0,2) m03 double value at (0,3) m10 double value at (1,0) m11 double value at (1,1) m12 double value at (1,2) m13 double value at (1,3) m20 double value at (2,0) m21 double value at (2,1) m22 double value at (2,2) m23 double value at (2,3) m30 double value at (3,0) m31 double value at (3,1) m32 double value at (3,2) m33 double value at (3,3) Mat4d(double[]) constructor public Mat4d(double[] src) Parameters src double[] src Mat4d(BinaryReader) Ctor. public Mat4d(BinaryReader reader) Parameters reader BinaryReader reader Mat4d(string) Ctor by Set(string). public Mat4d(string str) Parameters str string src Fields m Column-major matrix in form of array. public double[] m Field Value double[] Properties AxialNormal Vec3d on 2th row. It usually is tool normal. public Vec3d AxialNormal { get; } Property Value Vec3d AxisAngle Gets the axis-angle representation of the rotation component of this matrix. public AxisAngle4d AxisAngle { get; } Property Value AxisAngle4d Determinant Gets the determinant of this matrix. public double Determinant { get; } Property Value double The determinant value. Idt Generate identity matrix. public static Mat4d Idt { get; } Property Value Mat4d IsAllNaN Gets a value indicating whether all elements of this matrix are NaN. public bool IsAllNaN { get; } Property Value bool IsFinite Gets a value indicating whether all elements of this matrix are finite numbers. public bool IsFinite { get; } Property Value bool IsRotate Gets a value indicating whether this matrix represents a pure rotation. public bool IsRotate { get; } Property Value bool MatScale Gets the scale factor of the matrix, calculated as the cube root of the determinant without translation. public double MatScale { get; } Property Value double NaN Generate matrix that all elements are nan. public static Mat4d NaN { get; } Property Value Mat4d NativeByteSize public static int NativeByteSize { get; } Property Value int Byte size: sizeof(double) * 3. NoTransMat Generate new matrix that the translation part is zero. i.e. (m[12],m[13],m[14])=(0,0,0). public Mat4d NoTransMat { get; } Property Value Mat4d Pn Pn: Point and Normal (position + tool axis direction). Point = Trans = (m[12], m[13], m[14]), Normal = AxialNormal = (m[8], m[9], m[10]). public DVec3d Pn { get; } Property Value DVec3d Trans Translation. The value is Vec3d(m[12], m[13], m[14]). public Vec3d Trans { get; set; } Property Value Vec3d TransposeMat Gets a new matrix that is the transpose of this matrix. public Mat4d TransposeMat { get; } Property Value Mat4d Zero Generate zero matrix. public static Mat4d Zero { get; } Property Value Mat4d Methods AdjustSingularValueByTolerance(double) Adjusts matrix values that are close to 0, 1, or -1 (within the specified tolerance) to exactly those values. public Mat4d AdjustSingularValueByTolerance(double tolerance) Parameters tolerance double The tolerance threshold for considering values close to 0, 1, or -1. Returns Mat4d This matrix after adjustment. At(int, int) Gets a reference to the matrix element at the specified row and column. public ref double At(int i, int j) Parameters i int The row index (0-based). j int The column index (0-based). Returns double A reference to the matrix element. Equals(Mat4d) Indicates whether the current object is equal to another object of the same type. public bool Equals(Mat4d other) Parameters other Mat4d An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. EqualsByTolerance(Mat4d, double) Determines whether this matrix is equal to another matrix within a specified tolerance. public bool EqualsByTolerance(Mat4d other, double tolerance) Parameters other Mat4d The matrix to compare with this matrix. tolerance double The maximum absolute difference between matrix elements for them to be considered equal. Returns bool true if the matrices are equal within the specified tolerance; otherwise, false. FilledMat(double) Creates a matrix with all elements set to the specified value. public static Mat4d FilledMat(double v) Parameters v double The value to fill all elements with. Returns Mat4d A new matrix with all elements set to the specified value. FixFloatingZero(double) Fixes floating-point values that are close to zero by setting them to exactly zero. public Mat4d FixFloatingZero(double floatingZeroTolerance = 1E-12) Parameters floatingZeroTolerance double The tolerance below which values are considered zero. Default is 1e-12. Returns Mat4d This matrix instance for method chaining. GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. GetInverse() Gets the inverse. public Mat4d GetInverse() Returns Mat4d Inverse matrix GetScaleMat(double) Creates a new matrix by scaling this matrix by the specified factor. public Mat4d GetScaleMat(double scale) Parameters scale double The scale factor to apply. Returns Mat4d A new scaled matrix. GetTransform(Func<double, double>) Creates a new matrix with all elements transformed by the specified function. public Mat4d GetTransform(Func<double, double> transformingFunc) Parameters transformingFunc Func<double, double> The function to apply to each matrix element. Returns Mat4d A new matrix with transformed elements. Inverse() Inverses this instance. public Mat4d Inverse() Returns Mat4d this ReadBin(BinaryReader) Reads binary data to initialize the object. public void ReadBin(BinaryReader reader) Parameters reader BinaryReader The binary reader to read from Scale(double) Scales the specified s. public Mat4d Scale(double s) Parameters s double The s. Returns Mat4d this Set(AxisAngle4d) Set this matrix to rotation matrix. The matrix is rotate along axis with given radian. public Mat4d Set(AxisAngle4d src) Parameters src AxisAngle4d src Returns Mat4d this Set(Mat4d) copy the data from src to this. public Mat4d Set(Mat4d src) Parameters src Mat4d src Returns Mat4d this Set(Vec3d) Set this matrix to translation matrix. m(3,0)=trans.x; m(3,1)=trans.y; m(3,2)=trans.z. public Mat4d Set(Vec3d trans) Parameters trans Vec3d translation Returns Mat4d this Set(Vec3d, double) Set this matrix to rotation matrix. The matrix is rotate along axis with given radian. public Mat4d Set(Vec3d axis, double rad) Parameters axis Vec3d rotation axis rad double radian Returns Mat4d this Set(Vec3d, double, Vec3d) Set the matrix rotation at pivot along axis by angle rad. public Mat4d Set(Vec3d axis, double rad, Vec3d pivot) Parameters axis Vec3d rotation axis rad double angle pivot Vec3d rotation pivot Returns Mat4d this Set(mat4d) Set the data by src. public Mat4d Set(mat4d src) Parameters src mat4d src Returns Mat4d this Set(double) The matrix will be reset to a scale matrix which is I*scale. Where I is an identity matrix. public Mat4d Set(double scale) Parameters scale double scale Returns Mat4d this Set(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double) constructor public Mat4d Set(double m00, double m01, double m02, double m03, double m10, double m11, double m12, double m13, double m20, double m21, double m22, double m23, double m30, double m31, double m32, double m33) Parameters m00 double value at (0,0) m01 double value at (0,1) m02 double value at (0,2) m03 double value at (0,3) m10 double value at (1,0) m11 double value at (1,1) m12 double value at (1,2) m13 double value at (1,3) m20 double value at (2,0) m21 double value at (2,1) m22 double value at (2,2) m23 double value at (2,3) m30 double value at (3,0) m31 double value at (3,1) m32 double value at (3,2) m33 double value at (3,3) Returns Mat4d this Set(int, int, double) Sets the value of the matrix element at the specified row and column. public void Set(int i, int j, double v) Parameters i int The row index (0-based). j int The column index (0-based). v double The value to set. Set(string) Set data by str. The format is {0,1,2,3,...,15} public Mat4d Set(string str) Parameters str string src Returns Mat4d this SetIdt() Set this instance to identity matrix. public void SetIdt() SetNoTrans() Sets the translation components of this matrix to zero. public Mat4d SetNoTrans() Returns Mat4d This matrix with translation components set to zero. ToBriefString() To brief string. public string ToBriefString() Returns string brief string. ToLinesString() Converts the matrix to a multi-line string representation with aligned columns. public string ToLinesString() Returns string A formatted multi-line string representation of the matrix. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. Transform(Func<double, double>) Transforms all matrix elements in-place using the specified transformation function. public Mat4d Transform(Func<double, double> transformingFunc) Parameters transformingFunc Func<double, double> The function to apply to each matrix element. Returns Mat4d This matrix instance for method chaining. Transpose() Transposes this matrix in place. public Mat4d Transpose() Returns Mat4d This matrix after transposition. WriteBin(BinaryWriter) Writes the object's data to a binary stream. public void WriteBin(BinaryWriter writer) Parameters writer BinaryWriter The binary writer to write to Operators operator +(Mat4d, Mat4d) Adds two matrices element-wise. public static Mat4d operator +(Mat4d a, Mat4d b) Parameters a Mat4d The first matrix. b Mat4d The second matrix. Returns Mat4d A new matrix that is the sum of the two matrices. operator /(Mat4d, double) Divides a matrix by a scalar value. public static Mat4d operator /(Mat4d a, double b) Parameters a Mat4d The matrix to divide. b double The scalar divisor. Returns Mat4d A new matrix with all elements divided by the scalar. operator ==(Mat4d, Mat4d) Determines whether two matrices are equal. public static bool operator ==(Mat4d a, Mat4d b) Parameters a Mat4d The first matrix. b Mat4d The second matrix. Returns bool true if the matrices are equal; otherwise, false. operator !=(Mat4d, Mat4d) Determines whether two matrices are not equal. public static bool operator !=(Mat4d a, Mat4d b) Parameters a Mat4d The first matrix. b Mat4d The second matrix. Returns bool true if the matrices are not equal; otherwise, false. operator *(Mat4d, DVec3d) Multiple matrxi to cutter location (Point and Normal). public static DVec3d operator *(Mat4d m, DVec3d v) Parameters m Mat4d matrix v DVec3d point and normal Returns DVec3d transformed point and normal operator *(Mat4d, Mat4d) Multiplies two matrices. public static Mat4d operator *(Mat4d a, Mat4d b) Parameters a Mat4d The first matrix. b Mat4d The second matrix. Returns Mat4d A new matrix that is the product of the two matrices. operator *(Mat4d, Vec3d) Multiplies a matrix by a vector, transforming the vector. public static Vec3d operator *(Mat4d a, Vec3d b) Parameters a Mat4d The transformation matrix. b Vec3d The vector to transform. Returns Vec3d The transformed vector. operator *(Mat4d, double) Multiplies a matrix by a scalar value. public static Mat4d operator *(Mat4d a, double s) Parameters a Mat4d The matrix to multiply. s double The scalar value. Returns Mat4d A new matrix with all elements multiplied by the scalar. operator -(Mat4d, Mat4d) Subtracts the second matrix from the first matrix element-wise. public static Mat4d operator -(Mat4d a, Mat4d b) Parameters a Mat4d The matrix to subtract from. b Mat4d The matrix to subtract. Returns Mat4d A new matrix that is the difference of the two matrices. operator -(Mat4d) Returns the negation of the specified matrix. public static Mat4d operator -(Mat4d src) Parameters src Mat4d The source matrix. Returns Mat4d A new matrix with all elements negated."
  },
  "api/Hi.Geom.MathNetUtil.html": {
    "href": "api/Hi.Geom.MathNetUtil.html",
    "title": "Class MathNetUtil | HiAPI-C# 2025",
    "summary": "Class MathNetUtil Namespace Hi.Geom Assembly HiGeom.dll Utility class for MathNet.Numerics operations. public static class MathNetUtil Inheritance object MathNetUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods ClearFloatingZero(Matrix<double>, double) the elements which the absolute value lower to gap are set to zero. public static void ClearFloatingZero(Matrix<double> mat, double gap = 1E-07) Parameters mat Matrix<double> target matrix gap double gap value GetCovMatByMultiThread(IList<double[]>, Action<double>, int) Calculates the covariance matrix for a list of vectors using multi-threading. public static DenseMatrix GetCovMatByMultiThread(IList<double[]> vecs, Action<double> progressAction = null, int progressTickPerVec = 20) Parameters vecs IList<double[]> The list of vectors to calculate covariance for. progressAction Action<double> Optional action to report progress. progressTickPerVec int Number of progress ticks per vector processed. Returns DenseMatrix A dense matrix representing the covariance. GetDiagonalString(Matrix<double>) Gets a string representation of the diagonal elements of a matrix. public static string GetDiagonalString(Matrix<double> src) Parameters src Matrix<double> The source matrix to extract diagonal elements from. Returns string A comma-separated string of the diagonal elements with 6 significant digits. GetInversedWeightMat(Matrix<double>, out int, double, double) public static Matrix<double> GetInversedWeightMat(Matrix<double> w, out int abandonedIndex, double minGap = 1E-05, double sumTerminate = 0.99999999) Parameters w Matrix<double> abandonedIndex int abandoned index. Inclusive. minGap double sumTerminate double Returns Matrix<double>"
  },
  "api/Hi.Geom.MathUtil.html": {
    "href": "api/Hi.Geom.MathUtil.html",
    "title": "Class MathUtil | HiAPI-C# 2025",
    "summary": "Class MathUtil Namespace Hi.Geom Assembly HiGeom.dll Math Utility. public static class MathUtil Inheritance object MathUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields sqrt2 square root of 2. public const double sqrt2 = 1.4142135623730951 Field Value double sqrt3 square root of 3. public const double sqrt3 = 1.7320508075688772 Field Value double Methods AbsDiffAngle(double, double) Calculates the absolute difference between two angles in radians public static double AbsDiffAngle(double angleA_rad, double angleB_rad) Parameters angleA_rad double First angle in radians angleB_rad double Second angle in radians Returns double The absolute difference between the two angles Add(double[], double[]) Adds the elements of the second array to the corresponding elements of the first array in-place. public static double[] Add(this double[] src, double[] src2) Parameters src double[] The source array to which elements will be added. src2 double[] The array containing elements to add. Returns double[] The modified source array. AlterIfNan(double, double) public static double AlterIfNan(double primaryValue, double alteringValue) Parameters primaryValue double primary value alteringValue double the candidate value Returns double ApplyAlterIf<T>(T, Func<T, bool>, T) Applies an alternative value if the source value meets a specified condition. public static T ApplyAlterIf<T>(T src, Func<T, bool> isApplyingAlternateFunc, T alternative) Parameters src T The source value to check. isApplyingAlternateFunc Func<T, bool> Function that determines if the alternative should be applied. alternative T The alternative value to use if the condition is met. Returns T Either the original value or the alternative value based on the condition. Type Parameters T The type of the values. Average(IEnumerable<Vec3d>) Average. public static Vec3d Average(this IEnumerable<Vec3d> src) Parameters src IEnumerable<Vec3d> src Returns Vec3d Average BilinearInterpolate(double, double, double, double, double, double) Performs bilinear interpolation between four double values public static double BilinearInterpolate(double v00, double v01, double v10, double v11, double u, double v) Parameters v00 double Value at (0,0) on normalized bilinear coordinate v01 double Value at (0,1) on normalized bilinear coordinate v10 double Value at (1,0) on normalized bilinear coordinate v11 double Value at (1,1) on normalized bilinear coordinate u double Ratio along v00 and v10, etc. v double Ratio along v00 and v01, etc. Returns double The interpolated value BilinearInterpolate<T>(T, T, T, T, double, double) Bilinear interpolate. public static T BilinearInterpolate<T>(T v00, T v01, T v10, T v11, double u, double v) where T : IAdditionOperators<T, T, T>, IMultiplyOperators<T, double, T> Parameters v00 T value at (0,0) on normalized bilinear coordinate v01 T value at (0,1) on normalized bilinear coordinate v10 T value at (1,0) on normalized bilinear coordinate v11 T value at (1,1) on normalized bilinear coordinate u double ratio along v00 and v10, etc. v double ratio along v00 and v01, etc. Returns T interpolated value Type Parameters T value type. BilinearInterpolate<T>(T, T, T, T, double, double, Func<T, double, T>, Func<T, T, T>) Bilinear interpolate. public static T BilinearInterpolate<T>(T v00, T v01, T v10, T v11, double u, double v, Func<T, double, T> scalingFunc, Func<T, T, T> addingFunc) Parameters v00 T value at (0,0) on normalized bilinear coordinate v01 T value at (0,1) on normalized bilinear coordinate v10 T value at (1,0) on normalized bilinear coordinate v11 T value at (1,1) on normalized bilinear coordinate u double ratio along v00 and v10, etc. v double ratio along v00 and v01, etc. scalingFunc Func<T, double, T> scaling function addingFunc Func<T, T, T> adding function Returns T interpolated value Type Parameters T value type. BinaryDividentSequence(int) Generates a value in a binary divident sequence based on the seed. public static double BinaryDividentSequence(int seed) Parameters seed int The seed value for the sequence. Returns double The value in the binary divident sequence. Cbrt(double) Calculates the cube root of a number. public static double Cbrt(double v) Parameters v double The value to calculate the cube root of. Returns double The cube root of the specified value. Clamp<T>(T, T, T) Clamps a value within an inclusive range of minimum and maximum values. public static T Clamp<T>(this T val, T min, T max) where T : IComparable<T> Parameters val T min T max T Returns T Type Parameters T Convert_inchdmin_To_mmds(double) Converts inches per minute to millimeters per second. public static double Convert_inchdmin_To_mmds(double inchdmin) Parameters inchdmin double Value in inches per minute. Returns double Value in millimeters per second. Convert_mdmin_To_mmds(double) Converts meters per minute to millimeters per second. public static double Convert_mdmin_To_mmds(double mdmin) Parameters mdmin double Value in meters per minute. Returns double Value in millimeters per second. Convert_mmdmin_To_mmds(double) Converts millimeters per minute to millimeters per second. public static double Convert_mmdmin_To_mmds(double mmdmin) Parameters mmdmin double Value in millimeters per minute. Returns double Value in millimeters per second. Convert_mmds_To_mdmin(double) Converts millimeters per second to meters per minute. public static double Convert_mmds_To_mdmin(double mmds) Parameters mmds double Value in millimeters per second. Returns double Value in meters per minute. Convert_mmds_To_mmdmin(double) Converts millimeters per second to millimeters per minute. public static double Convert_mmds_To_mmdmin(double mmds) Parameters mmds double Value in millimeters per second. Returns double Value in millimeters per minute. Convert_radds_To_rpm(double) Converts radians per second to revolutions per minute (RPM). public static double Convert_radds_To_rpm(double radds) Parameters radds double Value in radians per second. Returns double Value in revolutions per minute. Convert_rpm_To_radds(double) Converts revolutions per minute (RPM) to radians per second. public static double Convert_rpm_To_radds(double rpm) Parameters rpm double Value in revolutions per minute. Returns double Value in radians per second. Cycle(double, double, double) If the value is within lowerBound and upperBound, return value. Otherwise, perform looped value according to the direction from lower to upper. ex. bound=(0,1), value=3.1, than return 0.1. public static double Cycle(double value, double lowerBound, double upperBound) Parameters value double value lowerBound double lower bound, inclusive upperBound double upper bound, exclusive Returns double cycled value Cycle(double, double, double, bool) Cycles a value to be within the specified range, with configurable bound inclusivity. public static double Cycle(double value, double lowerBound, double upperBound, bool isBothBoundInclusive) Parameters value double The value to cycle. lowerBound double The lower bound of the range. upperBound double The upper bound of the range. isBothBoundInclusive bool If true, both bounds are inclusive; otherwise, only the lower bound is inclusive. Returns double The cycled value within the specified range. Cycle2Pi_rad(double, double, bool) Get value by the cycle range transformation. The cycle is from anchor_rad-pi to anchor_rad+pi. public static double Cycle2Pi_rad(double target_rad, double anchor_rad = 0, bool isBothBoundInclusive = false) Parameters target_rad double target angle anchor_rad double anchor angle isBothBoundInclusive bool if true, both bounds are inclusive; otherwise, only the lower bound is inclusive Returns double adjusted target angle CycleUnit(double) Get the value locates on 0(inclusive) ~ 1(exclusive). The source code: return v - Math.Floor(v); public static double CycleUnit(double v) Parameters v double value Returns double 0 (inclusive) ~1 (exclusive) CycleUpperInclusive(double, double, double) Cycles a value into the lower-exclusive/upper-inclusive window (lowerBound, upperBound] — the mirror of Cycle(double, double, double), whose window is lower-inclusive/upper-exclusive. A value congruent with the bounds resolves to upperBound, never lowerBound — the property a negative-direction rotary window (anchor-2π, anchor] needs so a target congruent with the anchor stays put instead of committing a full negative turn. public static double CycleUpperInclusive(double value, double lowerBound, double upperBound) Parameters value double value lowerBound double lower bound, exclusive upperBound double upper bound, inclusive Returns double cycled value Decompose(double[,], out int[], out int) Performs LU decomposition with partial pivoting on a matrix. public static double[,] Decompose(double[,] matrix, out int[] perm, out int toggle) Parameters matrix double[,] The matrix to decompose. perm int[] Output parameter that holds row permutations. toggle int Output parameter that is +1 or -1 depending on whether the number of row exchanges is even or odd. Returns double[,] The LU decomposition of the matrix. Exceptions Exception Thrown when attempting to decompose a non-square matrix. Div(double[], double) Divides each element of the array by a scalar value in-place. public static double[] Div(this double[] src, double scale) Parameters src double[] The source array to be modified. scale double The scalar value to divide by. Returns double[] The modified source array. Erf(double) Calculates the error function (erf) for the specified value. public static double Erf(double x) Parameters x double The value to calculate the error function for Returns double The error function value Erfc(double) Calculates the complementary error function (erfc) for the specified value. public static double Erfc(double x) Parameters x double The value to calculate the complementary error function for Returns double The complementary error function value GetAbs(double[]) Creates a new array containing the absolute values of the elements in the source array. public static double[] GetAbs(this double[] src) Parameters src double[] The source array. Returns double[] A new array containing the absolute values of the elements in the source array. GetAdd(double[], double[]) Creates a new array by adding corresponding elements of two arrays. public static double[] GetAdd(this double[] src, double[] src2) Parameters src double[] The first array. src2 double[] The second array. Returns double[] A new array containing the sum of corresponding elements. GetCommonRatioFromGeometricSeries(double, double, double) Calculates the common ratio from a geometric series sum. public static double GetCommonRatioFromGeometricSeries(double geometricSeriesSum, double powIndex, double convergenceLimit = 0.001) Parameters geometricSeriesSum double The sum of the geometric series. powIndex double The power index in the series. convergenceLimit double The convergence limit for the calculation. Returns double The common ratio of the geometric series. GetDiv(double[], double) Creates a new array by dividing each element of the source array by a scalar value. public static double[] GetDiv(this double[] src, double scale) Parameters src double[] The source array. scale double The scalar value to divide by. Returns double[] A new array with each element divided by the scalar value. GetDot(double[], double[]) Creates a new array by multiplying corresponding elements of two arrays. public static double[] GetDot(this double[] a, double[] b) Parameters a double[] The first array. b double[] The second array. Returns double[] A new array containing the product of corresponding elements. GetInterpolationRatio(TimeSpan, TimeSpan, TimeSpan) Gets the interpolation ratio between two TimeSpan values public static double GetInterpolationRatio(TimeSpan begin, TimeSpan end, TimeSpan pos) Parameters begin TimeSpan The beginning TimeSpan end TimeSpan The ending TimeSpan pos TimeSpan The position TimeSpan to calculate the ratio for Returns double The interpolation ratio: (pos - begin) / (end - begin) GetInterpolationRatio<T>(T, T, T) Get position ratio. (pos - begin) / (end - begin) . public static double GetInterpolationRatio<T>(T begin, T end, T pos) where T : ISubtractionOperators<T, T, T>, IDivisionOperators<T, T, double> Parameters begin T range begin end T range end pos T key position Returns double position ratio Type Parameters T GetInterpolationRatio<T>(T, T, T, Func<T, T, T>, Func<T, T, double>) Gets the interpolation ratio between two values using custom subtraction and division functions public static double GetInterpolationRatio<T>(T begin, T end, T pos, Func<T, T, T> minusFunc, Func<T, T, double> divFunc) Parameters begin T The beginning value end T The ending value pos T The position value to calculate the ratio for minusFunc Func<T, T, T> The function to use for subtraction divFunc Func<T, T, double> The function to use for division Returns double The interpolation ratio: (pos - begin) / (end - begin) Type Parameters T The type of the values GetMul(double[], double) Creates a new array by multiplying each element of the source array by a scalar value. public static double[] GetMul(this double[] src, double s) Parameters src double[] The source array. s double The scalar value to multiply by. Returns double[] A new array with each element multiplied by the scalar value. GetSub(double[], double[]) Creates a new array by subtracting corresponding elements of the second array from the first array. public static double[] GetSub(this double[] a, double[] b) Parameters a double[] The first array. b double[] The second array to subtract. Returns double[] A new array containing the difference of corresponding elements. Idt(int) Creates an identity matrix of the specified size. public static double[,] Idt(int n) Parameters n int The size of the square identity matrix. Returns double[,] An n x n identity matrix. Interpolate(TimeSpan, TimeSpan, double) Interpolates between two TimeSpan values using the specified ratio public static TimeSpan Interpolate(TimeSpan a, TimeSpan b, double ratio) Parameters a TimeSpan The first TimeSpan value b TimeSpan The second TimeSpan value ratio double The interpolation ratio (0.0 to 1.0) Returns TimeSpan The interpolated TimeSpan value: a * (1 - ratio) + b * ratio InterpolateWithinBoundary<T>(T, T, double) If ratio smaller or equal 0, return a. If ratio larger or equal 1, return b. Otherwise, interpolate by ratio. public static T InterpolateWithinBoundary<T>(T a, T b, double ratio) where T : IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IMultiplyOperators<T, double, T> Parameters a T b T ratio double Returns T Type Parameters T Interpolate<T>(T, T, double) Interpolate from a to b with ratio alpha:(1-alpha). public static T Interpolate<T>(T a, T b, double ratio) where T : IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IMultiplyOperators<T, double, T> Parameters a T a b T b ratio double ratio Returns T a * (1 - ratio) + b * ratio Type Parameters T Interpolate<T>(T, T, double, Func<T, double>) Interpolates between two values based on a position using a position function. public static T Interpolate<T>(T a, T b, double pos, Func<T, double> posFunc) where T : INumber<T>, IMultiplyOperators<T, double, T> Parameters a T The first value b T The second value pos double The position to interpolate at posFunc Func<T, double> Function to extract a position from a value Returns T The interpolated value Type Parameters T The type of the values Interpolate<TItem>(TItem, TItem, double, Func<TItem, double>, Func<TItem, TItem, TItem>, Func<TItem, double, TItem>) Interpolates between two items based on a key value using custom functions. public static TItem Interpolate<TItem>(TItem a, TItem b, double key, Func<TItem, double> keyFunc, Func<TItem, TItem, TItem> addingFunc, Func<TItem, double, TItem> scalingFunc) Parameters a TItem The first item b TItem The second item key double The key value to interpolate at (0.0 to 1.0) keyFunc Func<TItem, double> Function to extract a double key from an item addingFunc Func<TItem, TItem, TItem> Function to add two items scalingFunc Func<TItem, double, TItem> Function to scale an item by a double Returns TItem The interpolated item Type Parameters TItem The type of the items Interpolate<T>(T, T, double, Func<T, T, T>, Func<T, double, T>) Interpolates between two values using custom addition and scaling functions public static T Interpolate<T>(T a, T b, double ratio, Func<T, T, T> addingFunc, Func<T, double, T> scalingFunc) Parameters a T The first value b T The second value ratio double The interpolation ratio (0.0 to 1.0) addingFunc Func<T, T, T> The function to use for addition scalingFunc Func<T, double, T> The function to use for scaling Returns T The interpolated value: a * (1 - ratio) + b * ratio Type Parameters T The type of the values Interpolate<T>(T[], T[], double) Interpolates between two arrays of values using the specified ratio public static T[] Interpolate<T>(T[] a, T[] b, double ratio) where T : INumber<T>, IMultiplyOperators<T, double, T> Parameters a T[] The first array b T[] The second array ratio double The interpolation ratio (0.0 to 1.0) Returns T[] A new array containing the interpolated values Type Parameters T The type of the array elements Interpolate<TKey, TItem>(TItem, TItem, TKey, Func<TItem, TKey>, Func<TKey, TKey, TKey>, Func<TKey, TKey, double>, Func<TItem, TItem, TItem>, Func<TItem, double, TItem>) Interpolates between two items using custom key extraction, key operations, and item operations public static TItem Interpolate<TKey, TItem>(TItem a, TItem b, TKey key, Func<TItem, TKey> keyFunc, Func<TKey, TKey, TKey> keyMinusFunc, Func<TKey, TKey, double> keyDivFunc, Func<TItem, TItem, TItem> itemAddingFunc, Func<TItem, double, TItem> itemScalingFunc) Parameters a TItem The first item b TItem The second item key TKey The key value to interpolate at keyFunc Func<TItem, TKey> Function to extract a key from an item keyMinusFunc Func<TKey, TKey, TKey> Function to subtract keys keyDivFunc Func<TKey, TKey, double> Function to divide keys itemAddingFunc Func<TItem, TItem, TItem> Function to add items itemScalingFunc Func<TItem, double, TItem> Function to scale items Returns TItem The interpolated item Type Parameters TKey The type of the key used for interpolation TItem The type of the items being interpolated Inverse(double[,]) Computes the inverse of a matrix. public static double[,] Inverse(double[,] matrix) Parameters matrix double[,] The matrix to invert. Returns double[,] The inverse of the matrix. Exceptions Exception Thrown when the matrix cannot be inverted. Inverse2d(double[,], double[,]) Calculates the inverse of a 2x2 matrix public static void Inverse2d(double[,] src, double[,] dst) Parameters src double[,] The source 2x2 matrix dst double[,] The destination matrix to store the inverse Inverse3d(double[,], double[,]) Calculates the inverse of a 3x3 matrix public static void Inverse3d(double[,] src, double[,] dst) Parameters src double[,] The source 3x3 matrix dst double[,] The destination matrix to store the inverse IsFinite(double) Is v neither NaN nor infinity. public static bool IsFinite(double v) Parameters v double value Returns bool Is v neither NaN nor infinity. Max<T>(T, T) Returns the larger of two values. public static T Max<T>(T a, T b) where T : IComparable<T> Parameters a T The first value to compare. b T The second value to compare. Returns T The larger of the two values. Type Parameters T The type of values to compare. Min<T>(T, T) Returns the smaller of two values. public static T Min<T>(T a, T b) where T : IComparable<T> Parameters a T The first value to compare. b T The second value to compare. Returns T The smaller of the two values. Type Parameters T The type of values to compare. Mul(double[], double) Multiplies each element of the array by a scalar value in-place. public static double[] Mul(this double[] src, double scale) Parameters src double[] The source array to be modified. scale double The scalar value to multiply by. Returns double[] The modified source array. NoChanged(double) Do nothing. public static double NoChanged(double src) Parameters src double src Returns double src Norm2(double[]) Calculates the Euclidean norm (L2 norm) of a vector. public static double Norm2(this double[] src) Parameters src double[] The source vector as an array of doubles. Returns double The Euclidean norm of the vector. Normalized(double[]) Creates a new array by normalizing the source array to have a unit norm. public static double[] Normalized(this double[] src) Parameters src double[] The source array. Returns double[] A new array with the same direction as the source array but with unit norm. Pow3(double) Calculates the cube (power of 3) of a double value. public static double Pow3(this double src) Parameters src double The source double value Returns double The cube of the source value Pow3(int) Calculates the cube (power of 3) of an integer value. public static int Pow3(this int src) Parameters src int The source integer value Returns int The cube of the source value Pow4(double) Calculates the fourth power of a double value. public static double Pow4(this double src) Parameters src double The source double value Returns double The fourth power of the source value Pow4(int) Calculates the fourth power of an integer value. public static int Pow4(this int src) Parameters src int The source integer value Returns int The fourth power of the source value Product(double[,], double[,]) Multiplies two matrices. public static double[,] Product(double[,] matrixA, double[,] matrixB) Parameters matrixA double[,] The first matrix. matrixB double[,] The second matrix. Returns double[,] The product of the two matrices. Exceptions Exception Thrown when the matrices are not conformable for multiplication. SolveCubic(double, double, double, double) public static Complex[] SolveCubic(double c0, double c1, double c2, double c3) Parameters c0 double constant term. c1 double coefficient of power of 1 of x. c2 double coefficient of power of 2 of x. c3 double coefficient of power of 3 of x. Returns Complex[] SolveQuadratic(double, double, double, out double, out double) Solve quadratic equation. public static double SolveQuadratic(double c, double b, double a, out double x0, out double x1) Parameters c double coefficient of constant of x. b double coefficient of power of 1 of x. a double coefficient of power of 2 of x. x0 double lower root x1 double higher root Returns double determinent SqrtVariance(IList<double>, out double) Standard deviation with n denominator (instead of n-1). public static double SqrtVariance(IList<double> src, out double avg) Parameters src IList<double> avg double Returns double STD Square(double) Calculates the square of a double value. public static double Square(this double src) Parameters src double The source double value Returns double The square of the source value Square(int) Calculates the square of an integer value. public static int Square(this int src) Parameters src int The source integer value Returns int The square of the source value Sum(IEnumerable<Vec3d>) Sum. public static Vec3d Sum(this IEnumerable<Vec3d> src) Parameters src IEnumerable<Vec3d> src Returns Vec3d Sum ToDeg(double) Get degree from radian. public static double ToDeg(double rad) Parameters rad double radian Returns double degree ToRad(double) Get radian from degree. public static double ToRad(double deg) Parameters deg double degree Returns double radian ToString(double[,], string) Converts a 2D double array to a string representation using the specified format public static string ToString(this double[,] src, string format) Parameters src double[,] The source 2D double array format string The format string to use for each double value Returns string A string representation of the 2D array ToString(double[], string) Converts a double array to a string representation using the specified format public static string ToString(this double[] src, string format) Parameters src double[] The source double array format string The format string to use for each double value Returns string A string representation of the array ToStringWithoutCultureNum(double, string) To string function. The special number is formatted by XmlConvert. public static string ToStringWithoutCultureNum(this double src, string format) Parameters src double src format string format Returns string string Transpose(double[,]) Transposes a 2D matrix represented as a 2D array. public static double[,] Transpose(double[,] src) Parameters src double[,] The source matrix to transpose. Returns double[,] A new matrix that is the transpose of the source matrix."
  },
  "api/Hi.Geom.NativeFraction.html": {
    "href": "api/Hi.Geom.NativeFraction.html",
    "title": "Class NativeFraction | HiAPI-C# 2025",
    "summary": "Class NativeFraction Namespace Hi.Geom Assembly HiDisp.dll Native wrapper for C++ fraction_t<0> (unlimited precision fraction). A fraction consists of a numerator and denominator using unlimited precision integers. public class NativeFraction : IDisposable Inheritance object NativeFraction Implements IDisposable Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks Delegate to geom::fraction_t<0> (fraction_unlimited_t) in CppCore. The fraction may be not packed or not evaluated. However, all fraction numerator and denominator are singular managed and denominator is never negative. Constructors NativeFraction() Initializes a new instance of zero fraction. public NativeFraction() NativeFraction(NativeFraction) Initializes a new instance by copying another fraction. public NativeFraction(NativeFraction src) Parameters src NativeFraction The source fraction to copy. NativeFraction(double, double) Initializes a new instance from a double value with specified resolution. Uses Stern-Brocot binary search for approximation. public NativeFraction(double val, double resolution) Parameters val double The double value to convert. resolution double The resolution tolerance for approximation. NativeFraction(int) Initializes a new instance with an integer value. public NativeFraction(int num) Parameters num int The integer value. NativeFraction(long) Initializes a new instance with integer value. public NativeFraction(long num) Parameters num long The integer numerator value. NativeFraction(long, long) Initializes a new instance with numerator and denominator. public NativeFraction(long num, long den) Parameters num long The numerator. den long The denominator. Cannot be negative. Properties CeilInt Gets the ceiling integer value. public int CeilInt { get; } Property Value int Denominator Gets or sets the denominator as BigInteger. Uses byte array transfer for better performance. public BigInteger Denominator { get; set; } Property Value BigInteger DenominatorString Gets or sets the denominator as a string (for unlimited precision). public string DenominatorString { get; set; } Property Value string FloorInt Gets the floor integer value. public int FloorInt { get; } Property Value int IsEvaluated Gets whether the fraction value has been evaluated. public bool IsEvaluated { get; } Property Value bool IsFinite Gets whether the fraction is finite (denominator != 0). public bool IsFinite { get; } Property Value bool IsNaN Gets whether the fraction is NaN (0/0). public bool IsNaN { get; } Property Value bool IsPacked Gets whether the fraction is packed (reduced to irreducible form). public bool IsPacked { get; } Property Value bool IsZero Gets whether the fraction is zero (numerator == 0 and denominator != 0). public bool IsZero { get; } Property Value bool Numerator Gets or sets the numerator as BigInteger. Uses byte array transfer for better performance. public BigInteger Numerator { get; set; } Property Value BigInteger NumeratorString Gets or sets the numerator as a string (for unlimited precision). public string NumeratorString { get; set; } Property Value string Ptr Gets the native pointer. public nint Ptr { get; } Property Value nint RoughValue Gets the roughly evaluated double value. If the data has not been reduced, the return value is not evaluated by the reduced numbers. public double RoughValue { get; } Property Value double Sign Gets the sign of the fraction (-1, 0, or 1). public int Sign { get; } Property Value int Status Gets the status flags. public FractionStatus Status { get; } Property Value FractionStatus Value Gets the evaluated double value. Computes the value if not yet evaluated. public double Value { get; } Property Value double Methods Abs() Gets the absolute value of this fraction. public NativeFraction Abs() Returns NativeFraction ComparePerformanceTest(int, int) Comparative performance test between pure C# Fraction and NativeFraction (C++ backend). public static void ComparePerformanceTest(int iterations = 128, int rounds = 16) Parameters iterations int Number of accumulation steps per round. rounds int Number of rounds to average timing. CompareTo(NativeFraction) Compares this fraction with another. public int CompareTo(NativeFraction other) Parameters other NativeFraction The other fraction. Returns int -1 if less, 0 if equal, 1 if greater. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. Evaluate() Evaluates the double value if not already evaluated. public NativeFraction Evaluate() Returns NativeFraction This instance for chaining. ~NativeFraction() protected ~NativeFraction() GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. NaN() Creates a NaN fraction (0/0). public static NativeFraction NaN() Returns NativeFraction Negate() Negates this fraction in place. public NativeFraction Negate() Returns NativeFraction This instance for chaining. NegativeInf() Creates a negative infinity fraction (-1/0). public static NativeFraction NegativeInf() Returns NativeFraction One() Creates a one fraction (1/1). public static NativeFraction One() Returns NativeFraction Pack() Packs (reduces) the fraction to irreducible form if not already packed. public NativeFraction Pack() Returns NativeFraction This instance for chaining. PerformanceTest(int, int) Performance test for NativeFraction (C++ backend). Test 1: Accumulative += with Val (bounded, linear growth). Test 2: Bounded arithmetic (converging average). public static void PerformanceTest(int iterations = 128, int rounds = 16) Parameters iterations int Number of steps per round. rounds int Number of rounds to average timing. PositiveInf() Creates a positive infinity fraction (1/0). public static NativeFraction PositiveInf() Returns NativeFraction Reciprocal() Gets the reciprocal of this fraction. public NativeFraction Reciprocal() Returns NativeFraction SetAbs() Sets this fraction to its absolute value. public NativeFraction SetAbs() Returns NativeFraction This instance for chaining. SetNumeratorAndDenominator(BigInteger, BigInteger) Sets both numerator and denominator at once. public void SetNumeratorAndDenominator(BigInteger numerator, BigInteger denominator) Parameters numerator BigInteger The numerator value. denominator BigInteger The denominator value. SetReciprocal() Sets this fraction to its reciprocal. public NativeFraction SetReciprocal() Returns NativeFraction This instance for chaining. SetSquare() Sets this fraction to its square. public NativeFraction SetSquare() Returns NativeFraction This instance for chaining. Simplify(double) Simplifies the fraction to the specified resolution. public NativeFraction Simplify(double resolution) Parameters resolution double The resolution tolerance. Returns NativeFraction This instance for chaining. Square() Gets the square of this fraction. public NativeFraction Square() Returns NativeFraction Test() Test function for NativeFraction. public static void Test() ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. Val(double, double) Creates a fraction from a double value with specified resolution. public static NativeFraction Val(double val, double resolution) Parameters val double The double value. resolution double The resolution tolerance. Returns NativeFraction Zero() Creates a zero fraction (0/1). public static NativeFraction Zero() Returns NativeFraction Operators operator +(NativeFraction, NativeFraction) Addition operator. public static NativeFraction operator +(NativeFraction a, NativeFraction b) Parameters a NativeFraction b NativeFraction Returns NativeFraction operator /(NativeFraction, NativeFraction) Division operator. public static NativeFraction operator /(NativeFraction a, NativeFraction b) Parameters a NativeFraction b NativeFraction Returns NativeFraction operator ==(NativeFraction, NativeFraction) Equality operator. public static bool operator ==(NativeFraction a, NativeFraction b) Parameters a NativeFraction b NativeFraction Returns bool explicit operator double(NativeFraction) Explicit conversion to double. public static explicit operator double(NativeFraction f) Parameters f NativeFraction Returns double operator >(NativeFraction, NativeFraction) Greater than operator. public static bool operator >(NativeFraction a, NativeFraction b) Parameters a NativeFraction b NativeFraction Returns bool operator >=(NativeFraction, NativeFraction) Greater than or equal operator. public static bool operator >=(NativeFraction a, NativeFraction b) Parameters a NativeFraction b NativeFraction Returns bool operator !=(NativeFraction, NativeFraction) Inequality operator. public static bool operator !=(NativeFraction a, NativeFraction b) Parameters a NativeFraction b NativeFraction Returns bool operator <(NativeFraction, NativeFraction) Less than operator. public static bool operator <(NativeFraction a, NativeFraction b) Parameters a NativeFraction b NativeFraction Returns bool operator <=(NativeFraction, NativeFraction) Less than or equal operator. public static bool operator <=(NativeFraction a, NativeFraction b) Parameters a NativeFraction b NativeFraction Returns bool operator *(NativeFraction, NativeFraction) Multiplication operator. public static NativeFraction operator *(NativeFraction a, NativeFraction b) Parameters a NativeFraction b NativeFraction Returns NativeFraction operator -(NativeFraction, NativeFraction) Subtraction operator. public static NativeFraction operator -(NativeFraction a, NativeFraction b) Parameters a NativeFraction b NativeFraction Returns NativeFraction operator -(NativeFraction) Negation operator. public static NativeFraction operator -(NativeFraction a) Parameters a NativeFraction Returns NativeFraction"
  },
  "api/Hi.Geom.NativeStl.html": {
    "href": "api/Hi.Geom.NativeStl.html",
    "title": "Class NativeStl | HiAPI-C# 2025",
    "summary": "Class NativeStl Namespace Hi.Geom Assembly HiCbtr.dll Native Stl. For purpose of efficient swept volume. public class NativeStl : IGetStl, IDisposable, IExpandToBox3d Inheritance object NativeStl Implements IGetStl IDisposable IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods StlUtil.ToFaceDrawing(IGetStl) StlUtil.ToLineDrawing(IGetStl) StlUtil.ToSparkleLineDrawing(IGetStl) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NativeStl(Stl) Ctor. public NativeStl(Stl stl) Parameters stl Stl ctor Properties StlPtr Native pointer. public nint StlPtr { get; } Property Value nint TriangleNum Triangle number. public int TriangleNum { get; } Property Value int Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Remarks The dispose will also dispose the related TriTree. Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box ~NativeStl() protected ~NativeStl() GenStl() Generate Stl. public Stl GenStl() Returns Stl stl GetStl() Gets the STL geometry data. public Stl GetStl() Returns Stl The STL geometry object"
  },
  "api/Hi.Geom.ObjUtil.html": {
    "href": "api/Hi.Geom.ObjUtil.html",
    "title": "Class ObjUtil | HiAPI-C# 2025",
    "summary": "Class ObjUtil Namespace Hi.Geom Assembly HiGeom.dll Wavefront OBJ writer for RGB-coloured triangle buffers. public static class ObjUtil Inheritance object ObjUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods WriteText(string, double[]) Write a stride-15 RGB-triangle buffer as Wavefront OBJ text with the per-vertex colour extension (v x y z r g b). Triangle vertices are not shared; faces reference vertices/normals via negative (relative) indices, so no global counters are required. public static void WriteText(string file, double[] rgbTrisNativeArray) Parameters file string Destination OBJ file path. rgbTrisNativeArray double[] Stride-15 array: r,g,b, nx,ny,nz, p0.x,p0.y,p0.z, p1.x,p1.y,p1.z, p2.x,p2.y,p2.z, repeated once per triangle. RGB components are in the [0, 1] range. See Hi.Cbtr.CubeTree.GetRgbTrisNativeArray."
  },
  "api/Hi.Geom.PairZr.html": {
    "href": "api/Hi.Geom.PairZr.html",
    "title": "Class PairZr | HiAPI-C# 2025",
    "summary": "Class PairZr Namespace Hi.Geom Assembly HiGeom.dll Value pair of Z and R. public class PairZr : IMakeXmlSource, IExpandToBox3d, IEqualityOperators<PairZr, PairZr, bool>, IAdditionOperators<PairZr, PairZr, PairZr>, ISubtractionOperators<PairZr, PairZr, PairZr>, IMultiplyOperators<PairZr, double, PairZr>, IDivisionOperators<PairZr, double, PairZr>, IFormattable Inheritance object PairZr Implements IMakeXmlSource IExpandToBox3d IEqualityOperators<PairZr, PairZr, bool> IAdditionOperators<PairZr, PairZr, PairZr> ISubtractionOperators<PairZr, PairZr, PairZr> IMultiplyOperators<PairZr, double, PairZr> IDivisionOperators<PairZr, double, PairZr> IFormattable Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods XmlUtil.MakeXmlSourceToFile(IMakeXmlSource, string, bool) XmlUtil.MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) XmlUtil.SaveToByteArrayAsync(IMakeXmlSource, string) GeomUtil.ExpandToBox3d(IExpandToBox3d, Mat4d, Box3d) GeomUtil.GetBox3d(IExpandToBox3d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors PairZr() Ctor. public PairZr() PairZr(PairZr) Copy ctor. public PairZr(PairZr src) Parameters src PairZr PairZr(double, double) Ctor. public PairZr(double z, double r) Parameters z double see Z r double see R PairZr(string) Ctor. public PairZr(string src) Parameters src string PairZr(XElement) Ctor. public PairZr(XElement src) Parameters src XElement XML Properties R R value. public double R { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Z Z value. public double Z { get; set; } Property Value double ZR (x,y)=(z,r). public Vec2d ZR { get; set; } Property Value Vec2d Methods Equals(PairZr) public bool Equals(PairZr other) Parameters other PairZr Returns bool Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GenCircle(int) Generates a collection of Vec3d points forming a circle at the Z coordinate with radius R. public IEnumerable<Vec3d> GenCircle(int posNum) Parameters posNum int The number of points to generate around the circle Returns IEnumerable<Vec3d> An enumerable collection of Vec3d points GenPolarCircle(int) Generates a collection of Polar3d points forming a circle at the Z coordinate with radius R. public IEnumerable<Polar3d> GenPolarCircle(int posNum) Parameters posNum int The number of points to generate around the circle Returns IEnumerable<Polar3d> An enumerable collection of Polar3d points GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. ToString(string, IFormatProvider) Returns a string representation of the PairZr formatted according to the specified format. public string ToString(string format, IFormatProvider formatProvider) Parameters format string The format to use for each component formatProvider IFormatProvider The format provider to use Returns string A formatted string representation of the PairZr Operators operator +(PairZr, PairZr) Addition operator that adds two PairZr instances. public static PairZr operator +(PairZr left, PairZr right) Parameters left PairZr The left operand right PairZr The right operand Returns PairZr A new PairZr instance with the sum of Z and R values operator /(PairZr, double) Division operator that divides a PairZr instance by a scalar value. public static PairZr operator /(PairZr left, double right) Parameters left PairZr The PairZr instance right double The scalar value Returns PairZr A new PairZr instance with Z and R values divided by the scalar operator ==(PairZr, PairZr) Equality operator that compares two PairZr instances. public static bool operator ==(PairZr left, PairZr right) Parameters left PairZr The left operand right PairZr The right operand Returns bool True if both instances are equal; otherwise, false operator !=(PairZr, PairZr) Inequality operator that compares two PairZr instances. public static bool operator !=(PairZr left, PairZr right) Parameters left PairZr The left operand right PairZr The right operand Returns bool True if the instances are not equal; otherwise, false operator *(PairZr, double) Multiplication operator that multiplies a PairZr instance by a scalar value. public static PairZr operator *(PairZr left, double right) Parameters left PairZr The PairZr instance right double The scalar value Returns PairZr A new PairZr instance with Z and R values multiplied by the scalar operator -(PairZr, PairZr) Subtraction operator that subtracts one PairZr instance from another. public static PairZr operator -(PairZr a, PairZr b) Parameters a PairZr The left operand b PairZr The right operand to subtract Returns PairZr A new PairZr instance with the difference of Z and R values"
  },
  "api/Hi.Geom.PairZrUtil.html": {
    "href": "api/Hi.Geom.PairZrUtil.html",
    "title": "Class PairZrUtil | HiAPI-C# 2025",
    "summary": "Class PairZrUtil Namespace Hi.Geom Assembly HiGeom.dll Utility class for working with PairZr objects public static class PairZrUtil Inheritance object PairZrUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetIntensiveZrs(IEnumerable<PairZr>, double) public static IEnumerable<PairZr> GetIntensiveZrs(this IEnumerable<PairZr> src, double ZResolution) Parameters src IEnumerable<PairZr> ZResolution double Returns IEnumerable<PairZr> GetNormal2d(SortedList<double, PairZr>, double) Gets a 2D normal vector to the surface at the specified Z position public static Vec2d GetNormal2d(this SortedList<double, PairZr> zVsPairZr, double z) Parameters zVsPairZr SortedList<double, PairZr> The sorted list of PairZr objects defining the surface z double The Z position to get the normal vector for Returns Vec2d A 2D normal vector to the surface, or null if it cannot be calculated GetNormal2dByFittedZ(SortedList<double, PairZr>, double, out double) Gets a 2D normal vector to the surface at the specified Z position, adjusted to fit within the Z range public static Vec2d GetNormal2dByFittedZ(this SortedList<double, PairZr> zVsPairZr, double z, out double fittedZ) Parameters zVsPairZr SortedList<double, PairZr> The sorted list of PairZr objects defining the surface z double The Z position to get the normal vector for fittedZ double Output parameter that receives the adjusted Z value that fits within the range Returns Vec2d A 2D normal vector to the surface, or null if it cannot be calculated GetRByZ(List<PairZr>, double) Gets the R value at a specified Z position by interpolating between PairZr objects in a list public static double GetRByZ(this List<PairZr> zVsPairZr, double z) Parameters zVsPairZr List<PairZr> The list of PairZr objects z double The Z position to get the R value for Returns double The interpolated R value at the specified Z position, or NaN if interpolation is not possible GetRByZ(SortedList<double, PairZr>, double) Gets the R value at a specified Z position by interpolating between PairZr objects in a sorted list public static double GetRByZ(this SortedList<double, PairZr> zVsPairZr, double z) Parameters zVsPairZr SortedList<double, PairZr> The sorted list of PairZr objects keyed by Z values z double The Z position to get the R value for Returns double The interpolated R value at the specified Z position, or NaN if interpolation is not possible GetSurfaceVerticalArrow2d(List<PairZr>, double) Gets a 2D vector perpendicular to the surface at the specified Z position public static Vec2d GetSurfaceVerticalArrow2d(this List<PairZr> zVsPairZr, double z) Parameters zVsPairZr List<PairZr> The list of PairZr objects defining the surface z double The Z position to get the vector for Returns Vec2d A 2D vector perpendicular to the surface, or null if it cannot be calculated GetSurfaceVerticalArrow2dByFittedZ(List<PairZr>, double, out double) Gets a 2D vector perpendicular to the surface at the specified Z position, adjusted to fit within the Z range public static Vec2d GetSurfaceVerticalArrow2dByFittedZ(this List<PairZr> zVsPairZr, double z, out double fittedZ) Parameters zVsPairZr List<PairZr> The list of PairZr objects defining the surface z double The Z position to get the vector for fittedZ double Output parameter that receives the adjusted Z value that fits within the range Returns Vec2d A 2D vector perpendicular to the surface, or null if it cannot be calculated GetSurfaceVerticalArrow3dByFittedZ(List<PairZr>, double, double, out double) Gets a 3D vector perpendicular to the surface at the specified Z position, adjusted to fit within the Z range public static Vec3d GetSurfaceVerticalArrow3dByFittedZ(this List<PairZr> zVsPairZr, double z, double angle_rad, out double fittedZ) Parameters zVsPairZr List<PairZr> The list of PairZr objects defining the surface z double The Z position to get the vector for angle_rad double The angle in radians to position the vector around the Z axis fittedZ double Output parameter that receives the adjusted Z value that fits within the range Returns Vec3d A 3D vector perpendicular to the surface, or null if it cannot be calculated GetVolume(IGetZrList) Calculates the volume of an object that implements IGetZrList public static double GetVolume(this IGetZrList src) Parameters src IGetZrList The object that implements IGetZrList Returns double The calculated volume, or 0 if the source is null GetVolume(IEnumerable<PairZr>) Get Volume. Assume the src.Z is ascendent. If Z descendent, the result may be negative. public static double GetVolume(this IEnumerable<PairZr> src) Parameters src IEnumerable<PairZr> Returns double GetZrList(IGetStl) Extracts a list of PairZr objects from an object that implements IGetStl public static List<PairZr> GetZrList(this IGetStl geom) Parameters geom IGetStl The object that implements IGetStl Returns List<PairZr> A list of PairZr objects, or null if the geometry is null GetZrList(IEnumerable<Tri3d>) Extracts a list of PairZr objects from a collection of triangles public static List<PairZr> GetZrList(this IEnumerable<Tri3d> tris) Parameters tris IEnumerable<Tri3d> The collection of triangles Returns List<PairZr> A list of PairZr objects ordered by Z value"
  },
  "api/Hi.Geom.PlyUtil.html": {
    "href": "api/Hi.Geom.PlyUtil.html",
    "title": "Class PlyUtil | HiAPI-C# 2025",
    "summary": "Class PlyUtil Namespace Hi.Geom Assembly HiGeom.dll Stanford PLY writer for RGB-coloured triangle buffers. public static class PlyUtil Inheritance object PlyUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods WriteBin(string, double[]) Write a stride-15 RGB-triangle buffer as little-endian binary PLY with per-vertex RGB. Vertices are not shared between triangles (the input is a non-manifold soup), so each triangle contributes 3 unique vertices. public static void WriteBin(string file, double[] rgbTrisNativeArray) Parameters file string Destination PLY file path. rgbTrisNativeArray double[] Stride-15 array: r,g,b, nx,ny,nz, p0.x,p0.y,p0.z, p1.x,p1.y,p1.z, p2.x,p2.y,p2.z, repeated once per triangle. RGB components are in the [0, 1] range. See Hi.Cbtr.CubeTree.GetRgbTrisNativeArray."
  },
  "api/Hi.Geom.Polar3d.html": {
    "href": "api/Hi.Geom.Polar3d.html",
    "title": "Class Polar3d | HiAPI-C# 2025",
    "summary": "Class Polar3d Namespace Hi.Geom Assembly HiGeom.dll Represents a point in 3D space using polar coordinates public class Polar3d : IAdditionOperators<Polar3d, Polar3d, Polar3d>, ISubtractionOperators<Polar3d, Polar3d, Polar3d>, IMultiplyOperators<Polar3d, double, Polar3d>, IDivisionOperators<Polar3d, double, Polar3d>, ICsvRowIo, IFormattable Inheritance object Polar3d Implements IAdditionOperators<Polar3d, Polar3d, Polar3d> ISubtractionOperators<Polar3d, Polar3d, Polar3d> IMultiplyOperators<Polar3d, double, Polar3d> IDivisionOperators<Polar3d, double, Polar3d> ICsvRowIo IFormattable Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Polar3d() Ctor. public Polar3d() Polar3d(Polar3d) Copy constructor public Polar3d(Polar3d src) Parameters src Polar3d The source Polar3d object to copy Polar3d(Vec3d) Ctor. public Polar3d(Vec3d src) Parameters src Vec3d src Polar3d(double, double, double) Ctor. public Polar3d(double r, double angle_rad, double z) Parameters r double r angle_rad double angle_rad z double z Polar3d(BinaryReader) Ctor by bytes: r = reader.ReadDouble(); angle = reader.ReadDouble(); z = reader.ReadDouble(); public Polar3d(BinaryReader reader) Parameters reader BinaryReader reader Polar3d(string) Ctor by string. The format is (r,angle_rad,z). public Polar3d(string src) Parameters src string src Fields angle_rad Angle in radian. public double angle_rad Field Value double r Radius. public double r Field Value double z Height. public double z Field Value double Properties Angle_deg Angle in degree. public double Angle_deg { get; set; } Property Value double Angle_rad Angle in radian. public double Angle_rad { get; set; } Property Value double CsvText Csv text. public string CsvText { get; set; } Property Value string CsvTitleText Csv titles text. public string CsvTitleText { get; } Property Value string IsAllFinite public bool IsAllFinite { get; } Property Value bool Is r,angle_rad,z all finite. IsAllNaN public bool IsAllNaN { get; } Property Value bool is r,angle_rad,z all NaN. IsAnyNaN public bool IsAnyNaN { get; } Property Value bool Is any of {r,angle_rad,z} NaN. NaN public static Polar3d NaN { get; } Property Value Polar3d Generate Polar3d(double.NaN, double.NaN, double.NaN). NativeByteSize public static int NativeByteSize { get; } Property Value int Byte size: sizeof(double) * 3. R Radius. public double R { get; set; } Property Value double StaticCsvTitleText Gets the CSV column headers for Polar3d objects public static string StaticCsvTitleText { get; } Property Value string Text Gets or sets the text representation of this Polar3d object public string Text { get; set; } Property Value string Z Height. public double Z { get; set; } Property Value double Zero public static Polar3d Zero { get; } Property Value Polar3d Generate Polar3d(0, 0, 0). Methods Dot(Polar3d) this dot src. public double Dot(Polar3d src) Parameters src Polar3d src Returns double dotted value Equals(Polar3d) public bool Equals(Polar3d other) Parameters other Polar3d Returns bool Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. ExpandToBox3d(Box3d) public void ExpandToBox3d(Box3d dst) Parameters dst Box3d GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. Interpolate(Polar3d, Polar3d, double) Interpolate from a to b with ratio alpha:(1-alpha). public static Polar3d Interpolate(Polar3d a, Polar3d b, double alpha) Parameters a Polar3d a b Polar3d b alpha double ratio Returns Polar3d a * (1 - alpha) + b * alpha Parse(string) If src is not null and not empty string, return Polar3d(string); otherwise return null. public static Polar3d Parse(string src) Parameters src string src Returns Polar3d parsed Polar3d ReadBin(BinaryReader) public void ReadBin(BinaryReader reader) Parameters reader BinaryReader Set(Polar3d) Set values by copy. public Polar3d Set(Polar3d src) Parameters src Polar3d src Returns Polar3d this Set(double, double, double) Set values. public Polar3d Set(double r, double angle_rad, double z) Parameters r double r angle_rad double angle_rad z double z Returns Polar3d this Set(double[]) Set values by array. public Polar3d Set(double[] src) Parameters src double[] double[]{r,angle_rad,z} Returns Polar3d this SetEachNanToZero() Set NaN to 0 for each value. public Polar3d SetEachNanToZero() Returns Polar3d this ToArray() return new double[] { r, angle_rad, z } public double[] ToArray() Returns double[] { r, angle_rad, z } ToBuf(double[]) Set r,angle_rad,z to the dst array. public void ToBuf(double[] dst) Parameters dst double[] dst ToBuf(double[], ref int) Set r,angle_rad,z to the dst array from postion p and increase p by the pushed number. public int ToBuf(double[] dst, ref int p) Parameters dst double[] dst p int position from dst Returns int Which is pushed number of double ToString() To representative string with format:(r,angle_rad,z). public override string ToString() Returns string Representative string ToString(string) To string with format: (r,angle_rad,z) public string ToString(string format) Parameters format string format of ToString(string) Returns string Representative string ToString(string, IFormatProvider) Returns a string representation of the polar coordinates formatted according to the specified format. public string ToString(string format, IFormatProvider formatProvider) Parameters format string The format to use for each component formatProvider IFormatProvider The format provider to use Returns string A formatted string representation of the polar coordinates TryParse(string, out Polar3d) Attempts to parse a string into a Polar3d object public static bool TryParse(string src, out Polar3d dst) Parameters src string The string to parse dst Polar3d When this method returns, contains the Polar3d object if parsing succeeded, or null if parsing failed Returns bool true if parsing succeeded; otherwise, false WriteBin(BinaryWriter) Output to bytes: writer.Write(r); writer.Write(angle); writer.Write(z); public void WriteBin(BinaryWriter writer) Parameters writer BinaryWriter writer Operators operator +(Polar3d, Polar3d) Plus. public static Polar3d operator +(Polar3d a, Polar3d b) Parameters a Polar3d a b Polar3d b Returns Polar3d new Polar3d(a.r + b.r, a.angle_rad + b.angle_rad, a.z + b.z) operator /(Polar3d, double) Get a new object from a scaled by 1/d. public static Polar3d operator /(Polar3d a, double d) Parameters a Polar3d a d double denominator Returns Polar3d result operator *(Polar3d, double) Scale a by s. public static Polar3d operator *(Polar3d a, double s) Parameters a Polar3d vector s double scale Returns Polar3d new Polar3d(a.r * s, a.angle_rad * s, a.z * s) operator -(Polar3d, Polar3d) Minus. public static Polar3d operator -(Polar3d a, Polar3d b) Parameters a Polar3d a b Polar3d b Returns Polar3d new Polar3d(a.r - b.r, a.angle_rad - b.angle_rad, a.z - b.z) operator -(Polar3d) Get negate vector. public static Polar3d operator -(Polar3d src) Parameters src Polar3d src Returns Polar3d new Polar3d(-src.r, -src.angle_rad, -src.z)"
  },
  "api/Hi.Geom.Resolution.IPolarResolution2d.html": {
    "href": "api/Hi.Geom.Resolution.IPolarResolution2d.html",
    "title": "Interface IPolarResolution2d | HiAPI-C# 2025",
    "summary": "Interface IPolarResolution2d Namespace Hi.Geom.Resolution Assembly HiGeom.dll Interface for objects that control STL resolution parameters for both linear and angular measurements. public interface IPolarResolution2d Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties AngleResolution_deg Gets or sets the angular resolution in degrees. double AngleResolution_deg { get; set; } Property Value double AngleResolution_rad Gets or sets the angular resolution in radians. double AngleResolution_rad { get; set; } Property Value double LinearResolution_mm Gets or sets the linear resolution in millimeters. double LinearResolution_mm { get; set; } Property Value double"
  },
  "api/Hi.Geom.Resolution.PolarResolution2d.html": {
    "href": "api/Hi.Geom.Resolution.PolarResolution2d.html",
    "title": "Class PolarResolution2d | HiAPI-C# 2025",
    "summary": "Class PolarResolution2d Namespace Hi.Geom.Resolution Assembly HiGeom.dll Polar resolution for generating geometry in polar coordinate. public class PolarResolution2d : IPolarResolution2d, IMakeXmlSource, IToXElement Inheritance object PolarResolution2d Implements IPolarResolution2d IMakeXmlSource IToXElement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods XmlUtil.MakeXmlSourceToFile(IMakeXmlSource, string, bool) XmlUtil.MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) XmlUtil.SaveToByteArrayAsync(IMakeXmlSource, string) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors PolarResolution2d() Initializes a new instance of the PolarResolution2d class. public PolarResolution2d() PolarResolution2d(double, double) Initializes a new instance of the PolarResolution2d class with values. public PolarResolution2d(double linearResolution_mm, double angleResolution_rad) Parameters linearResolution_mm double Linear resolution in millimeters angleResolution_rad double Angular resolution in radians PolarResolution2d(XElement) Initializes a new instance of the PolarResolution2d class from XML data. public PolarResolution2d(XElement src) Parameters src XElement The XML element containing polar resolution data. Properties AngleResolution_deg Gets or sets the angular resolution in degrees. public double AngleResolution_deg { get; set; } Property Value double AngleResolution_rad Gets or sets the angular resolution in radians. public double AngleResolution_rad { get; set; } Property Value double LinearResolution_mm Gets or sets the linear resolution in millimeters. public double LinearResolution_mm { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.Geom.Resolution.html": {
    "href": "api/Hi.Geom.Resolution.html",
    "title": "Namespace Hi.Geom.Resolution | HiAPI-C# 2025",
    "summary": "Namespace Hi.Geom.Resolution Classes PolarResolution2d Polar resolution for generating geometry in polar coordinate. Interfaces IPolarResolution2d Interface for objects that control STL resolution parameters for both linear and angular measurements."
  },
  "api/Hi.Geom.Segment3d.html": {
    "href": "api/Hi.Geom.Segment3d.html",
    "title": "Class Segment3d | HiAPI-C# 2025",
    "summary": "Class Segment3d Namespace Hi.Geom Assembly HiGeom.dll Represents a 3D line segment defined by two endpoints. public class Segment3d : IExpandToBox3d, IEquatable<Segment3d>, IBinaryIo, IWriteBin, IEnumerable<Vec3d>, IEnumerable Inheritance object Segment3d Implements IExpandToBox3d IEquatable<Segment3d> IBinaryIo IWriteBin IEnumerable<Vec3d> IEnumerable Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods BinIoUtil.ToBytes(IWriteBin) GeomUtil.ExpandToBox3d(IExpandToBox3d, Mat4d, Box3d) GeomUtil.GetBox3d(IExpandToBox3d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) EnumerableUtil.GetIntensiveItems<TItem>(IEnumerable<TItem>, double, Func<TItem, double>) StringUtil.ToDotSplitedString<T>(IEnumerable<T>) MathUtil.Average(IEnumerable<Vec3d>) MathUtil.Sum(IEnumerable<Vec3d>) Tri3dUtil.GenTrisByFan(IEnumerable<Vec3d>, Vec3d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Segment3d() Initializes a new instance of the Segment3d class. public Segment3d() Segment3d(Vec3d, Vec3d) Initializes a new instance of the Segment3d class with endpoints. public Segment3d(Vec3d begin, Vec3d end) Parameters begin Vec3d Start point end Vec3d End point Properties Arrow Gets the arrow vector from Begin to End. public Vec3d Arrow { get; } Property Value Vec3d Begin The starting point of the segment. public Vec3d Begin { get; set; } Property Value Vec3d Center Gets the midpoint of the segment. public Vec3d Center { get; } Property Value Vec3d End The ending point of the segment. public Vec3d End { get; set; } Property Value Vec3d Length Gets the length of the segment. public double Length { get; } Property Value double LengthSquare The squared length of the segment. public double LengthSquare { get; } Property Value double Methods ClosestPoint(Vec3d) Gets the closest point on the segment to the specified point. public Vec3d ClosestPoint(Vec3d point) Parameters point Vec3d Point to find closest point to. Returns Vec3d Closest point on the segment. Equals(Segment3d) Indicates whether the current object is equal to another object of the same type. public bool Equals(Segment3d other) Parameters other Segment3d An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetEnumerator() Returns an enumerator that iterates through the collection. public IEnumerator<Vec3d> GetEnumerator() Returns IEnumerator<Vec3d> An enumerator that can be used to iterate through the collection. GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. PointAt(double) Gets a point on the segment at the specified parameter t (0 <= t <= 1). public Vec3d PointAt(double t) Parameters t double Parameter value between 0 and 1. Returns Vec3d Point on the segment. ReadBin(BinaryReader) Reads binary data to initialize the object. public void ReadBin(BinaryReader reader) Parameters reader BinaryReader The binary reader to read from Swap() Swaps the begin and end points of the segment. public void Swap() ToString() Returns a string representation of the segment. public override string ToString() Returns string WriteBin(BinaryWriter) Writes the object's data to a binary stream. public void WriteBin(BinaryWriter writer) Parameters writer BinaryWriter The binary writer to write to"
  },
  "api/Hi.Geom.Solvers.BinarySolverUtil.html": {
    "href": "api/Hi.Geom.Solvers.BinarySolverUtil.html",
    "title": "Class BinarySolverUtil | HiAPI-C# 2025",
    "summary": "Class BinarySolverUtil Namespace Hi.Geom.Solvers Assembly HiGeom.dll Utility class providing binary solving methods for one-dimensional functions. public static class BinarySolverUtil Inheritance object BinarySolverUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods CenterSplitionSolve(Func<double, double>, Range<double>, Vec2d, double, double, Func<double, bool>, int) Efficient center splitting solve that uses an initial point (x0, y0) within the boundary to save one function evaluation. The algorithm intelligently chooses the optimal boundary points based on the initial point position. public static IEnumerable<BinarySolvingEntry> CenterSplitionSolve(Func<double, double> func, Range<double> xBoundary, Vec2d x0y0, double yTarget, double convergenceLimit, Func<double, bool> isYAcceptableFunc, int maxIteration = 12) Parameters func Func<double, double> The function to solve xBoundary Range<double> Boundary of the search interval. The order of Min and Max is not mattered, i.e. they can be reversed. x0y0 Vec2d Initial x,y value (x0,func(x0)) yTarget double Target y value to solve for convergenceLimit double Convergence limit (acceptable error) isYAcceptableFunc Func<double, bool> Function to determine if a y value is acceptable maxIteration int Maximum number of iterations Returns IEnumerable<BinarySolvingEntry> A sequence of solving status objects showing the progress of the solution CenterSplitionSolve(Func<double, double>, Range<double>, double, double, double, Func<double, bool>, int) Solves for a target y-value using the center splitting method with a boundary range and initial x value. public static IEnumerable<BinarySolvingEntry> CenterSplitionSolve(Func<double, double> func, Range<double> xBoundary, double x0, double yTarget, double convergenceLimit, Func<double, bool> isYAcceptableFunc, int maxIteration = 12) Parameters func Func<double, double> The function to solve xBoundary Range<double> Boundary of the search interval x0 double Initial x value (must be within the boundary) yTarget double Target y value to solve for convergenceLimit double Convergence limit (acceptable error) isYAcceptableFunc Func<double, bool> Function to determine if a y value is acceptable maxIteration int Maximum number of iterations Returns IEnumerable<BinarySolvingEntry> A sequence of solving status objects showing the progress of the solution CenterSplitionSolve(Func<double, double>, Range<double>, double, double, Func<double, bool>, int) Solves for a target y-value using the center splitting method with a boundary range. public static IEnumerable<BinarySolvingEntry> CenterSplitionSolve(Func<double, double> func, Range<double> xBoundary, double yTarget, double convergenceLimit, Func<double, bool> isYAcceptableFunc, int maxIteration = 12) Parameters func Func<double, double> The function to solve xBoundary Range<double> Boundary of the search interval yTarget double Target y value to solve for convergenceLimit double Convergence limit (acceptable error) isYAcceptableFunc Func<double, bool> Function to determine if a y value is acceptable maxIteration int Maximum number of iterations Returns IEnumerable<BinarySolvingEntry> A sequence of solving status objects showing the progress of the solution CenterSplitionSolve(Func<double, double>, double, double, double, double, double, Func<double, bool>, int) Solves for a target y-value using the center splitting method. public static IEnumerable<BinarySolvingEntry> CenterSplitionSolve(Func<double, double> func, double x0, double y0, double xBoundary, double yTarget, double convergenceLimit, Func<double, bool> isYAcceptableFunc, int maxIteration = 12) Parameters func Func<double, double> The function to solve x0 double Initial x value y0 double Initial y value (func(x0)) xBoundary double extended side boundary yTarget double Target y value to solve for convergenceLimit double Convergence limit (acceptable error) isYAcceptableFunc Func<double, bool> Function to determine if a y value is acceptable maxIteration int Maximum number of iterations Returns IEnumerable<BinarySolvingEntry> A sequence of solving status objects showing the progress of the solution CenterSplitionSolveWithY1(Func<double, double>, double, double, double, double, double, double, Func<double, bool>, int) Solves for a target y-value using the center splitting method with a pre-calculated y1 value. public static IEnumerable<BinarySolvingEntry> CenterSplitionSolveWithY1(Func<double, double> func, double x0, double y0, double x1, double y1, double yTarget, double convergenceLimit, Func<double, bool> isYAcceptableFunc, int maxIteration = 12) Parameters func Func<double, double> The function to solve x0 double Initial x value y0 double Initial y value (func(x0)) x1 double Second x value y1 double Second y value (func(x1)) yTarget double Target y value to solve for convergenceLimit double Convergence limit (acceptable error) isYAcceptableFunc Func<double, bool> Function to determine if a y value is acceptable maxIteration int Maximum number of iterations Returns IEnumerable<BinarySolvingEntry> A sequence of solving status objects showing the progress of the solution SlopeSolve(Func<double, double>, double, double, double, double, double, int) Solves for a target y-value using the slope method. public static IEnumerable<BinarySolvingEntry> SlopeSolve(Func<double, double> func, double x0, double y0, double x1, double yTarget, double convergenceLimit, int maxIteration = 12) Parameters func Func<double, double> The function to solve x0 double Initial x value y0 double Initial y value (func(x0)) x1 double Second x value yTarget double Target y value to solve for convergenceLimit double Convergence limit (acceptable error) maxIteration int Maximum number of iterations Returns IEnumerable<BinarySolvingEntry> A sequence of solving status objects showing the progress of the solution SlopeSolveWithY1(Func<double, double>, double, double, double, double, double, double, int) Solves for a target y-value using the slope method with a pre-calculated y1 value. public static IEnumerable<BinarySolvingEntry> SlopeSolveWithY1(Func<double, double> func, double x0, double y0, double x1, double y1, double yTarget, double convergenceLimit, int maxIteration = 12) Parameters func Func<double, double> The function to solve x0 double Initial x value y0 double Initial y value (func(x0)) x1 double Second x value y1 double Second y value (func(x1)) yTarget double Target y value to solve for convergenceLimit double Convergence limit (acceptable error) maxIteration int Maximum number of iterations Returns IEnumerable<BinarySolvingEntry> A sequence of solving status objects showing the progress of the solution"
  },
  "api/Hi.Geom.Solvers.BinarySolvingEntry.html": {
    "href": "api/Hi.Geom.Solvers.BinarySolvingEntry.html",
    "title": "Class BinarySolvingEntry | HiAPI-C# 2025",
    "summary": "Class BinarySolvingEntry Namespace Hi.Geom.Solvers Assembly HiGeom.dll Represents the status of a binary solving process. Contains information about the current state of the solver including best solutions and error metrics. public class BinarySolvingEntry Inheritance object BinarySolvingEntry Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors BinarySolvingEntry(SolvingStatus, int, double, double, double, double, double, double) Initializes a new instance of the BinarySolvingEntry class. public BinarySolvingEntry(SolvingStatus solvingResultStatus, int iteration, double bestX, double bestY, double minBias, double workingX, double workingY, double bias) Parameters solvingResultStatus SolvingStatus The current status of the solving process iteration int The current iteration count bestX double The X-coordinate of the best solution found bestY double The Y-coordinate of the best solution found minBias double The minimum bias (error) found workingX double The current working X-coordinate workingY double The current working Y-coordinate bias double The current bias (error) Properties BestX Gets or sets the X-coordinate of the best solution found. public double BestX { get; set; } Property Value double BestY Gets or sets the Y-coordinate of the best solution found. public double BestY { get; set; } Property Value double Bias Gets or sets the current bias (error). public double Bias { get; set; } Property Value double Iteration Gets or sets the current iteration count. public int Iteration { get; set; } Property Value int MinBias Gets or sets the minimum bias (error) found. public double MinBias { get; set; } Property Value double SolvingStatus Gets or sets the current status of the solving process. public SolvingStatus SolvingStatus { get; set; } Property Value SolvingStatus WorkingX Gets or sets the current working X-coordinate. public double WorkingX { get; set; } Property Value double WorkingY Gets or sets the current working Y-coordinate. public double WorkingY { get; set; } Property Value double Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Geom.Solvers.DeepSolvingStatus.html": {
    "href": "api/Hi.Geom.Solvers.DeepSolvingStatus.html",
    "title": "Class DeepSolvingStatus | HiAPI-C# 2025",
    "summary": "Class DeepSolvingStatus Namespace Hi.Geom.Solvers Assembly HiGeom.dll Represents the status of a deep solving process with multiple parameters. Contains detailed information about the solving process including iterations, convergence, and Jacobian matrix. public class DeepSolvingStatus Inheritance object DeepSolvingStatus Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors DeepSolvingStatus(int, int, int, double, double[], double[], double[,], double[], double, SolvingTerm) Initializes a new instance of the DeepSolvingStatus class. public DeepSolvingStatus(int totalIteration, int directIteration, int slowIteration, double convergence, double[] para, double[] bias, double[,] jacob, double[] bestPara, double bestConvergence, SolvingTerm solvingTerm) Parameters totalIteration int The total number of iterations performed directIteration int The number of direct method iterations performed slowIteration int The number of slow method iterations performed convergence double The current convergence value para double[] The current parameter values bias double[] The current bias values jacob double[,] The Jacobian matrix bestPara double[] The best parameter values found bestConvergence double The best convergence value found solvingTerm SolvingTerm The current solving term Fields bestConvergence The best convergence value found so far. public double bestConvergence Field Value double bestPara The best parameter values found so far. public double[] bestPara Field Value double[] bias The current bias (error) values. public double[] bias Field Value double[] convergence The current convergence value (error metric). public double convergence Field Value double directIteration The number of direct method iterations performed. public int directIteration Field Value int jacob The Jacobian matrix for the current iteration. public double[,] jacob Field Value double[,] para The current parameter values. public double[] para Field Value double[] slowIteration The number of slow method iterations performed. public int slowIteration Field Value int solvingTerm The current solving term (method) being used. public SolvingTerm solvingTerm Field Value SolvingTerm totalIteration The total number of iterations performed. public int totalIteration Field Value int Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. ToString(string) Returns a string representation of the solving status with the specified numeric format. public string ToString(string format) Parameters format string The numeric format string to use for formatting numeric values Returns string A string representation of the solving status"
  },
  "api/Hi.Geom.Solvers.NumericalSolver.GetRepondsDelegate.html": {
    "href": "api/Hi.Geom.Solvers.NumericalSolver.GetRepondsDelegate.html",
    "title": "Delegate NumericalSolver.GetRepondsDelegate | HiAPI-C# 2025",
    "summary": "Delegate NumericalSolver.GetRepondsDelegate Namespace Hi.Geom.Solvers Assembly HiGeom.dll Delegate for getting response values from the system being solved. public delegate double[] NumericalSolver.GetRepondsDelegate() Returns double[] The response values from the system Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Geom.Solvers.NumericalSolver.SetParasDelegate.html": {
    "href": "api/Hi.Geom.Solvers.NumericalSolver.SetParasDelegate.html",
    "title": "Delegate NumericalSolver.SetParasDelegate | HiAPI-C# 2025",
    "summary": "Delegate NumericalSolver.SetParasDelegate Namespace Hi.Geom.Solvers Assembly HiGeom.dll Delegate for setting parameter values in the system being solved. public delegate void NumericalSolver.SetParasDelegate(double[] paras) Parameters paras double[] The parameter values to set Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Geom.Solvers.NumericalSolver.html": {
    "href": "api/Hi.Geom.Solvers.NumericalSolver.html",
    "title": "Class NumericalSolver | HiAPI-C# 2025",
    "summary": "Class NumericalSolver Namespace Hi.Geom.Solvers Assembly HiGeom.dll A numerical solver for systems of equations using the Jacobian matrix. public class NumericalSolver Inheritance object NumericalSolver Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NumericalSolver(SetParasDelegate, int, GetRepondsDelegate, int, double, double, int) Initializes a new instance of the NumericalSolver class. public NumericalSolver(NumericalSolver.SetParasDelegate setParasFunc, int paraNum, NumericalSolver.GetRepondsDelegate getResponsesFunc, int targetNum, double partialInterval, double tolerance, int iterationLimit = 12) Parameters setParasFunc NumericalSolver.SetParasDelegate Function to set parameter values paraNum int Number of parameters in the system getResponsesFunc NumericalSolver.GetRepondsDelegate Function to get response values targetNum int Number of target values (equations) in the system partialInterval double Interval for calculating partial derivatives tolerance double Tolerance for convergence iterationLimit int Maximum number of iterations allowed Properties GetResponsesFunc Gets the function used to get response values. public NumericalSolver.GetRepondsDelegate GetResponsesFunc { get; } Property Value NumericalSolver.GetRepondsDelegate HalfPartialInterval Gets half of the partial interval value for optimization. public double HalfPartialInterval { get; } Property Value double IterationLimit Gets or sets the maximum number of iterations allowed. public int IterationLimit { get; set; } Property Value int ParaNum Gets or sets the number of parameters in the system. public int ParaNum { get; set; } Property Value int Paras Sets the parameter values in the system being solved. public double[] Paras { set; } Property Value double[] PartialInterval Gets or sets the interval used for calculating partial derivatives. public double PartialInterval { get; set; } Property Value double Responses Gets the response values from the system being solved. public double[] Responses { get; } Property Value double[] SetParasFunc Gets the function used to set parameter values. public NumericalSolver.SetParasDelegate SetParasFunc { get; } Property Value NumericalSolver.SetParasDelegate TargetNum Gets or sets the number of target values (equations) in the system. public int TargetNum { get; set; } Property Value int Tolerance Gets or sets the tolerance for convergence. public double Tolerance { get; set; } Property Value double Methods ErrorFunc(double[], double[]) Calculates the error (difference) between the system responses and target values. public double[] ErrorFunc(double[] paras, double[] targets) Parameters paras double[] The parameter values to use targets double[] The target values to compare against Returns double[] An array of error values Solve(double[], double[], out double, out double[,]) Solves the system of equations using numerical methods. public SolvingStatus Solve(double[] paras, double[] targets, out double minBias, out double[,] jacob) Parameters paras double[] The initial parameter values, will be modified during solving targets double[] The target values to solve for minBias double Output parameter that will contain the minimum bias (error) found jacob double[,] Output parameter that will contain the final Jacobian matrix Returns SolvingStatus The status of the solving process Remarks Note that the paras array will be modified during solving."
  },
  "api/Hi.Geom.Solvers.SolverUtil.html": {
    "href": "api/Hi.Geom.Solvers.SolverUtil.html",
    "title": "Class SolverUtil | HiAPI-C# 2025",
    "summary": "Class SolverUtil Namespace Hi.Geom.Solvers Assembly HiGeom.dll Utility class providing advanced numerical solving methods for systems of equations. public static class SolverUtil Inheritance object SolverUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Properties LinearSlowIterationFunc Gets a linear function for slow iteration convergence. public static Func<double, double> LinearSlowIterationFunc { get; } Property Value Func<double, double> LogSlowIterationFunc Gets a logarithmic function for slow iteration convergence. public static Func<double, double> LogSlowIterationFunc { get; } Property Value Func<double, double> Methods DeepSolveArray(Func<double[], double[]>, int, double[], double[], double, Func<double, double>, int, int, int) Performs deep solving of a function with multiple parameters. public static IEnumerable<DeepSolvingStatus> DeepSolveArray(Func<double[], double[]> func, int outputNum, double[] para, double[] dpara, double convergenceLimit, Func<double, double> slowIterationFunc = null, int maxDirectIteration = 6, int maxSlowIteration = 6, int maxTotalIteration = 1200) Parameters func Func<double[], double[]> The function to solve. outputNum int The number of output values. para double[] The initial parameter values. dpara double[] The parameter delta values. convergenceLimit double The convergence limit. slowIterationFunc Func<double, double> The function for slow iteration. maxDirectIteration int The maximum number of direct iterations. maxSlowIteration int The maximum number of slow iterations. maxTotalIteration int The maximum total number of iterations. Returns IEnumerable<DeepSolvingStatus> An enumerable of deep solving status objects. GetApproxInv(double[,], double) Calculates an approximate inverse of a matrix using SVD decomposition. public static double[,] GetApproxInv(double[,] mat, double availableAccumulatedWeightRatio = 0.99999999) Parameters mat double[,] The input matrix. availableAccumulatedWeightRatio double The ratio of accumulated weights to consider. Returns double[,] The approximate inverse matrix. GetApproxInvAndOrthogonalPaces(double[,], out List<(double eigenValue, double[] v)>) Calculates an approximate inverse of a matrix and returns orthogonal paces using SVD decomposition. public static double[,] GetApproxInvAndOrthogonalPaces(double[,] mat, out List<(double eigenValue, double[] v)> orthogonalPaces) Parameters mat double[,] The input matrix. orthogonalPaces List<(double eigenValue, double[] v)> The output list of orthogonal paces with eigenvalues and eigenvectors. Returns double[,] The approximate inverse matrix. GetBiases(Func<double[], double[]>, double[], double[]) Calculates the bias values between function outputs and target values. public static double[] GetBiases(Func<double[], double[]> func, double[] paras, double[] targets) Parameters func Func<double[], double[]> The function to evaluate. paras double[] The parameter values. targets double[] The target values. Returns double[] The bias values. GetCosSinTermRotationMat4d(Vec3d, double, double) Gets a rotation matrix from an axis and precomputed cosine/sine values using Rodrigues' rotation formula. public static Mat4d GetCosSinTermRotationMat4d(Vec3d axis, double cos, double sin) Parameters axis Vec3d The rotation axis (should be normalized). cos double The cosine of the rotation angle. sin double The sine of the rotation angle. Returns Mat4d A 4x4 rotation matrix. GetCosSinTermRotationMat4d(Vec3d, double, double, Vec3d) Gets a rotation matrix from an axis, precomputed cosine/sine values, and a pivot point. public static Mat4d GetCosSinTermRotationMat4d(Vec3d axis, double cos, double sin, Vec3d pivot) Parameters axis Vec3d The rotation axis (should be normalized). cos double The cosine of the rotation angle. sin double The sine of the rotation angle. pivot Vec3d The pivot point for the rotation. Returns Mat4d A 4x4 rotation matrix about the pivot point. GetJacobMat(Func<double[], double[]>, double[], double[], int) Calculates the Jacobian matrix for a function. public static double[,] GetJacobMat(Func<double[], double[]> func, double[] paras, double[] dparas, int targetNum) Parameters func Func<double[], double[]> The function to evaluate. paras double[] The parameter values. dparas double[] The parameter delta values. targetNum int The number of target values. Returns double[,] The Jacobian matrix. GetParasCompensation(Func<double[], double[]>, double[], double[], double[], out double[,]) Gets parameter compensation values based on the function, current parameters, parameter deltas, and target values. public static double[] GetParasCompensation(Func<double[], double[]> func, double[] paras, double[] dparas, double[] targets, out double[,] jacob) Parameters func Func<double[], double[]> The function to evaluate. paras double[] The current parameter values. dparas double[] The parameter delta values. targets double[] The target values. jacob double[,] The output Jacobian matrix. Returns double[] The parameter compensation values. GetParasCompensation(Func<double[], double[]>, double[], double[], double[], double[], out double[,]) Gets parameter compensation values based on the function, current parameters, parameter deltas, target values, and biases. public static double[] GetParasCompensation(Func<double[], double[]> func, double[] paras, double[] dparas, double[] targets, double[] biases, out double[,] jacob) Parameters func Func<double[], double[]> The function to evaluate. paras double[] The current parameter values. dparas double[] The parameter delta values. targets double[] The target values. biases double[] The bias values. jacob double[,] The output Jacobian matrix. Returns double[] The parameter compensation values. Solve(Func<double, double>, double, double, double, double, int) Solves a one-dimensional function for a target value. public static IEnumerable<SolvingResult> Solve(Func<double, double> func, double para, double dpara, double target, double convergenceLimit, int maxIteration = 12) Parameters func Func<double, double> The function to solve para double Initial parameter value dpara double Parameter step size for calculating derivatives target double Target value to solve for convergenceLimit double Convergence limit (acceptable error) maxIteration int Maximum number of iterations Returns IEnumerable<SolvingResult> A sequence of solving result objects showing the progress of the solution SolveArray(Func<double[], double[]>, double[], double[], double[], Func<double[], double>, double, int) Solves a multi-dimensional function for specified target values with a custom convergence function. public static IEnumerable<SolvingResult> SolveArray(Func<double[], double[]> func, double[] paras, double[] dparas, double[] targets, Func<double[], double> convergenceFunc, double convergenceLimit, int maxIteration = 12) Parameters func Func<double[], double[]> The function to solve paras double[] Initial parameter values dparas double[] Parameter step sizes for calculating derivatives targets double[] Target values to solve for convergenceFunc Func<double[], double> Function to calculate convergence from biases convergenceLimit double Convergence limit (acceptable error) maxIteration int Maximum number of iterations Returns IEnumerable<SolvingResult> A sequence of solving result objects showing the progress of the solution SolveArray(Func<double[], double[]>, double[], double[], int, double, int) Solves a multi-dimensional function with default convergence function. public static IEnumerable<SolvingResult> SolveArray(Func<double[], double[]> func, double[] paras, double[] dparas, int funcDstNum, double convergenceLimit, int maxIteration = 12) Parameters func Func<double[], double[]> The function to solve paras double[] Initial parameter values dparas double[] Parameter step sizes for calculating derivatives funcDstNum int Number of output values from the function convergenceLimit double Convergence limit (acceptable error) maxIteration int Maximum number of iterations Returns IEnumerable<SolvingResult> A sequence of solving result objects showing the progress of the solution SolveArray(Func<double[], double[]>, double[], double[], int, Func<double[], double>, double, int) Solves a multi-dimensional function with a specified convergence function. public static IEnumerable<SolvingResult> SolveArray(Func<double[], double[]> func, double[] paras, double[] dparas, int funcDstNum, Func<double[], double> convergenceFunc, double convergenceLimit, int maxIteration = 12) Parameters func Func<double[], double[]> The function to solve paras double[] Initial parameter values dparas double[] Parameter step sizes for calculating derivatives funcDstNum int Number of output values from the function convergenceFunc Func<double[], double> Function to calculate convergence from biases convergenceLimit double Convergence limit (acceptable error) maxIteration int Maximum number of iterations Returns IEnumerable<SolvingResult> A sequence of solving result objects showing the progress of the solution Test() Internal Use Only public static void Test() Test2() Internal Use Only public static void Test2()"
  },
  "api/Hi.Geom.Solvers.SolvingResult.html": {
    "href": "api/Hi.Geom.Solvers.SolvingResult.html",
    "title": "Class SolvingResult | HiAPI-C# 2025",
    "summary": "Class SolvingResult Namespace Hi.Geom.Solvers Assembly HiGeom.dll Represents the result of a solving process. Contains detailed information about the solution including parameters, biases, and convergence metrics. public class SolvingResult Inheritance object SolvingResult Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SolvingResult(SolvingStatus, double[], double[], double, int, int, double[], double[,]) Initializes a new instance of the SolvingResult class. public SolvingResult(SolvingStatus solvingResultStatus, double[] workingParas, double[] biases, double convergence, int iteration, int continuousSlowMomentumIteration, double[] paraCompensationOnNext, double[,] jacob) Parameters solvingResultStatus SolvingStatus The status of the solving process workingParas double[] The current working parameter values biases double[] The bias values for each constraint convergence double The convergence metric iteration int The total number of iterations performed continuousSlowMomentumIteration int The number of continuous iterations using slow momentum method paraCompensationOnNext double[] Parameter compensation values for the next iteration jacob double[,] The Jacobian matrix Fields biases The bias (error) values for each constraint. public double[] biases Field Value double[] continuousSlowMomentumIteration The number of continuous iterations using slow momentum method. public int continuousSlowMomentumIteration Field Value int convergence The convergence metric (overall error). public double convergence Field Value double iteration The total number of iterations performed. public int iteration Field Value int jacob The Jacobian matrix for the current iteration. public double[,] jacob Field Value double[,] paraCompensationOnNext Parameter compensation values to apply in the next iteration. public double[] paraCompensationOnNext Field Value double[] solvingResultStatus The status of the solving process. public SolvingStatus solvingResultStatus Field Value SolvingStatus workingParas The current working parameter values. public double[] workingParas Field Value double[] Methods ToString(string) Returns a string representation of the solving result with the specified numeric format. public string ToString(string format) Parameters format string The numeric format string to use for formatting numeric values Returns string A string representation of the solving result"
  },
  "api/Hi.Geom.Solvers.SolvingStatus.html": {
    "href": "api/Hi.Geom.Solvers.SolvingStatus.html",
    "title": "Enum SolvingStatus | HiAPI-C# 2025",
    "summary": "Enum SolvingStatus Namespace Hi.Geom.Solvers Assembly HiGeom.dll Enumeration of possible statuses for solving results. public enum SolvingStatus Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Iterating = 4 Currently in the process of iterating. NotCal = 0 Not calculated yet. OverIteration = 3 Exceeded maximum number of iterations. Singular = 2 Singular condition encountered during solving. Solved = 1 Successfully solved."
  },
  "api/Hi.Geom.Solvers.SolvingTerm.html": {
    "href": "api/Hi.Geom.Solvers.SolvingTerm.html",
    "title": "Enum SolvingTerm | HiAPI-C# 2025",
    "summary": "Enum SolvingTerm Namespace Hi.Geom.Solvers Assembly HiGeom.dll Enumeration of solving terms or methods used in geometric solvers. public enum SolvingTerm Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Direct = 1 Direct solving method, typically using analytical solutions. Side = 2 Side solving method, typically used for auxiliary calculations. Slow = 0 Slow solving method, typically using iterative approaches."
  },
  "api/Hi.Geom.Solvers.html": {
    "href": "api/Hi.Geom.Solvers.html",
    "title": "Namespace Hi.Geom.Solvers | HiAPI-C# 2025",
    "summary": "Namespace Hi.Geom.Solvers Classes BinarySolverUtil Utility class providing binary solving methods for one-dimensional functions. BinarySolvingEntry Represents the status of a binary solving process. Contains information about the current state of the solver including best solutions and error metrics. DeepSolvingStatus Represents the status of a deep solving process with multiple parameters. Contains detailed information about the solving process including iterations, convergence, and Jacobian matrix. NumericalSolver A numerical solver for systems of equations using the Jacobian matrix. SolverUtil Utility class providing advanced numerical solving methods for systems of equations. SolvingResult Represents the result of a solving process. Contains detailed information about the solution including parameters, biases, and convergence metrics. Enums SolvingStatus Enumeration of possible statuses for solving results. SolvingTerm Enumeration of solving terms or methods used in geometric solvers. Delegates NumericalSolver.GetRepondsDelegate Delegate for getting response values from the system being solved. NumericalSolver.SetParasDelegate Delegate for setting parameter values in the system being solved."
  },
  "api/Hi.Geom.Stl.StlType.html": {
    "href": "api/Hi.Geom.Stl.StlType.html",
    "title": "Enum Stl.StlType | HiAPI-C# 2025",
    "summary": "Enum Stl.StlType Namespace Hi.Geom Assembly HiGeom.dll Stl file format. public enum Stl.StlType Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields ASCII = 1 ASCII format BINARY = 2 Binary format UNKNOWN = 0 unknown format"
  },
  "api/Hi.Geom.Stl.html": {
    "href": "api/Hi.Geom.Stl.html",
    "title": "Class Stl | HiAPI-C# 2025",
    "summary": "Class Stl Namespace Hi.Geom Assembly HiGeom.dll STL (stereolithography). Composed by Triangles. Provide Stl File R/W. public class Stl : IGetStl, IExpandToBox3d Inheritance object Stl Implements IGetStl IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods GeomUtil.ExpandToBox3d(IExpandToBox3d, Mat4d, Box3d) GeomUtil.GetBox3d(IExpandToBox3d) PairZrUtil.GetZrList(IGetStl) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Stl(Box3d) Ctor by box. public Stl(Box3d box) Parameters box Box3d box Stl(Stl) Copy ctor. public Stl(Stl stl) Parameters stl Stl src stl Stl(params Stl[]) Ctor. Copy triangles from stls. public Stl(params Stl[] stls) Parameters stls Stl[] source stls Stl(IEnumerable<Tri3d>) Ctor. The content of tris is copied by this.tris = new List(tris). public Stl(IEnumerable<Tri3d> tris) Parameters tris IEnumerable<Tri3d> triangles Stl(Stream, StlType) Ctor by stream. public Stl(Stream stream, Stl.StlType stlType = StlType.UNKNOWN) Parameters stream Stream stl data stream stlType Stl.StlType stl data format Stl(Stream, StlType, CancellationToken) Ctor by stream with cooperative cancellation. The reading loops observe cancel periodically. public Stl(Stream stream, Stl.StlType stlType, CancellationToken cancel) Parameters stream Stream stl data stream stlType Stl.StlType stl data format cancel CancellationToken Token to cancel the read; cancelling throws OperationCanceledException and leaves this instance unusable. Stl(int) Ctor with preserved triangle grid capacity. public Stl(int cap = 16) Parameters cap int Preserved triangle grid capacity Stl(string, StlType) ctor by file. public Stl(string file, Stl.StlType stlType = StlType.UNKNOWN) Parameters file string stl file stlType Stl.StlType stl file format Stl(string, StlType, CancellationToken) Ctor by file with cooperative cancellation. The reading loops observe cancel periodically, so aborting a large file load (hundreds of MB) takes effect promptly instead of running to completion. public Stl(string file, Stl.StlType stlType, CancellationToken cancel) Parameters file string stl file stlType Stl.StlType stl file format cancel CancellationToken Token to cancel the read; cancelling throws OperationCanceledException and leaves this instance unusable. Fields DegenerateCrossTolerance Cross-product length below which a triangle counts as degenerate for RemoveDegenerateTris(double) (1e-12 mm², i.e. two edges collinear or a vertex pair coincident to ~1e-6 mm). public const double DegenerateCrossTolerance = 1E-12 Field Value double Properties Area Gets the total surface area of the STL model public double Area { get; } Property Value double Tris public List<Tri3d> Tris { get; set; } Property Value List<Tri3d> Triangle grid of this. Methods ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetStl() Gets the STL geometry data. public Stl GetStl() Returns Stl The STL geometry object IsAscii(Stream) Is the stream ascii format stl. public static bool IsAscii(Stream stream) Parameters stream Stream stream Returns bool true if the stream is ascii format stl; otherwise, return false. IsAscii(string) Is the file ascii format stl. public static bool IsAscii(string file) Parameters file string file Returns bool true if the file is ascii format stl; otherwise, return false. ReBuildNormal() Re-build normal for all triangles. public void ReBuildNormal() RemoveDegenerateTris(double) Drops triangles whose cross product is (numerically) the zero vector. A mesh consumer that orients triangles exactly — the native sweep — aborts on such a triangle, and it contributes no surface anyway. public int RemoveDegenerateTris(double crossTolerance = 1E-12) Parameters crossTolerance double Returns int The number of triangles removed. Transform(Mat4d) Trasnform all the triangles by the given matrix. public Stl Transform(Mat4d mat) Parameters mat Mat4d matrix Returns Stl this WriteBin(BinaryWriter) Write this to the writer with binary format. public void WriteBin(BinaryWriter writer) Parameters writer BinaryWriter writer WriteBin(string) Write this to the file with binary format. public void WriteBin(string file) Parameters file string dst file"
  },
  "api/Hi.Geom.StlFile.html": {
    "href": "api/Hi.Geom.StlFile.html",
    "title": "Class StlFile | HiAPI-C# 2025",
    "summary": "Class StlFile Namespace Hi.Geom Assembly HiGeom.dll Represents an STL file with loading and saving capabilities public class StlFile : IStlSource, IGetStl, IMakeXmlSource, IExpandToBox3d, IDuplicate, ISourceFile, IToPresentDto Inheritance object StlFile Implements IStlSource IGetStl IMakeXmlSource IExpandToBox3d IDuplicate ISourceFile IToPresentDto Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods XmlUtil.MakeXmlSourceToFile(IMakeXmlSource, string, bool) XmlUtil.MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) XmlUtil.SaveToByteArrayAsync(IMakeXmlSource, string) GeomUtil.ExpandToBox3d(IExpandToBox3d, Mat4d, Box3d) GeomUtil.GetBox3d(IExpandToBox3d) PairZrUtil.GetZrList(IGetStl) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors StlFile() Ctor. public StlFile() StlFile(string) Ctor. public StlFile(string filePath) Parameters filePath string file path StlFile(string, string) Initializes a new instance with the specified file path and optional base directory. If base directory is provided, the STL will be loaded immediately. public StlFile(string filePath, string baseDirectory) Parameters filePath string STL file path baseDirectory string Base directory to load file from StlFile(XElement, string, IProgress<IMessage>) Ctor. public StlFile(XElement src, string baseDirectory, IProgress<IMessage> progress) Parameters src XElement XML baseDirectory string Base directory path progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. Properties CacheStl CacheStl is loaded by the xml construtor. public Stl CacheStl { get; set; } Property Value Stl SourceFile Stl file path. public string SourceFile { get; set; } Property Value string XName Name for XML IO. public static string XName { get; } Property Value string Methods Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetStl() Gets the STL geometry data. public Stl GetStl() Returns Stl The STL geometry object LoadStlByFile(string) Loads an STL file from the specified base directory into the cache public Stl LoadStlByFile(string baseDirectory) Parameters baseDirectory string The base directory where the file is located Returns Stl The loaded STL object, or null if the file path is empty or loading fails LoadStlByFile(string, CancellationToken) Loads an STL file from the specified base directory into the cache, with cooperative cancellation of the underlying read. A cancelled load throws OperationCanceledException and leaves CacheStl unchanged (the previous cache, if any, stays valid). public Stl LoadStlByFile(string baseDirectory, CancellationToken cancel) Parameters baseDirectory string The base directory where the file is located cancel CancellationToken Token to cancel the read Returns Stl The loaded STL object, or null if the file path is empty MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SaveStlToFile(string) Saves the cached STL data to a file in the specified base directory public void SaveStlToFile(string baseDirectory) Parameters baseDirectory string The base directory where the file will be saved Remarks Does nothing when there is no path or no cached mesh. A source file that was never loaded (missing on disk) must stay missing — the read side then reports a FileNotFoundException naming the path — rather than be replaced by a 0-byte STL, which reads back as an opaque “Stl Loading failed” and gets committed into project repositories. ToPresentDto() Convert StlFile to presentation DTO (Data Transfer Object) for JSON serialization. The returned object includes type metadata for web API presentation. public object ToPresentDto() Returns object DTO dictionary with Type and SourceFile keys"
  },
  "api/Hi.Geom.StlFuncHost.html": {
    "href": "api/Hi.Geom.StlFuncHost.html",
    "title": "Class StlFuncHost | HiAPI-C# 2025",
    "summary": "Class StlFuncHost Namespace Hi.Geom Assembly HiGeom.dll A class that hosts a function to generate STL geometry. public class StlFuncHost : IGetStl Inheritance object StlFuncHost Implements IGetStl Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods PairZrUtil.GetZrList(IGetStl) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors StlFuncHost() Default constructor. public StlFuncHost() StlFuncHost(Func<Stl>) Constructor with STL generator function. public StlFuncHost(Func<Stl> stlHostFunc) Parameters stlHostFunc Func<Stl> Function that generates an STL object Properties StlHostFunc Gets or sets the function that generates the STL object. public Func<Stl> StlHostFunc { get; set; } Property Value Func<Stl> Methods GetStl() Gets the STL geometry by invoking the hosted function. public Stl GetStl() Returns Stl The generated STL object"
  },
  "api/Hi.Geom.StlUtil.html": {
    "href": "api/Hi.Geom.StlUtil.html",
    "title": "Class StlUtil | HiAPI-C# 2025",
    "summary": "Class StlUtil Namespace Hi.Geom Assembly HiDisp.dll Utility for Stl. public static class StlUtil Inheritance object StlUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods ToFaceDrawing(IGetStl) To Drawing, in form of faces, at the source's default resolution. If the source yields no Stl, return null. public static Drawing ToFaceDrawing(this IGetStl src) Parameters src IGetStl src Returns Drawing Face Drawing ToLineDrawing(IGetStl) To Drawing, in form of lines, at the source's default resolution. If the source yields no Stl, return null. public static Drawing ToLineDrawing(this IGetStl src) Parameters src IGetStl src Returns Drawing Lines Drawing ToSparkleLineDrawing(IGetStl) Converts an STL geometry to a sparkle line drawing, at the source's default resolution. public static Drawing ToSparkleLineDrawing(this IGetStl src) Parameters src IGetStl The source STL geometry. Returns Drawing A sparkle line drawing, or null if the STL or its triangles are null."
  },
  "api/Hi.Geom.Topo.CarveBooleanKind.html": {
    "href": "api/Hi.Geom.Topo.CarveBooleanKind.html",
    "title": "Enum CarveBooleanKind | HiAPI-C# 2025",
    "summary": "Enum CarveBooleanKind Namespace Hi.Geom.Topo Assembly HiDisp.dll What a carve boolean did to the workpiece container. public enum CarveBooleanKind Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields AddedShell = 1 Union with a strictly disjoint tool: the tool joined as a second shell. Crossed = 0 The surfaces crossed and were stitched along the seam contour. Kept = 2 The operation was a no-op (e.g. union with a tool inside the workpiece). Replaced = 3 Union with an enclosing tool: the workpiece content was replaced by the tool."
  },
  "api/Hi.Geom.Topo.CarveBooleanResult.html": {
    "href": "api/Hi.Geom.Topo.CarveBooleanResult.html",
    "title": "Class CarveBooleanResult | HiAPI-C# 2025",
    "summary": "Class CarveBooleanResult Namespace Hi.Geom.Topo Assembly HiDisp.dll Result of one carve boolean step. On failure the workpiece is untouched and the step may simply be skipped. public sealed class CarveBooleanResult Inheritance object CarveBooleanResult Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties FailReason Reason of a failed step, empty otherwise. public string FailReason { get; } Property Value string Failed Whether the boolean refused the step (non-manifold cut, contact without crossing, ...). public bool Failed { get; } Property Value bool KeyLines The seam contour segments (double-evaluated copies of the exact seam). public IReadOnlyList<Segment3d> KeyLines { get; } Property Value IReadOnlyList<Segment3d> Kind What the boolean did. Meaningless when Failed is set. public CarveBooleanKind Kind { get; } Property Value CarveBooleanKind RemovedWorkpieceTris Number of workpiece triangles removed by the surgery. public int RemovedWorkpieceTris { get; } Property Value int SewnToolTris Number of tool triangles sewn into the workpiece. public int SewnToolTris { get; } Property Value int"
  },
  "api/Hi.Geom.Topo.CarveStl.html": {
    "href": "api/Hi.Geom.Topo.CarveStl.html",
    "title": "Class CarveStl | HiAPI-C# 2025",
    "summary": "Class CarveStl Namespace Hi.Geom.Topo Assembly HiDisp.dll A triangle mesh that can be carved: an exact-fraction topology graph with an incrementally maintained spatial index, mutated in place by exact boolean steps (SubstractVolume(Stl, double) / AddVolume(Stl, double)). Unlike NativeTopoStl3wfr (build-once sweeping input), this object is long-lived and accumulates cut geometry step after step; sharp edges and exact planar faces survive the booleans exactly. Not thread-safe. public class CarveStl : IDisposable, IDisplayee, IExpandToBox3d Inheritance object CarveStl Implements IDisposable IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks Conversion loss, by source: NativeTopoStl3wfr and another CarveStl are already exact fractions, so those overloads copy coordinates verbatim and take no tolerance — the only lossless inbound paths. Stl and NativeTopoStl3d hold doubles, which have no small-denominator exact form, so those overloads convert at fractionTolerance. The loss is inherent to the source type, not to the route: converting such a mesh by any other path costs the same. Outbound, GenStl() evaluates to double, so a carved result round-tripped through it loses the compound coordinates the booleans produced. Keep the CarveStl itself, or pass it directly as a tool, when the exact surface is the deliverable. Constructors CarveStl(Stl, double) Initializes the container from an STL model. The triangles are converted to exact fractions at fractionTolerance. public CarveStl(Stl stl, double fractionTolerance) Parameters stl Stl The initial workpiece mesh (a closed shell). fractionTolerance double The tolerance for fraction conversion. CarveStl(CarveStl) Initializes the container as an exact copy of another CarveStl — a snapshot that later boolean steps on either object leave untouched. Lossless. public CarveStl(CarveStl src) Parameters src CarveStl The container to copy. CarveStl(NativeTopoStl3d, double) Initializes the container from a double-precision topology graph. The triangles are converted to exact fractions at fractionTolerance — the source holds doubles, so this is inherently the lossy path. public CarveStl(NativeTopoStl3d src, double fractionTolerance) Parameters src NativeTopoStl3d The source mesh (a closed shell). fractionTolerance double The tolerance for fraction conversion. CarveStl(NativeTopoStl3wfr) Initializes the container from an exact-fraction topology graph, copying every coordinate verbatim. Lossless, hence no tolerance: the source is already the same numeric type. The source is only read. public CarveStl(NativeTopoStl3wfr src) Parameters src NativeTopoStl3wfr The source mesh (a closed shell). Properties CarvePtr Gets the pointer to the native container. public nint CarvePtr { get; } Property Value nint IsSeamless Gets whether every directed edge is paired with an owned reverse (the manifold invariant the booleans maintain). public bool IsSeamless { get; } Property Value bool Size Gets the number of triangles currently in the container. public int Size { get; } Property Value int Methods AddVolume(Stl, double) Exact in-place union: merges the tool volume into the container. Same calling contract as SubstractVolume(Stl, double). public CarveBooleanResult AddVolume(Stl tool, double fractionTolerance) Parameters tool Stl The tool mesh (a closed shell). fractionTolerance double The tolerance for the tool's fraction conversion. Returns CarveBooleanResult The step result; on failure the container is untouched. AddVolume(CarveStl) Exact in-place union with another container's current state. Lossless; tool is only read. public CarveBooleanResult AddVolume(CarveStl tool) Parameters tool CarveStl The container whose volume is merged in. Returns CarveBooleanResult The step result; on failure this container is untouched. AddVolume(NativeTopoStl3wfr) Exact in-place union with an exact-fraction tool — the lossless tool path, hence no tolerance. The tool mesh is copied natively before the surgery consumes it, so tool survives the call. public CarveBooleanResult AddVolume(NativeTopoStl3wfr tool) Parameters tool NativeTopoStl3wfr The tool mesh (a closed shell). Returns CarveBooleanResult The step result; on failure the container is untouched. Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box ~CarveStl() protected ~CarveStl() GenStl() Generates an STL model from the container's current state. public Stl GenStl() Returns Stl A new STL model. SubstractVolume(Stl, double) Exact in-place difference: carves the tool volume out of the container. The tool triangles are consumed natively per call, so the same Stl may be reused for further steps. public CarveBooleanResult SubstractVolume(Stl tool, double fractionTolerance) Parameters tool Stl The tool mesh (a closed shell). fractionTolerance double The tolerance for the tool's fraction conversion. Returns CarveBooleanResult The step result; on failure the container is untouched. SubstractVolume(CarveStl) Exact in-place difference using another container's current state as the tool. Lossless; tool is only read. public CarveBooleanResult SubstractVolume(CarveStl tool) Parameters tool CarveStl The container whose volume is carved away. Returns CarveBooleanResult The step result; on failure this container is untouched. SubstractVolume(NativeTopoStl3wfr) Exact in-place difference with an exact-fraction tool — the lossless tool path, hence no tolerance. The tool mesh is copied natively before the surgery consumes it, so tool survives the call and may be reused for further steps. public CarveBooleanResult SubstractVolume(NativeTopoStl3wfr tool) Parameters tool NativeTopoStl3wfr The tool mesh (a closed shell). Returns CarveBooleanResult The step result; on failure the container is untouched."
  },
  "api/Hi.Geom.Topo.NativeTopoStl3d.html": {
    "href": "api/Hi.Geom.Topo.NativeTopoStl3d.html",
    "title": "Class NativeTopoStl3d | HiAPI-C# 2025",
    "summary": "Class NativeTopoStl3d Namespace Hi.Geom.Topo Assembly HiDisp.dll Native TopoStl with element type double. public class NativeTopoStl3d : IDisposable, IDisplayee, IExpandToBox3d Inheritance object NativeTopoStl3d Implements IDisposable IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NativeTopoStl3d(Stl) Initializes a new instance of the NativeTopoStl3d class. public NativeTopoStl3d(Stl stl) Parameters stl Stl The STL model to convert to a native topology. Properties CosRoundAngle Gets or sets the cosine of the angle used for rounding. public double CosRoundAngle { get; set; } Property Value double Size Gets the number of triangles in the native topology. public int Size { get; } Property Value int TopoStlPtr Gets the pointer to the native topology structure. public nint TopoStlPtr { get; } Property Value nint Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. DisplaySharpEdges(Bind) Renders only the edges of the topology. public void DisplaySharpEdges(Bind bind) Parameters bind Bind The binding context for rendering. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box ~NativeTopoStl3d() protected ~NativeTopoStl3d() GenStl() Generates an STL model from the native topology. public Stl GenStl() Returns Stl A new STL model."
  },
  "api/Hi.Geom.Topo.NativeTopoStl3wfr.html": {
    "href": "api/Hi.Geom.Topo.NativeTopoStl3wfr.html",
    "title": "Class NativeTopoStl3wfr | HiAPI-C# 2025",
    "summary": "Class NativeTopoStl3wfr Namespace Hi.Geom.Topo Assembly HiDisp.dll Native TopoStl with element type fraction. public class NativeTopoStl3wfr : IDisposable, IDisplayee, IExpandToBox3d Inheritance object NativeTopoStl3wfr Implements IDisposable IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NativeTopoStl3wfr(Stl, double) Initializes a new instance of the NativeTopoStl3wfr class. public NativeTopoStl3wfr(Stl stl, double fractionTolerance) Parameters stl Stl The STL model to convert to a native topology. fractionTolerance double The tolerance for fraction calculations. Properties Size Gets the number of triangles in the native topology. public int Size { get; } Property Value int TopoStlPtr Gets the pointer to the native topology structure. public nint TopoStlPtr { get; } Property Value nint Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box ~NativeTopoStl3wfr() protected ~NativeTopoStl3wfr() GenStl() Generates an STL model from the native topology. public Stl GenStl() Returns Stl A new STL model."
  },
  "api/Hi.Geom.Topo.TopoLine3Hfr.html": {
    "href": "api/Hi.Geom.Topo.TopoLine3Hfr.html",
    "title": "Class TopoLine3Hfr | HiAPI-C# 2025",
    "summary": "Class TopoLine3Hfr Namespace Hi.Geom.Topo Assembly HiDisp.dll Topological 3D line (directed edge) with Fraction<decimal> coordinates. Maintains connectivity to adjacent reversed line and owning triangle. Corresponds to C++ topo_line3wfr_t. public class TopoLine3Hfr Inheritance object TopoLine3Hfr Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields P0 Start point. public readonly TopoPoint3Hfr P0 Field Value TopoPoint3Hfr P1 End point. public readonly TopoPoint3Hfr P1 Field Value TopoPoint3Hfr ReversedLine The reversed (opposite direction) line sharing the same two endpoints. Null if no adjacent triangle shares this edge in reverse. public TopoLine3Hfr ReversedLine Field Value TopoLine3Hfr Tri The triangle that owns this directed line. Null if this line is not yet part of a triangle. public TopoTri3Hfr Tri Field Value TopoTri3Hfr Methods ClearCache() Clears cached arrow and direction. public void ClearCache() GetArrow() Gets the arrow vector (P1 - P0) in fraction coordinates. Cached after first computation. public Vec3Hfr GetArrow() Returns Vec3Hfr GetDirection() Gets the normalized direction vector in double precision. Cached after first computation. public Vec3d GetDirection() Returns Vec3d ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Geom.Topo.TopoLine3StockHfr.html": {
    "href": "api/Hi.Geom.Topo.TopoLine3StockHfr.html",
    "title": "Class TopoLine3StockHfr | HiAPI-C# 2025",
    "summary": "Class TopoLine3StockHfr Namespace Hi.Geom.Topo Assembly HiDisp.dll Stock (pool) of topological lines with deduplication based on endpoint identity. Corresponds to C++ topo_line3wfr_stock_t. public class TopoLine3StockHfr Inheritance object TopoLine3StockHfr Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors TopoLine3StockHfr(int) Initializes a new line stock with the specified capacity. public TopoLine3StockHfr(int capacity) Parameters capacity int Properties Count Gets the number of lines. public int Count { get; } Property Value int Lines Gets all lines in the stock. public IEnumerable<TopoLine3Hfr> Lines { get; } Property Value IEnumerable<TopoLine3Hfr> Methods BuildAdjacentLineIfExisted(TopoLine3Hfr) Builds the reversed line link for a single line if the reverse exists. public void BuildAdjacentLineIfExisted(TopoLine3Hfr tl) Parameters tl TopoLine3Hfr BuildAdjacentLinesIfExisted() Builds reversed line links for all lines in the stock. Corresponds to C++ build_adjacent_lines_if_existed. public void BuildAdjacentLinesIfExisted() Call(TopoPoint3Hfr, TopoPoint3Hfr) Gets or creates a topological line from p0 to p1. Thread-safe. If a line with the same endpoints already exists, returns the existing one. public TopoLine3Hfr Call(TopoPoint3Hfr p0, TopoPoint3Hfr p1) Parameters p0 TopoPoint3Hfr p1 TopoPoint3Hfr Returns TopoLine3Hfr CallIfExisted(TopoPoint3Hfr, TopoPoint3Hfr) Gets an existing topological line from p0 to p1, or null if not found. Thread-safe. public TopoLine3Hfr CallIfExisted(TopoPoint3Hfr p0, TopoPoint3Hfr p1) Parameters p0 TopoPoint3Hfr p1 TopoPoint3Hfr Returns TopoLine3Hfr Del(TopoLine3Hfr) Removes a line from the stock and cleans up connectivity. Thread-safe. public void Del(TopoLine3Hfr line) Parameters line TopoLine3Hfr"
  },
  "api/Hi.Geom.Topo.TopoPoint3Hfr.html": {
    "href": "api/Hi.Geom.Topo.TopoPoint3Hfr.html",
    "title": "Class TopoPoint3Hfr | HiAPI-C# 2025",
    "summary": "Class TopoPoint3Hfr Namespace Hi.Geom.Topo Assembly HiDisp.dll Topological 3D point with Fraction<decimal> coordinates. Maintains connectivity to adjacent lines and triangles. Corresponds to C++ topo_point3wfr_t. public class TopoPoint3Hfr Inheritance object TopoPoint3Hfr Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields BackwardLines Backward lines (lines ending at this point). Do not modify directly. public readonly List<TopoLine3Hfr> BackwardLines Field Value List<TopoLine3Hfr> ForwardLines Forward lines (lines starting from this point). Do not modify directly. public readonly List<TopoLine3Hfr> ForwardLines Field Value List<TopoLine3Hfr> Position The position in fraction coordinates. public Vec3Hfr Position Field Value Vec3Hfr Tris Triangles that contain this point. Do not modify directly. public readonly List<TopoTri3Hfr> Tris Field Value List<TopoTri3Hfr> Properties IsIsolated Whether the point is isolated (no forward lines). public bool IsIsolated { get; } Property Value bool IsSeamless Whether the point is seamless (all forward lines have a reversed line with a triangle). public bool IsSeamless { get; } Property Value bool Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Geom.Topo.TopoPoint3StockHfr.html": {
    "href": "api/Hi.Geom.Topo.TopoPoint3StockHfr.html",
    "title": "Class TopoPoint3StockHfr | HiAPI-C# 2025",
    "summary": "Class TopoPoint3StockHfr Namespace Hi.Geom.Topo Assembly HiDisp.dll Stock (pool) of topological points with deduplication based on fraction coordinates. Corresponds to C++ topo_point3wfr_stock_t. public class TopoPoint3StockHfr Inheritance object TopoPoint3StockHfr Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors TopoPoint3StockHfr(int) Initializes a new point stock with the specified capacity. public TopoPoint3StockHfr(int capacity) Parameters capacity int Properties Count Gets the number of points. public int Count { get; } Property Value int Points Gets all points in the stock. public IEnumerable<TopoPoint3Hfr> Points { get; } Property Value IEnumerable<TopoPoint3Hfr> Methods Call(Vec3Hfr) Gets or creates a topological point at the given position. Thread-safe. If a point with the same coordinates already exists, returns the existing one. public TopoPoint3Hfr Call(Vec3Hfr v) Parameters v Vec3Hfr Returns TopoPoint3Hfr CallIfExisted(Vec3Hfr) Gets an existing topological point at the given position, or null if not found. Thread-safe. public TopoPoint3Hfr CallIfExisted(Vec3Hfr v) Parameters v Vec3Hfr Returns TopoPoint3Hfr Del(TopoPoint3Hfr) Removes a point from the stock. Thread-safe. public void Del(TopoPoint3Hfr tp) Parameters tp TopoPoint3Hfr ExpandToBox3d(Box3d) Expands a Box3d to include all points. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d"
  },
  "api/Hi.Geom.Topo.TopoStl3Hfr.html": {
    "href": "api/Hi.Geom.Topo.TopoStl3Hfr.html",
    "title": "Class TopoStl3Hfr | HiAPI-C# 2025",
    "summary": "Class TopoStl3Hfr Namespace Hi.Geom.Topo Assembly HiDisp.dll Pure C# topological STL (triangle mesh) with Fraction<decimal> coordinates. Hfr: High-Precision (decimal) FRaction. Provides unlimited-precision exact arithmetic for geometric computations without relying on native (C++) interop. Corresponds to C++ topo_stl3wfr_t. public class TopoStl3Hfr : IDisplayee, IExpandToBox3d, IDisposable Inheritance object TopoStl3Hfr Implements IDisplayee IExpandToBox3d IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors TopoStl3Hfr(Stl, decimal) Initializes a topological STL from an Stl model. public TopoStl3Hfr(Stl stl, decimal fractionResolution) Parameters stl Stl Source STL model. fractionResolution decimal Fraction approximation resolution (decimal). TopoStl3Hfr(IReadOnlyList<Vec3Hfr[]>) Initializes a topological STL from fraction-precision triangles (Vec3Hfr arrays). Each element is a 3-element array of Vec3Hfr representing triangle apexes. Corresponds to C++ constructor topo_stl3wfr_t(Tri3fr_Iter, Tri3fr_Iter). public TopoStl3Hfr(IReadOnlyList<Vec3Hfr[]> tris) Parameters tris IReadOnlyList<Vec3Hfr[]> Source triangles as arrays of 3 Vec3Hfr. TopoStl3Hfr(IReadOnlyList<Tri3d>, decimal) Initializes a topological STL from double-precision triangles. Phase 1 (parallel): converts vertices to fraction coordinates via Stern-Brocot approximation. Phase 2 (sequential): builds topology (stocks, connectivity). Corresponds to C++ constructor topo_stl3wfr_t(Tri3d_Iter, Tri3d_Iter, double). public TopoStl3Hfr(IReadOnlyList<Tri3d> tris, decimal fractionResolution) Parameters tris IReadOnlyList<Tri3d> Source triangles. fractionResolution decimal Fraction approximation resolution (decimal). TopoStl3Hfr(int) Initializes an empty topological STL with the specified triangle capacity. public TopoStl3Hfr(int trisCap) Parameters trisCap int Expected number of triangles (for pre-allocation). Fields TlStock The line stock for this topological STL. public readonly TopoLine3StockHfr TlStock Field Value TopoLine3StockHfr TpStock The point stock for this topological STL. public readonly TopoPoint3StockHfr TpStock Field Value TopoPoint3StockHfr TtStock The triangle stock for this topological STL. public readonly TopoTri3StockHfr TtStock Field Value TopoTri3StockHfr Properties Count Gets the number of triangles. public int Count { get; } Property Value int FlatDisplayee Gets the flat-shaded displayee for this topological STL. Created lazily on first access. public TopoStl3HfrFlatDisplayee FlatDisplayee { get; } Property Value TopoStl3HfrFlatDisplayee Methods ClearDrawingsCache() Invalidates all cached displayees. Call this after modifying the topology. public void ClearDrawingsCache() Display(Bind) Displays the topological STL using flat shading. For smooth rendering, use TopoStl3HfrSmoothDisplayee. public void Display(Bind bind) Parameters bind Bind The rendering bind context. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) Disposes the cached drawings. protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToBox3d(Box3d) Expands the box to include all points. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d IsSeamless() Checks whether the mesh is seamless (all edges have a properly paired reversed line). A seamless mesh is a necessary condition for a manifold (closed, watertight) geometry. Corresponds to C++ is_seamless(). public bool IsSeamless() Returns bool True if every directed edge has a reversed line with a triangle. IsSeamless(List<TopoLine3Hfr>) Checks whether the mesh is seamless. Defect lines are output to dstDefectLines. Corresponds to C++ is_seamless(vector<topo_line3wfr_t*>&). public bool IsSeamless(List<TopoLine3Hfr> dstDefectLines) Parameters dstDefectLines List<TopoLine3Hfr> Output list for defect (non-seamless) lines. Returns bool True if the mesh is fully seamless. ToStl() Converts to an Stl model. public Stl ToStl() Returns Stl ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. ToTris() Converts all triangles to a list of Tri3d (double precision). Corresponds to C++ to_tris(). public List<Tri3d> ToTris() Returns List<Tri3d>"
  },
  "api/Hi.Geom.Topo.TopoStl3HfrFlatDisplayee.html": {
    "href": "api/Hi.Geom.Topo.TopoStl3HfrFlatDisplayee.html",
    "title": "Class TopoStl3HfrFlatDisplayee | HiAPI-C# 2025",
    "summary": "Class TopoStl3HfrFlatDisplayee Namespace Hi.Geom.Topo Assembly HiDisp.dll Flat-shaded displayee for TopoStl3Hfr. Renders flat triangle faces (one normal per triangle) and all unique edge lines. Corresponds to C++ topo_stl3::_flatDraw + all-lines draw. public class TopoStl3HfrFlatDisplayee : IDisplayee, IExpandToBox3d, IDisposable Inheritance object TopoStl3HfrFlatDisplayee Implements IDisplayee IExpandToBox3d IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors TopoStl3HfrFlatDisplayee(TopoStl3Hfr) Initializes a new flat displayee wrapping the given TopoStl3Hfr. public TopoStl3HfrFlatDisplayee(TopoStl3Hfr source) Parameters source TopoStl3Hfr The source topological STL. Properties Source The source topological STL. public TopoStl3Hfr Source { get; } Property Value TopoStl3Hfr Methods ClearCache() Invalidates all cached drawings. Call this after modifying the source topology. public void ClearCache() Display(Bind) Displays the flat-shaded topological STL: all edges in black + flat-shaded triangle faces. public void Display(Bind bind) Parameters bind Bind Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box"
  },
  "api/Hi.Geom.Topo.TopoStl3HfrSmoothDisplayee.html": {
    "href": "api/Hi.Geom.Topo.TopoStl3HfrSmoothDisplayee.html",
    "title": "Class TopoStl3HfrSmoothDisplayee | HiAPI-C# 2025",
    "summary": "Class TopoStl3HfrSmoothDisplayee Namespace Hi.Geom.Topo Assembly HiDisp.dll Smooth-shaded displayee for TopoStl3Hfr. Renders smooth faces (per-vertex averaged normals) and sharp edges only. All rendering-related cached data (adjacent cos², smooth normals) is stored in this class via dictionaries, keeping the source TopoStl3Hfr clean. Corresponds to C++ topo_stl3::_smoothDraw + _edgeDraw. public class TopoStl3HfrSmoothDisplayee : IDisplayee, IExpandToBox3d, IDisposable Inheritance object TopoStl3HfrSmoothDisplayee Implements IDisplayee IExpandToBox3d IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors TopoStl3HfrSmoothDisplayee(TopoStl3Hfr, double) Initializes a new smooth displayee wrapping the given TopoStl3Hfr. public TopoStl3HfrSmoothDisplayee(TopoStl3Hfr source, double roundCos = 0.8) Parameters source TopoStl3Hfr The source topological STL. roundCos double Round cosine threshold (default 0.8). Fields DefaultRoundCos Default round cosine threshold for smooth/sharp edge classification. public const double DefaultRoundCos = 0.8 Field Value double DefaultRoundCosSquare Default round cosine squared threshold. public const double DefaultRoundCosSquare = 0.6400000000000001 Field Value double Properties RoundCos Gets or sets the round cosine threshold for smooth/sharp edge classification. Edges where the cos² of adjacent triangle normals exceeds this² are considered “round” (smooth). Setting this value invalidates the cached drawings. Corresponds to C++ _round_cos. public double RoundCos { get; set; } Property Value double Source The source topological STL. public TopoStl3Hfr Source { get; } Property Value TopoStl3Hfr Methods ClearCache() Invalidates all cached data (dictionaries and drawings). Call this after modifying the source topology or changing RoundCos. public void ClearCache() Display(Bind) Displays the smooth-shaded topological STL: sharp edges in black + smooth-shaded faces. Corresponds to C++ topo_stl3::Render. public void Display(Bind bind) Parameters bind Bind Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box"
  },
  "api/Hi.Geom.Topo.TopoTri3Hfr.html": {
    "href": "api/Hi.Geom.Topo.TopoTri3Hfr.html",
    "title": "Class TopoTri3Hfr | HiAPI-C# 2025",
    "summary": "Class TopoTri3Hfr Namespace Hi.Geom.Topo Assembly HiDisp.dll Topological 3D triangle with Fraction<decimal> coordinates. Maintains connectivity to points and lines. Corresponds to C++ topo_tri3wfr_t. public class TopoTri3Hfr Inheritance object TopoTri3Hfr Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Lines Three directed edges. The index is aligned to the begin point: lines[0] = {P0=ps[0], P1=ps[1]}, lines[1] = {P0=ps[1], P1=ps[2]}, lines[2] = {P0=ps[2], P1=ps[0]}. public readonly TopoLine3Hfr[] Lines Field Value TopoLine3Hfr[] Ps Three apex points. ps[i] == lines[i].P0. public readonly TopoPoint3Hfr[] Ps Field Value TopoPoint3Hfr[] Properties CachedCross Gets or sets the cached cross product. Setting this is useful when the cross is computed externally (e.g. during construction). public Vec3Hfr? CachedCross { get; set; } Property Value Vec3Hfr? Methods ApexAtc(int) Gets the apex at the specified index. public Vec3Hfr ApexAtc(int index) Parameters index int Returns Vec3Hfr ClearCache() Clears all cached values. public void ClearCache() GetCross() Gets the cross product vector from line edges: lines[2].arrow x lines[0].arrow. Cached after first computation. Corresponds to C++ get_cross. public Vec3Hfr GetCross() Returns Vec3Hfr GetCrossByTls(TopoLine3Hfr, TopoLine3Hfr) Computes cross from line arrows: lines[2].arrow x lines[0].arrow. public static Vec3Hfr GetCrossByTls(TopoLine3Hfr tl0, TopoLine3Hfr tl2) Parameters tl0 TopoLine3Hfr tl2 TopoLine3Hfr Returns Vec3Hfr GetIntegerNormal() Gets the integer normal vector (cross scaled to integer-like fraction). Corresponds to C++ get_integer_normal. public Vec3Hfr GetIntegerNormal() Returns Vec3Hfr GetNormal() Gets the normalized (unit length) normal vector in double precision. Cached after first computation. Corresponds to C++ get_normal. public Vec3d GetNormal() Returns Vec3d ResetCross() Recomputes the cached cross product. public void ResetCross() ResetIntegerNormal() Recomputes the cached integer normal. Also recomputes the cross. public void ResetIntegerNormal() Exceptions InvalidOperationException The triangle is degenerate (zero area), so its cross is the zero vector and has no direction. ResetNormal() Recomputes the cached normal. Also recomputes the integer normal and cross. public void ResetNormal() ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. ToTri3d() Converts to a Tri3d (double precision). public Tri3d ToTri3d() Returns Tri3d"
  },
  "api/Hi.Geom.Topo.TopoTri3StockHfr.html": {
    "href": "api/Hi.Geom.Topo.TopoTri3StockHfr.html",
    "title": "Class TopoTri3StockHfr | HiAPI-C# 2025",
    "summary": "Class TopoTri3StockHfr Namespace Hi.Geom.Topo Assembly HiDisp.dll Stock (pool) of topological triangles. Corresponds to C++ topo_tri3wfr_stock_t. public class TopoTri3StockHfr Inheritance object TopoTri3StockHfr Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors TopoTri3StockHfr(int) Initializes a new triangle stock with the specified capacity. public TopoTri3StockHfr(int capacity) Parameters capacity int Properties Count Gets the number of triangles. public int Count { get; } Property Value int Tris Gets all triangles in the stock. public IReadOnlyCollection<TopoTri3Hfr> Tris { get; } Property Value IReadOnlyCollection<TopoTri3Hfr> Methods Del(TopoTri3Hfr) Removes a triangle from the stock and cleans up connectivity. Thread-safe. public void Del(TopoTri3Hfr src) Parameters src TopoTri3Hfr Gen(TopoLine3Hfr, TopoLine3Hfr, TopoLine3Hfr) Creates a new triangle from three directed edges and adds it to the stock. Thread-safe. public TopoTri3Hfr Gen(TopoLine3Hfr tl0, TopoLine3Hfr tl1, TopoLine3Hfr tl2) Parameters tl0 TopoLine3Hfr tl1 TopoLine3Hfr tl2 TopoLine3Hfr Returns TopoTri3Hfr Gen(TopoPoint3Hfr, TopoPoint3Hfr, TopoPoint3Hfr, TopoLine3StockHfr) Creates a new triangle from three points (automatically creating lines via the stock). Thread-safe. public TopoTri3Hfr Gen(TopoPoint3Hfr tp0, TopoPoint3Hfr tp1, TopoPoint3Hfr tp2, TopoLine3StockHfr lineStock) Parameters tp0 TopoPoint3Hfr tp1 TopoPoint3Hfr tp2 TopoPoint3Hfr lineStock TopoLine3StockHfr Returns TopoTri3Hfr"
  },
  "api/Hi.Geom.Topo.Vec3Hfr.html": {
    "href": "api/Hi.Geom.Topo.Vec3Hfr.html",
    "title": "Struct Vec3Hfr | HiAPI-C# 2025",
    "summary": "Struct Vec3Hfr Namespace Hi.Geom.Topo Assembly HiDisp.dll 3D vector with Fraction<decimal> elements. Provides unlimited-precision exact arithmetic for geometric computations. Corresponds to C++ vec3<wfr_t>. public struct Vec3Hfr : IEquatable<Vec3Hfr> Implements IEquatable<Vec3Hfr> Inherited Members object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Vec3Hfr(Fraction<decimal>, Fraction<decimal>, Fraction<decimal>) Initializes a new Vec3Hfr with three fraction components. public Vec3Hfr(Fraction<decimal> x, Fraction<decimal> y, Fraction<decimal> z) Parameters x Fraction<decimal> y Fraction<decimal> z Fraction<decimal> Vec3Hfr(Vec3d, decimal) Initializes a new Vec3Hfr from a Vec3d with the specified resolution. Converts each double component to a fraction via Stern-Brocot approximation. public Vec3Hfr(Vec3d src, decimal resolution) Parameters src Vec3d Source double-precision vector. resolution decimal Fraction approximation tolerance. Fields X X component. public Fraction<decimal> X Field Value Fraction<decimal> Y Y component. public Fraction<decimal> Y Field Value Fraction<decimal> Z Z component. public Fraction<decimal> Z Field Value Fraction<decimal> Methods Dot(Vec3Hfr) Dot product. public readonly Fraction<decimal> Dot(Vec3Hfr b) Parameters b Vec3Hfr Returns Fraction<decimal> Equals(Vec3Hfr) Indicates whether the current object is equal to another object of the same type. public readonly bool Equals(Vec3Hfr other) Parameters other Vec3Hfr An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Indicates whether this instance and a specified object are equal. public override readonly bool Equals(object obj) Parameters obj object The object to compare with the current instance. Returns bool true if obj and this instance are the same type and represent the same value; otherwise, false. Evaluate() Evaluates all components. public Vec3Hfr Evaluate() Returns Vec3Hfr GetCross(Vec3Hfr) Cross product: this x b. Corresponds to C++ get_cross. public readonly Vec3Hfr GetCross(Vec3Hfr b) Parameters b Vec3Hfr Returns Vec3Hfr GetHashCode() Returns the hash code for this instance. public override readonly int GetHashCode() Returns int A 32-bit signed integer that is the hash code for this instance. Pack() Packs (reduces) all components to irreducible form. public Vec3Hfr Pack() Returns Vec3Hfr ToString() Returns the fully qualified type name of this instance. public override readonly string ToString() Returns string The fully qualified type name. ToVec3d() Converts to a Vec3d by evaluating each fraction component. public readonly Vec3d ToVec3d() Returns Vec3d Operators operator +(Vec3Hfr, Vec3Hfr) Addition. public static Vec3Hfr operator +(Vec3Hfr a, Vec3Hfr b) Parameters a Vec3Hfr b Vec3Hfr Returns Vec3Hfr operator ==(Vec3Hfr, Vec3Hfr) Equality operator. public static bool operator ==(Vec3Hfr a, Vec3Hfr b) Parameters a Vec3Hfr b Vec3Hfr Returns bool operator !=(Vec3Hfr, Vec3Hfr) Inequality operator. public static bool operator !=(Vec3Hfr a, Vec3Hfr b) Parameters a Vec3Hfr b Vec3Hfr Returns bool operator *(Fraction<decimal>, Vec3Hfr) Scalar multiplication. public static Vec3Hfr operator *(Fraction<decimal> s, Vec3Hfr a) Parameters s Fraction<decimal> a Vec3Hfr Returns Vec3Hfr operator *(Vec3Hfr, Fraction<decimal>) Scalar multiplication. public static Vec3Hfr operator *(Vec3Hfr a, Fraction<decimal> s) Parameters a Vec3Hfr s Fraction<decimal> Returns Vec3Hfr operator -(Vec3Hfr, Vec3Hfr) Subtraction. public static Vec3Hfr operator -(Vec3Hfr a, Vec3Hfr b) Parameters a Vec3Hfr b Vec3Hfr Returns Vec3Hfr operator -(Vec3Hfr) Negation. public static Vec3Hfr operator -(Vec3Hfr a) Parameters a Vec3Hfr Returns Vec3Hfr"
  },
  "api/Hi.Geom.Topo.html": {
    "href": "api/Hi.Geom.Topo.html",
    "title": "Namespace Hi.Geom.Topo | HiAPI-C# 2025",
    "summary": "Namespace Hi.Geom.Topo Classes CarveBooleanResult Result of one carve boolean step. On failure the workpiece is untouched and the step may simply be skipped. CarveStl A triangle mesh that can be carved: an exact-fraction topology graph with an incrementally maintained spatial index, mutated in place by exact boolean steps (SubstractVolume(Stl, double) / AddVolume(Stl, double)). Unlike NativeTopoStl3wfr (build-once sweeping input), this object is long-lived and accumulates cut geometry step after step; sharp edges and exact planar faces survive the booleans exactly. Not thread-safe. NativeTopoStl3d Native TopoStl with element type double. NativeTopoStl3wfr Native TopoStl with element type fraction. TopoLine3Hfr Topological 3D line (directed edge) with Fraction<decimal> coordinates. Maintains connectivity to adjacent reversed line and owning triangle. Corresponds to C++ topo_line3wfr_t. TopoLine3StockHfr Stock (pool) of topological lines with deduplication based on endpoint identity. Corresponds to C++ topo_line3wfr_stock_t. TopoPoint3Hfr Topological 3D point with Fraction<decimal> coordinates. Maintains connectivity to adjacent lines and triangles. Corresponds to C++ topo_point3wfr_t. TopoPoint3StockHfr Stock (pool) of topological points with deduplication based on fraction coordinates. Corresponds to C++ topo_point3wfr_stock_t. TopoStl3Hfr Pure C# topological STL (triangle mesh) with Fraction<decimal> coordinates. Hfr: High-Precision (decimal) FRaction. Provides unlimited-precision exact arithmetic for geometric computations without relying on native (C++) interop. Corresponds to C++ topo_stl3wfr_t. TopoStl3HfrFlatDisplayee Flat-shaded displayee for TopoStl3Hfr. Renders flat triangle faces (one normal per triangle) and all unique edge lines. Corresponds to C++ topo_stl3::_flatDraw + all-lines draw. TopoStl3HfrSmoothDisplayee Smooth-shaded displayee for TopoStl3Hfr. Renders smooth faces (per-vertex averaged normals) and sharp edges only. All rendering-related cached data (adjacent cos², smooth normals) is stored in this class via dictionaries, keeping the source TopoStl3Hfr clean. Corresponds to C++ topo_stl3::_smoothDraw + _edgeDraw. TopoTri3Hfr Topological 3D triangle with Fraction<decimal> coordinates. Maintains connectivity to points and lines. Corresponds to C++ topo_tri3wfr_t. TopoTri3StockHfr Stock (pool) of topological triangles. Corresponds to C++ topo_tri3wfr_stock_t. Structs Vec3Hfr 3D vector with Fraction<decimal> elements. Provides unlimited-precision exact arithmetic for geometric computations. Corresponds to C++ vec3<wfr_t>. Enums CarveBooleanKind What a carve boolean did to the workpiece container."
  },
  "api/Hi.Geom.TransformationGeom.html": {
    "href": "api/Hi.Geom.TransformationGeom.html",
    "title": "Class TransformationGeom | HiAPI-C# 2025",
    "summary": "Class TransformationGeom Namespace Hi.Geom Assembly HiMech.dll Represents a geometric transformation that can be applied to a geometry object. This class combines a transformer with a target geometry to produce transformed geometric results. public class TransformationGeom : IStlSource, IGetStl, IMakeXmlSource, IGeomProperty, IGenStl, IExpandToBox3d, IDuplicate Inheritance object TransformationGeom Implements IStlSource IGetStl IMakeXmlSource IGeomProperty IGenStl IExpandToBox3d IDuplicate Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods StlUtil.ToFaceDrawing(IGetStl) StlUtil.ToLineDrawing(IGetStl) StlUtil.ToSparkleLineDrawing(IGetStl) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks The TransformationGeom class provides functionality to: Apply geometric transformations to STL geometry Support XML serialization and deserialization Handle duplication of transformation configurations Manage transformation matrices and their application to geometry Constructors TransformationGeom() Initializes a new instance of the TransformationGeom class with default values. public TransformationGeom() TransformationGeom(IGetStl) Initializes a new instance of the TransformationGeom class with a specified geometry. public TransformationGeom(IGetStl geom) Parameters geom IGetStl The geometry object to be transformed. TransformationGeom(XElement, string, IProgress<IMessage>) Initializes a new instance of the TransformationGeom class from XML data. public TransformationGeom(XElement src, string baseDirectory, IProgress<IMessage> progress) Parameters src XElement The XML element containing the transformation data. baseDirectory string The base directory for resolving relative paths. progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. Remarks This constructor deserializes both the transformer and geometry data from the provided XML. If either element is missing or invalid, the corresponding property will be null. Properties Geom Gets or sets the target geometry that will be transformed. public IGetStl Geom { get; set; } Property Value IGetStl Remarks This property represents the base geometry object that will have the transformation applied to it. If null, operations involving this geometry will return null results. Transformer Gets or sets the transformer that defines the geometric transformation. The transformation is applied from left (first element) to right (last element), with the target geometry being on the left side. public ITransformer Transformer { get; set; } Property Value ITransformer Remarks The transformer can be null, in which case no transformation is applied to the geometry. XName Gets the XML element name used for serialization. public static string XName { get; } Property Value string The string “TransformationGeom”. Methods Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object Remarks The duplication process creates new instances of both the transformer and geometry objects if they implement the appropriate cloning interfaces. ExpandToBox3d(Box3d) Expands the given box to include the bounds of the transformed geometry. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d The box to expand. Remarks A rough, quick operation (view fitting): the geometry's own box is transformed corner-wise — a conservative superset of the transformed geometry's true bounds. Bounds queries never generate a mesh, so a geometry without IExpandToBox3d support contributes nothing. GenStl(IPolarResolution2d) Generates a new STL. public Stl GenStl(IPolarResolution2d resolution) Parameters resolution IPolarResolution2d Polar resolution Returns Stl A newly created STL. GetStl() Gets the transformed STL representation of the geometry. public Stl GetStl() Returns Stl The transformed STL if both geometry and transformer are valid; the original STL if transformer is null; null if geometry is null or produces null STL. Remarks If the transformer is null, the method returns the untransformed geometry. If the geometry is null or produces a null STL, the method returns null. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Geom.Tri3d.html": {
    "href": "api/Hi.Geom.Tri3d.html",
    "title": "Class Tri3d | HiAPI-C# 2025",
    "summary": "Class Tri3d Namespace Hi.Geom Assembly HiGeom.dll Basic 3D Triangle. public class Tri3d : ITri3d, IFlat3d, IExpandToBox3d, IEquatable<Tri3d>, IBinaryIo, IWriteBin Inheritance object Tri3d Implements ITri3d IFlat3d IExpandToBox3d IEquatable<Tri3d> IBinaryIo IWriteBin Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods BinIoUtil.ToBytes(IWriteBin) GeomUtil.ExpandToBox3d(IExpandToBox3d, Mat4d, Box3d) GeomUtil.GetBox3d(IExpandToBox3d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Tri3d(ITri3d) Creates a triangle from an ITri3d interface public Tri3d(ITri3d t) Parameters t ITri3d The source triangle implementing ITri3d Tri3d(ITri3d, Mat4d) Creates a triangle from an ITri3d interface and transforms it using a matrix public Tri3d(ITri3d t, Mat4d mat) Parameters t ITri3d The source triangle implementing ITri3d mat Mat4d The transformation matrix to apply Tri3d(Tri3d, bool) Creates a triangle by copying or referencing another triangle public Tri3d(Tri3d t, bool useRef = false) Parameters t Tri3d The source triangle useRef bool If true, references to the source triangle's vertices and normal are used; otherwise, copies are created Tri3d(Vec3d, Vec3d, Vec3d) Ctor. public Tri3d(Vec3d p0, Vec3d p1, Vec3d p2) Parameters p0 Vec3d apex0 p1 Vec3d apex1 p2 Vec3d apex2 Tri3d(Vec3d, Vec3d, Vec3d, Vec3d) Creates a triangle with the specified vertices and normal vector public Tri3d(Vec3d p0, Vec3d p1, Vec3d p2, Vec3d n) Parameters p0 Vec3d First vertex p1 Vec3d Second vertex p2 Vec3d Third vertex n Vec3d Normal vector Tri3d(tri3d) Ctor. public Tri3d(tri3d src) Parameters src tri3d src Tri3d(bool) Ctor. public Tri3d(bool initAllMemberToNull = false) Parameters initAllMemberToNull bool If true, the three apexes and normal are null; otherwise, they are initialized by the default constructor of Vec3d. Tri3d(BinaryReader) Creates a triangle by reading its data from a binary reader public Tri3d(BinaryReader reader) Parameters reader BinaryReader The binary reader to read from Fields n normal vector of this triangle. public Vec3d n Field Value Vec3d ps Points. Three apexs. public Vec3d[] ps Field Value Vec3d[] Properties Area Gets the area of the triangle public double Area { get; } Property Value double NativeByteSize Native byte size. public static int NativeByteSize { get; } Property Value int Methods Equals(Tri3d) Indicates whether the current object is equal to another object of the same type. public bool Equals(Tri3d other) Parameters other Tri3d An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetApex(int) Gets the specified vertex (apex) of this triangle. public Vec3d GetApex(int i) Parameters i int Index of the vertex (0-2) Returns Vec3d The position of the specified vertex GetDistanceToOrigin() Signed Distance To Origin. public double GetDistanceToOrigin() Returns double Signed Distance To Origin. GetEdgeArrow(int) Gets the edge vector from vertex i to vertex i+1. public Vec3d GetEdgeArrow(int i) Parameters i int The index of the starting vertex (0, 1, or 2). Returns Vec3d The vector representing the edge. GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. GetLocate() Gets an anchor point on this flat surface. public Vec3d GetLocate() Returns Vec3d A point on the flat surface GetNormal() Gets the normal vector of the flat surface. public Vec3d GetNormal() Returns Vec3d The unit normal vector GetRewind() Creates a new triangle with reversed vertex order and flipped normal public Tri3d GetRewind() Returns Tri3d A new triangle with reversed vertex order GetSegmentsFromPlaneClip(IFlat3d) Gets the line segments resulting from intersecting this triangle with a clipping plane. public IEnumerable<Segment3d> GetSegmentsFromPlaneClip(IFlat3d clipPlane) Parameters clipPlane IFlat3d The clipping plane Returns IEnumerable<Segment3d> An enumerable of line segments representing the intersection GetTransform(Mat4d) Creates a new triangle by transforming this triangle using the specified matrix. public Tri3d GetTransform(Mat4d mat) Parameters mat Mat4d The transformation matrix. Returns Tri3d A new transformed triangle. GetTranslate(Vec3d) Creates a new triangle by translating this triangle by the specified vector. public Tri3d GetTranslate(Vec3d v) Parameters v Vec3d The translation vector. Returns Tri3d A new translated triangle. GetTriSplition(double[], out Tri3d[], out Tri3d[]) Get triangles splition by pointWeights interpolation. negativeTris or positiveTris are null if no triangles generated. If all pointWeights is 0, no triangle generated. public void GetTriSplition(double[] pointWeights, out Tri3d[] positiveTris, out Tri3d[] negativeTris) Parameters pointWeights double[] weights of points positiveTris Tri3d[] triangles with positive or zero weight negativeTris Tri3d[] triangles with negative or zero weight ReBuildNormal() Rebuilds the normal vector of the triangle based on its vertices. public Vec3d ReBuildNormal() Returns Vec3d The rebuilt normal vector. ReadBin(BinaryReader) Reads binary data to initialize the object. public void ReadBin(BinaryReader reader) Parameters reader BinaryReader The binary reader to read from Rewind() Reverses the order of the triangle's vertices, which flips the normal direction public void Rewind() Rotate(Vec3d, double) Rotates the triangle around the specified axis by the given angle. public Tri3d Rotate(Vec3d axis, double rad) Parameters axis Vec3d The axis of rotation. rad double The angle of rotation in radians. Returns Tri3d This triangle after rotation. Set(ITri3d) Sets this triangle's vertices and normal from an ITri3d interface public Tri3d Set(ITri3d t) Parameters t ITri3d The source triangle implementing ITri3d Returns Tri3d This triangle instance Set(ITri3d, Mat4d) Sets this triangle's vertices and normal from an ITri3d interface and transforms them using a matrix public Tri3d Set(ITri3d t, Mat4d mat) Parameters t ITri3d The source triangle implementing ITri3d mat Mat4d The transformation matrix to apply Returns Tri3d This triangle instance Set(Tri3d, bool) Sets this triangle's vertices and normal from another triangle public Tri3d Set(Tri3d t, bool useRef = false) Parameters t Tri3d The source triangle useRef bool If true, references to the source triangle's vertices and normal are used; otherwise, copies are created Returns Tri3d This triangle instance Set(Vec3d, Vec3d, Vec3d) Set value. public Tri3d Set(Vec3d p0, Vec3d p1, Vec3d p2) Parameters p0 Vec3d apex0 p1 Vec3d apex1 p2 Vec3d apex2 Returns Tri3d this Set(Vec3d, Vec3d, Vec3d, Vec3d) Sets the triangle's vertices and normal vector public Tri3d Set(Vec3d p0, Vec3d p1, Vec3d p2, Vec3d n) Parameters p0 Vec3d First vertex p1 Vec3d Second vertex p2 Vec3d Third vertex n Vec3d Normal vector Returns Tri3d This triangle instance SetOrderForward(int) Reorders the triangle's vertices to make the specified vertex the first one public void SetOrderForward(int index) Parameters index int The index of the vertex to make first (0, 1, or 2) ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. Transform(Mat4d) Transforms the triangle using the specified transformation matrix. public Tri3d Transform(Mat4d mat) Parameters mat Mat4d The transformation matrix. Returns Tri3d This triangle after transformation. Translate(Vec3d) Translates the triangle by the specified vector. public Tri3d Translate(Vec3d v) Parameters v Vec3d The translation vector. Returns Tri3d This triangle after translation. Translate(double, double, double) Translates the triangle by the specified x, y, and z coordinates. public Tri3d Translate(double x, double y, double z) Parameters x double The x-coordinate of the translation. y double The y-coordinate of the translation. z double The z-coordinate of the translation. Returns Tri3d This triangle after translation. WriteBin(BinaryWriter) Writes the object's data to a binary stream. public void WriteBin(BinaryWriter writer) Parameters writer BinaryWriter The binary writer to write to"
  },
  "api/Hi.Geom.Tri3dUtil.html": {
    "href": "api/Hi.Geom.Tri3dUtil.html",
    "title": "Class Tri3dUtil | HiAPI-C# 2025",
    "summary": "Class Tri3dUtil Namespace Hi.Geom Assembly HiGeom.dll Utility of Tri3d. Include generator of triangles from points. public static class Tri3dUtil Inheritance object Tri3dUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GenTrisByAlignedLists(IList<Vec3d>, IList<Vec3d>, IList<Tri3d>) public static void GenTrisByAlignedLists(IList<Vec3d> ps, IList<Vec3d> rrps, IList<Tri3d> dst) Parameters ps IList<Vec3d> rrps IList<Vec3d> dst IList<Tri3d> GenTrisByAlignedLoops(IList<Vec3d>, IList<Vec3d>, IList<Tri3d>) Generates triangles between two aligned loops of points. public static void GenTrisByAlignedLoops(IList<Vec3d> ps, IList<Vec3d> rrps, IList<Tri3d> dst) Parameters ps IList<Vec3d> First loop of points rrps IList<Vec3d> Second loop of points dst IList<Tri3d> The collection to add the generated triangles to GenTrisByFan(IEnumerable<Vec3d>, Vec3d) Generates triangles in a fan pattern from a sequence of points. public static IEnumerable<Tri3d> GenTrisByFan(this IEnumerable<Vec3d> ps, Vec3d faceNormal = null) Parameters ps IEnumerable<Vec3d> The sequence of points faceNormal Vec3d Optional face normal for the triangles Returns IEnumerable<Tri3d> An enumerable of triangles forming a fan GenTrisByNumAlignment(List<Vec3d>, List<Vec3d>, IList<Tri3d>) Generates triangles between two lists of points with different numbers of points. public static void GenTrisByNumAlignment(List<Vec3d> psA, List<Vec3d> psB, IList<Tri3d> dst) Parameters psA List<Vec3d> First list of points psB List<Vec3d> Second list of points dst IList<Tri3d> The collection to add the generated triangles to GenTrisByQuad(Vec3d, Vec3d, Vec3d, Vec3d, IList<Tri3d>) Generates two triangles from a quadrilateral defined by four points. public static void GenTrisByQuad(Vec3d p0, Vec3d p1, Vec3d p2, Vec3d p3, IList<Tri3d> dst) Parameters p0 Vec3d First point of the quadrilateral p1 Vec3d Second point of the quadrilateral p2 Vec3d Third point of the quadrilateral p3 Vec3d Fourth point of the quadrilateral dst IList<Tri3d> The collection to add the generated triangles to GenTrisByStar(Vec3d, IList<Vec3d>, IList<Tri3d>) Generates triangles in a star pattern from a center point to a list of points. public static void GenTrisByStar(Vec3d starP, IList<Vec3d> ps, IList<Tri3d> dst) Parameters starP Vec3d The center point of the star ps IList<Vec3d> The list of points forming the perimeter dst IList<Tri3d> The collection to add the generated triangles to GenTrisByStar(IList<Vec3d>, Vec3d, IList<Tri3d>) Generates triangles in a star pattern from a list of points to a center point. public static void GenTrisByStar(IList<Vec3d> ps, Vec3d starP, IList<Tri3d> dst) Parameters ps IList<Vec3d> The list of points forming the perimeter starP Vec3d The center point of the star dst IList<Tri3d> The collection to add the generated triangles to GetSegmentsFromPlaneClip(IEnumerable<Tri3d>, IFlat3d) Gets line segments resulting from intersecting triangles with a clipping plane. public static List<Segment3d> GetSegmentsFromPlaneClip(this IEnumerable<Tri3d> tris, IFlat3d clipPlane) Parameters tris IEnumerable<Tri3d> The collection of triangles to clip clipPlane IFlat3d The clipping plane Returns List<Segment3d> A list of line segments representing the intersection"
  },
  "api/Hi.Geom.UnitUtils.PhysicsUnit.html": {
    "href": "api/Hi.Geom.UnitUtils.PhysicsUnit.html",
    "title": "Enum PhysicsUnit | HiAPI-C# 2025",
    "summary": "Enum PhysicsUnit Namespace Hi.Geom.UnitUtils Assembly HiMech.dll Represents physical units used in the system. [Flags] public enum PhysicsUnit Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) UnitConvertUtil.ToUnitString(PhysicsUnit) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields [StringValue(\"<sup>o</sup>C\")] C = mm3 | kJ Represents degrees Celsius (temperature measurement). [StringValue(\"J\")] J = deg | MPa Represents Joules (energy measurement). [StringValue(\"<sup>o</sup>K\")] K = deg | C Represents Kelvin (temperature measurement). [StringValue(\"MPa\")] MPa = sec | N Represents Megapascals (pressure measurement). [StringValue(\"N\")] N = mm3 | rpm Represents Newtons (force measurement). [StringValue(\"Nm\")] Nm = deg | N Represents Newton-meters (torque measurement). [StringValue(null)] None = 0 Represents no unit. [StringValue(\"deg\")] deg = 1 Represents degrees (angular measurement). [StringValue(\"g\")] g = sec | rpm Represents grams (mass measurement). [StringValue(\"kJ\")] kJ = 16 Represents kilojoules (energy measurement). [StringValue(\"kW\")] kW = deg | watt Represents kilowatts (power measurement). [StringValue(\"kWh\")] kWh = deg | kJ Represents kilowatt-hours (energy measurement). [StringValue(\"mg\")] mg = deg | g Represents milligrams (mass measurement). [StringValue(\"mm\")] mm = deg | sec Represents millimeters (length measurement). [StringValue(\"mm<sup>3</sup>\")] mm3 = 4 Represents cubic millimeters (volume measurement). [StringValue(\"mm<sup>3</sup>/s\")] mm3ds = deg | rpm Represents cubic millimeters per second (volume flow rate measurement). [StringValue(\"mm/min\")] mmdmin = deg | mmds Represents millimeters per minute (feed rate measurement). [StringValue(\"mm/s\")] mmds = sec | mm3 Represents millimeters per second (velocity measurement). [StringValue(\"rpm\")] rpm = 8 Represents revolutions per minute (rotational speed measurement). [StringValue(\"sec\")] sec = 2 Represents seconds (time measurement). [StringValue(\"um\")] um = deg | mm3 Represents micrometers (length measurement). [StringValue(\"watt\")] watt = sec | kJ Represents watts (power measurement)."
  },
  "api/Hi.Geom.UnitUtils.StringValueAttribute.html": {
    "href": "api/Hi.Geom.UnitUtils.StringValueAttribute.html",
    "title": "Class StringValueAttribute | HiAPI-C# 2025",
    "summary": "Class StringValueAttribute Namespace Hi.Geom.UnitUtils Assembly HiMech.dll Attribute for associating a string value with an enum value or other element. public class StringValueAttribute : Attribute Inheritance object Attribute StringValueAttribute Inherited Members Attribute.Equals(object) Attribute.GetCustomAttribute(Assembly, Type) Attribute.GetCustomAttribute(Assembly, Type, bool) Attribute.GetCustomAttribute(MemberInfo, Type) Attribute.GetCustomAttribute(MemberInfo, Type, bool) Attribute.GetCustomAttribute(Module, Type) Attribute.GetCustomAttribute(Module, Type, bool) Attribute.GetCustomAttribute(ParameterInfo, Type) Attribute.GetCustomAttribute(ParameterInfo, Type, bool) Attribute.GetCustomAttributes(Assembly) Attribute.GetCustomAttributes(Assembly, bool) Attribute.GetCustomAttributes(Assembly, Type) Attribute.GetCustomAttributes(Assembly, Type, bool) Attribute.GetCustomAttributes(MemberInfo) Attribute.GetCustomAttributes(MemberInfo, bool) Attribute.GetCustomAttributes(MemberInfo, Type) Attribute.GetCustomAttributes(MemberInfo, Type, bool) Attribute.GetCustomAttributes(Module) Attribute.GetCustomAttributes(Module, bool) Attribute.GetCustomAttributes(Module, Type) Attribute.GetCustomAttributes(Module, Type, bool) Attribute.GetCustomAttributes(ParameterInfo) Attribute.GetCustomAttributes(ParameterInfo, bool) Attribute.GetCustomAttributes(ParameterInfo, Type) Attribute.GetCustomAttributes(ParameterInfo, Type, bool) Attribute.GetHashCode() Attribute.IsDefaultAttribute() Attribute.IsDefined(Assembly, Type) Attribute.IsDefined(Assembly, Type, bool) Attribute.IsDefined(MemberInfo, Type) Attribute.IsDefined(MemberInfo, Type, bool) Attribute.IsDefined(Module, Type) Attribute.IsDefined(Module, Type, bool) Attribute.IsDefined(ParameterInfo, Type) Attribute.IsDefined(ParameterInfo, Type, bool) Attribute.Match(object) Attribute.TypeId object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors StringValueAttribute(string) Initializes a new instance of the StringValueAttribute class with the specified value. public StringValueAttribute(string value) Parameters value string The string value to associate with the element. Properties Value Gets or sets the string value associated with the element. public string Value { get; set; } Property Value string"
  },
  "api/Hi.Geom.UnitUtils.UnitConvertUtil.html": {
    "href": "api/Hi.Geom.UnitUtils.UnitConvertUtil.html",
    "title": "Class UnitConvertUtil | HiAPI-C# 2025",
    "summary": "Class UnitConvertUtil Namespace Hi.Geom.UnitUtils Assembly HiMech.dll Provides utility methods for converting between different physical units and their string representations. public static class UnitConvertUtil Inheritance object UnitConvertUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods ToUnitString(PhysicsUnit) Converts a PhysicsUnit enum value to its string representation. public static string ToUnitString(this PhysicsUnit src) Parameters src PhysicsUnit The PhysicsUnit value to convert. Returns string The string representation of the unit, or the enum value's name if no string value is defined."
  },
  "api/Hi.Geom.UnitUtils.html": {
    "href": "api/Hi.Geom.UnitUtils.html",
    "title": "Namespace Hi.Geom.UnitUtils | HiAPI-C# 2025",
    "summary": "Namespace Hi.Geom.UnitUtils Classes StringValueAttribute Attribute for associating a string value with an enum value or other element. UnitConvertUtil Provides utility methods for converting between different physical units and their string representations. Enums PhysicsUnit Represents physical units used in the system."
  },
  "api/Hi.Geom.Vec2d.html": {
    "href": "api/Hi.Geom.Vec2d.html",
    "title": "Class Vec2d | HiAPI-C# 2025",
    "summary": "Class Vec2d Namespace Hi.Geom Assembly HiGeom.dll Basic 2D point (or vector). public class Vec2d : IExpandToBox2d, IEquatable<Vec2d>, ICsvRowIo, IEqualityOperators<Vec2d, Vec2d, bool>, IAdditionOperators<Vec2d, Vec2d, Vec2d>, ISubtractionOperators<Vec2d, Vec2d, Vec2d>, IMultiplyOperators<Vec2d, double, Vec2d>, IDivisionOperators<Vec2d, double, Vec2d>, IVec<double>, IFormattable Inheritance object Vec2d Implements IExpandToBox2d IEquatable<Vec2d> ICsvRowIo IEqualityOperators<Vec2d, Vec2d, bool> IAdditionOperators<Vec2d, Vec2d, Vec2d> ISubtractionOperators<Vec2d, Vec2d, Vec2d> IMultiplyOperators<Vec2d, double, Vec2d> IDivisionOperators<Vec2d, double, Vec2d> IVec<double> IFormattable Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Vec2d() Default constructor. Creates a vector with coordinates (0,0). public Vec2d() Vec2d(Vec2d) Copy ctor. public Vec2d(Vec2d src) Parameters src Vec2d src Vec2d(Vec2i) Creates a vector from Vec2i by converting integer coordinates to double. public Vec2d(Vec2i src) Parameters src Vec2i Source Vec2i vector with integer coordinates Vec2d(vec2d) ctor. public Vec2d(vec2d src) Parameters src vec2d src Vec2d(double, double) Ctor. public Vec2d(double x, double y) Parameters x double x y double y Vec2d(Func<int, double>) Ctor using a function that maps direction index to value. public Vec2d(Func<int, double> dirToValueFunc) Parameters dirToValueFunc Func<int, double> Function that maps direction index to value Vec2d(BinaryReader) Ctor by bytes: x = reader.ReadDouble(); y = reader.ReadDouble(); public Vec2d(BinaryReader reader) Parameters reader BinaryReader reader Vec2d(int, double, double) Ctor by direction offset. Direction 0,1 indicate x,y respectively. public Vec2d(int dir, double a, double b) Parameters dir int direction offset a double value at direction (0+dir)%2 b double value at direction (1+dir)%2 Vec2d(string) Ctor by string. The format is (x,y). public Vec2d(string src) Parameters src string src Fields x Value at x direction. public double x Field Value double y Value at y direction. public double y Field Value double Properties AbsSum Sum of abs(x) and abs(y). public double AbsSum { get; } Property Value double AllOne Generate vec (1,1). public static Vec2d AllOne { get; } Property Value Vec2d (1,1) AmpPhase Create AmpPhase instance. public AmpPhase AmpPhase { get; } Property Value AmpPhase Angle_deg Angle in degree between vec(x,y) and vec(1,0). public double Angle_deg { get; } Property Value double Angle_rad Angle in radian between vec(x,y) and vec(1,0). public double Angle_rad { get; } Property Value double CsvText Csv text. public string CsvText { get; set; } Property Value string CsvTitleText Csv titles text. public string CsvTitleText { get; } Property Value string IsAllFinite public bool IsAllFinite { get; } Property Value bool Is x,y,z all finite. IsAllNaN public bool IsAllNaN { get; } Property Value bool is x,y all NaN. IsAllNegativeInfinity public bool IsAllNegativeInfinity { get; } Property Value bool is x,y all NegativeInfinity. IsAllPositiveInfinity public bool IsAllPositiveInfinity { get; } Property Value bool is x,y all PositiveInfinity. IsAnyFinite public bool IsAnyFinite { get; } Property Value bool Is at least one of x,y finite. IsAnyNaN Is any member nan. public bool IsAnyNaN { get; } Property Value bool IsZero public bool IsZero { get; } Property Value bool Is zero vector. Which is x == 0 && y == 0. this[int] Gets or sets the element at the specified index. public double this[int dir] { get; set; } Parameters dir int Property Value double The element at the specified index. Length Length. public double Length { get; } Property Value double LengthSquare Length square. public double LengthSquare { get; } Property Value double MaxAbsDir Get the direction of the max absolute value. public int MaxAbsDir { get; } Property Value int MaxDir Get the direction of the max value. public int MaxDir { get; } Property Value int MaxValue Get max value from {x,y}. public double MaxValue { get; } Property Value double MinDir Get the direction index with minimum value. If {x,y} is the smallest, return {0,1}. public int MinDir { get; } Property Value int MinValue Get min value from {x,y}. public double MinValue { get; } Property Value double NaN Generate NAN vec. public static Vec2d NaN { get; } Property Value Vec2d (nan,nan) NativeByteSize public static int NativeByteSize { get; } Property Value int Byte size: sizeof(double) * 2. NegativeInfinity Generate negative infinity vec. public static Vec2d NegativeInfinity { get; } Property Value Vec2d (-inf,-inf) PositiveInfinity Generate positive infinity vec. public static Vec2d PositiveInfinity { get; } Property Value Vec2d (inf,inf) Rank Dimension (i.e. Size) of the Vector. public int Rank { get; } Property Value int UnitX Generate vec (1,0). public static Vec2d UnitX { get; } Property Value Vec2d (1,0) UnitY Generate vec (0,1). public static Vec2d UnitY { get; } Property Value Vec2d (0,1) X Gets or sets the X coordinate value. public double X { get; set; } Property Value double Y Gets or sets the Y coordinate value. public double Y { get; set; } Property Value double Zero Generate vec (0,0). public static Vec2d Zero { get; } Property Value Vec2d (0,0) Methods All(double) Generate Vec2d with all components set to the given value. public static Vec2d All(double v) Parameters v double Returns Vec2d At(int) Member at direction. public ref double At(int dir) Parameters dir int direction Returns double member Cross(Vec2d) Cross. public double Cross(Vec2d src) Parameters src Vec2d src Returns double cross value Dot(Vec2d) Dot. public double Dot(Vec2d src) Parameters src Vec2d src Returns double dotted value Equals(Vec2d) Indicates whether the current object is equal to another object of the same type. public bool Equals(Vec2d other) Parameters other Vec2d An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(Vec2d, double) check equals for each component with tolerance. public bool Equals(Vec2d other, double toleranceForEachComponent) Parameters other Vec2d other vec toleranceForEachComponent double tolerance for each component Returns bool check equals for each component with tolerance. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. ExpandMax(Vec2d) Find and expand maximum values from src. public void ExpandMax(Vec2d src) Parameters src Vec2d src ExpandMin(Vec2d) Find and expand minimum values from src. public void ExpandMin(Vec2d src) Parameters src Vec2d src ExpandToBox2d(Box2d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox2d(Box2d dst) Parameters dst Box2d Destination box GenNaN() Generate NAN vec. public static Vec2d GenNaN() Returns Vec2d (nan,nan) GenNegativeInfinity() Generate negative infinity vec. public static Vec2d GenNegativeInfinity() Returns Vec2d (-inf,-inf) GenOne() Generate vec (1,1). public static Vec2d GenOne() Returns Vec2d (1,1) GenPositiveInfinity() Generate positive infinity vec. public static Vec2d GenPositiveInfinity() Returns Vec2d (inf,inf) GenUnitX() Generate vec (1,0). public static Vec2d GenUnitX() Returns Vec2d (1,0) GenUnitY() Generate vec (0,1). public static Vec2d GenUnitY() Returns Vec2d (0,1) GenZero() Generate vec (0,0). public static Vec2d GenZero() Returns Vec2d (0,0) GetCosSquareWith(Vec2d) Get Cos(theta)^2. theta is the angle between this and src. This function is faster than GetCosWith(Vec2d) since it lacks one square root operation. public double GetCosSquareWith(Vec2d src) Parameters src Vec2d one of edge vector Returns double Cos(theta)^2 GetCosWith(Vec2d) Get cos(angle). The angle is between v and this. public double GetCosWith(Vec2d v) Parameters v Vec2d v Returns double cos(angle) GetCsvText(string) Get CSV text with specified format. public string GetCsvText(string format) Parameters format string Format string for each component Returns string CSV formatted string GetEachValueAbs() Get a new vector with each value set to its absolute value. public Vec2d GetEachValueAbs() Returns Vec2d A new vector with absolute values GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. GetMulEach(Vec2d) Get a new vector with each component multiplied with the corresponding component of the given vector. public Vec2d GetMulEach(Vec2d vec) Parameters vec Vec2d The vector to multiply with Returns Vec2d A new vector with multiplied components GetNormalized() Generate normalized vec. public Vec2d GetNormalized() Returns Vec2d Normalized vec GetRadian(Vec2d) Get angle between this and v. The angle has no sign. This vector is not required to be an unit vector. public double GetRadian(Vec2d v) Parameters v Vec2d one of the edge vector. Not required to be an unit vector. Returns double Angle in radian GetTransform(Func<double, double>) Get the new Vec2d by transforming each element by the function. public Vec2d GetTransform(Func<double, double> transformingFunc) Parameters transformingFunc Func<double, double> Returns Vec2d Interpolate(Vec2d, Vec2d, double) Linear interpolate between a and b. public static Vec2d Interpolate(Vec2d a, Vec2d b, double alpha) Parameters a Vec2d a b Vec2d b alpha double ratio Returns Vec2d interpolation IsNormalized(double) Check if this vector is normalized. public bool IsNormalized(double toleranceSquare = 1E-07) Parameters toleranceSquare double Tolerance for checking if length squared is 1 Returns bool True if the vector is normalized MulEach(Vec2d) Multiply each component with the corresponding component of the given vector. public Vec2d MulEach(Vec2d vec) Parameters vec Vec2d The vector to multiply with Returns Vec2d this Normalize() Normalize. public Vec2d Normalize() Returns Vec2d this Set(Vec2d) Set values by copy. public Vec2d Set(Vec2d src) Parameters src Vec2d src Returns Vec2d this Set(vec2d) Set values by copy. public Vec2d Set(vec2d src) Parameters src vec2d src Returns Vec2d this Set(double, double) Set values. public Vec2d Set(double x, double y) Parameters x double x y double y Returns Vec2d this Set(double[]) Set values by array. public Vec2d Set(double[] xy) Parameters xy double[] double[]{x,y} Returns Vec2d this Set(Func<int, double, double>) Set values using a function that maps direction index and current value to new value. public Vec2d Set(Func<int, double, double> dirToValueFunc) Parameters dirToValueFunc Func<int, double, double> Function that maps direction index and current value to new value Returns Vec2d this Set(Func<int, double>) Set values using a function that maps direction index to value. public Vec2d Set(Func<int, double> dirToValueFunc) Parameters dirToValueFunc Func<int, double> Function that maps direction index to value Returns Vec2d this Set(int, double, double) Set values by direction offset. Direction 0,1,2 indicate x,y,z respectively. public Vec2d Set(int dir, double a, double b) Parameters dir int direction offset a double value at direction (0+dir)%2 b double value at direction (1+dir)%2 Returns Vec2d this SetEachNanToZero() Set NaN to 0 for each value. public Vec2d SetEachNanToZero() Returns Vec2d this SetEachValueAbs() Set all member to absolute value. public Vec2d SetEachValueAbs() Returns Vec2d this ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. ToString(string) To string with format: (x,y) public string ToString(string format) Parameters format string Format string for the double values Returns string Formatted string representation of the vector ToString(string, IFormatProvider) Returns a string representation of the vector formatted according to the specified format. public string ToString(string format, IFormatProvider formatProvider) Parameters format string The format to use for each component formatProvider IFormatProvider The format provider to use Returns string A formatted string representation of the vector ToString(string, int) Format the vector with padding. public string ToString(string format, int leftPadding) Parameters format string Format string for each component leftPadding int Left padding for each component Returns string Formatted string Transform(Func<double, double>) Transform each element by the function. public Vec2d Transform(Func<double, double> transformingFunc) Parameters transformingFunc Func<double, double> Returns Vec2d WriteBin(BinaryWriter) Output to bytes: writer.Write(x); writer.Write(y); public void WriteBin(BinaryWriter writer) Parameters writer BinaryWriter writer Operators operator +(Vec2d, Vec2d) Plus. public static Vec2d operator +(Vec2d left, Vec2d right) Parameters left Vec2d a right Vec2d b Returns Vec2d a+b operator /(Vec2d, double) a/d. public static Vec2d operator /(Vec2d a, double d) Parameters a Vec2d a d double d Returns Vec2d a/d operator ==(Vec2d, Vec2d) Equality operator for comparing two Vec2d objects. public static bool operator ==(Vec2d left, Vec2d right) Parameters left Vec2d Left operand right Vec2d Right operand Returns bool True if the vectors are equal, false otherwise operator !=(Vec2d, Vec2d) Inequality operator for comparing two Vec2d objects. public static bool operator !=(Vec2d left, Vec2d right) Parameters left Vec2d Left operand right Vec2d Right operand Returns bool True if the vectors are not equal, false otherwise operator *(Vec2d, double) a*s. public static Vec2d operator *(Vec2d a, double s) Parameters a Vec2d a s double s Returns Vec2d a*s operator -(Vec2d, Vec2d) a-b. public static Vec2d operator -(Vec2d a, Vec2d b) Parameters a Vec2d a b Vec2d b Returns Vec2d a-b operator -(Vec2d) Negate. public static Vec2d operator -(Vec2d src) Parameters src Vec2d src Returns Vec2d Negate"
  },
  "api/Hi.Geom.Vec2i.html": {
    "href": "api/Hi.Geom.Vec2i.html",
    "title": "Class Vec2i | HiAPI-C# 2025",
    "summary": "Class Vec2i Namespace Hi.Geom Assembly HiGeom.dll Basic 2D point (or vector). public class Vec2i : IEquatable<Vec2i>, IFormattable Inheritance object Vec2i Implements IEquatable<Vec2i> IFormattable Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Vec2i(Vec2i) Copy ctor. public Vec2i(Vec2i src) Parameters src Vec2i src Vec2i(BinaryReader) Ctor by bytes: x = reader.ReadDouble(); y = reader.ReadDouble(); public Vec2i(BinaryReader reader) Parameters reader BinaryReader reader Vec2i(int, int) Ctor. public Vec2i(int x = 0, int y = 0) Parameters x int x y int y Vec2i(int, int, int) Ctor by direction offset. Direction 0,1 indicate x,y respectively. public Vec2i(int dir, int a, int b) Parameters dir int direction offset a int value at direction (0+dir)%3 b int value at direction (1+dir)%3 Vec2i(string) Ctor by string. The format is (x,y). public Vec2i(string src) Parameters src string src Fields x Value at x direction. public int x Field Value int y Value at y direction. public int y Field Value int Properties AbsSum Sum of abs(x) and abs(y). public int AbsSum { get; } Property Value int LengthSquare Length square. public int LengthSquare { get; } Property Value int Max Get max value from {x,y}. public int Max { get; } Property Value int MaxAbsDir Get the direction of the max absolute value. public int MaxAbsDir { get; } Property Value int MaxDir Get the direction of the max value. public int MaxDir { get; } Property Value int Min Get min value from {x,y}. public int Min { get; } Property Value int NativeByteSize public static int NativeByteSize { get; } Property Value int Byte size: sizeof(int) * 2. One Generate vec (1,1). public static Vec2i One { get; } Property Value Vec2i (1,1) UnitX Generate vec (1,0). public static Vec2i UnitX { get; } Property Value Vec2i (1,0) UnitY Generate vec (0,1). public static Vec2i UnitY { get; } Property Value Vec2i (0,1) Zero Generate vec (0,0). public static Vec2i Zero { get; } Property Value Vec2i (0,0) Methods At(int) Member at direction. public ref int At(int dir) Parameters dir int direction Returns int member Cross(Vec2i) Cross. public int Cross(Vec2i src) Parameters src Vec2i src Returns int cross value Dot(Vec2i) Dot. public int Dot(Vec2i src) Parameters src Vec2i src Returns int dotted value Equals(Vec2i) Indicates whether the current object is equal to another object of the same type. public bool Equals(Vec2i other) Parameters other Vec2i An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. GenOne() Generate vec (1,1). public static Vec2i GenOne() Returns Vec2i (1,1) GenUnitX() Generate vec (1,0). public static Vec2i GenUnitX() Returns Vec2i (1,0) GenUnitY() Generate vec (0,1). public static Vec2i GenUnitY() Returns Vec2i (0,1) GenZero() Generate vec (0,0). public static Vec2i GenZero() Returns Vec2i (0,0) GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. Output(BinaryWriter) Output to bytes: writer.Write(x); writer.Write(y); public void Output(BinaryWriter writer) Parameters writer BinaryWriter writer Set(Vec2i) Set values by copy. public Vec2i Set(Vec2i src) Parameters src Vec2i src Returns Vec2i this Set(int, int) Set values. public Vec2i Set(int x, int y) Parameters x int x y int y Returns Vec2i this Set(int, int, int) Set values by direction offset. Direction 0,1,2 indicate x,y,z respectively. public Vec2i Set(int dir, int a, int b) Parameters dir int direction offset a int value at direction (0+dir)%3 b int value at direction (1+dir)%3 Returns Vec2i this Set(int[]) Set values by array. public Vec2i Set(int[] xy) Parameters xy int[] int[]{x,y} Returns Vec2i this SetEachValueAbs() Set all member to absolute value. public Vec2i SetEachValueAbs() Returns Vec2i this ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. ToString(string, IFormatProvider) Returns a string representation of the vector formatted according to the specified format. public string ToString(string format, IFormatProvider formatProvider) Parameters format string The format to use for each component formatProvider IFormatProvider The format provider to use Returns string A formatted string representation of the vector Operators operator +(Vec2i, Vec2i) Plus. public static Vec2i operator +(Vec2i a, Vec2i b) Parameters a Vec2i a b Vec2i b Returns Vec2i a+b operator /(Vec2i, int) a/d. public static Vec2i operator /(Vec2i a, int d) Parameters a Vec2i a d int d Returns Vec2i a/d operator *(Vec2i, int) a*s. public static Vec2i operator *(Vec2i a, int s) Parameters a Vec2i a s int s Returns Vec2i a*s operator -(Vec2i, Vec2i) a-b. public static Vec2i operator -(Vec2i a, Vec2i b) Parameters a Vec2i a b Vec2i b Returns Vec2i a-b operator -(Vec2i) Negate. public static Vec2i operator -(Vec2i src) Parameters src Vec2i src Returns Vec2i Negate"
  },
  "api/Hi.Geom.Vec3d.html": {
    "href": "api/Hi.Geom.Vec3d.html",
    "title": "Class Vec3d | HiAPI-C# 2025",
    "summary": "Class Vec3d Namespace Hi.Geom Assembly HiGeom.dll Basic 3D point (or vector). public class Vec3d : IEquatable<Vec3d>, IExpandToBox3d, IBinaryIo, IWriteBin, ICsvRowIo, IEqualityOperators<Vec3d, Vec3d, bool>, IAdditionOperators<Vec3d, Vec3d, Vec3d>, ISubtractionOperators<Vec3d, Vec3d, Vec3d>, IMultiplyOperators<Vec3d, double, Vec3d>, IMultiplyOperators<Vec3d, Mat4d, Vec3d>, IDivisionOperators<Vec3d, double, Vec3d>, IVec<double>, IFormattable, IToPresentDto Inheritance object Vec3d Implements IEquatable<Vec3d> IExpandToBox3d IBinaryIo IWriteBin ICsvRowIo IEqualityOperators<Vec3d, Vec3d, bool> IAdditionOperators<Vec3d, Vec3d, Vec3d> ISubtractionOperators<Vec3d, Vec3d, Vec3d> IMultiplyOperators<Vec3d, double, Vec3d> IMultiplyOperators<Vec3d, Mat4d, Vec3d> IDivisionOperators<Vec3d, double, Vec3d> IVec<double> IFormattable IToPresentDto Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods BinIoUtil.ToBytes(IWriteBin) GeomUtil.ExpandToBox3d(IExpandToBox3d, Mat4d, Box3d) GeomUtil.GetBox3d(IExpandToBox3d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Vec3d() Ctor. public Vec3d() Vec3d(Polar3d) Ctor. public Vec3d(Polar3d src) Parameters src Polar3d src Vec3d(Vec2d, double) Initializes a new instance of the Vec3d class from a 2D vector and z coordinate. public Vec3d(Vec2d xy, double z) Parameters xy Vec2d The 2D vector providing x and y coordinates. z double The z coordinate. Vec3d(Vec3d) Copy ctor. public Vec3d(Vec3d src) Parameters src Vec3d src Vec3d(vec3d) ctor. public Vec3d(vec3d src) Parameters src vec3d src Vec3d(vec3f) ctor. public Vec3d(vec3f src) Parameters src vec3f src Vec3d(IEnumerable<double>) Creates a vector from an enumerable collection of three double values. public Vec3d(IEnumerable<double> src) Parameters src IEnumerable<double> Source collection containing three double values Vec3d(double, double, double) Ctor. public Vec3d(double x, double y, double z) Parameters x double x y double y z double z Vec3d(Func<int, double>) Creates a vector using a function that maps direction index to value. public Vec3d(Func<int, double> dirToValueFunc) Parameters dirToValueFunc Func<int, double> Function that takes direction index (0=X, 1=Y, 2=Z) and returns the corresponding value Vec3d(BinaryReader) Ctor by bytes: x = reader.ReadDouble(); y = reader.ReadDouble(); z = reader.ReadDouble(); public Vec3d(BinaryReader reader) Parameters reader BinaryReader reader Vec3d(int, double, double, double) Ctor by direction offset. Direction 0,1,2 indicate x,y,z respectively. public Vec3d(int dir, double a, double b, double c) Parameters dir int direction offset a double value at direction (0+dir)%3 b double value at direction (1+dir)%3 c double value at direction (2+dir)%3 Vec3d(string) Ctor by string. The format is (x,y,z). public Vec3d(string src) Parameters src string src Vec3d((double, double, double)) Ctor. public Vec3d((double, double, double) src) Parameters src (double, double, double) src Fields x Value at x direction. public double x Field Value double y Value at y direction. public double y Field Value double z Value at z direction. public double z Field Value double Properties AbsSum public double AbsSum { get; } Property Value double Sum of the abs {x,y,z}. Which is Math.Abs(x) + Math.Abs(y) + Math.Abs(z). AllOne public static Vec3d AllOne { get; } Property Value Vec3d Generate Vec3d(1, 1, 1). CsvText Csv text. public string CsvText { get; set; } Property Value string CsvTitleText Csv titles text. public string CsvTitleText { get; } Property Value string ElementNum Element number: 3 for (x,y,z). public static int ElementNum { get; } Property Value int IsAllFinite public bool IsAllFinite { get; } Property Value bool Is x,y,z all finite. IsAllNaN public bool IsAllNaN { get; } Property Value bool is x,y,z all NaN. IsAllNegativeInfinity public bool IsAllNegativeInfinity { get; } Property Value bool is x,y,z all NegativeInfinity. IsAllPositiveInfinity public bool IsAllPositiveInfinity { get; } Property Value bool is x,y,z all PositiveInfinity. IsAnyFinite public bool IsAnyFinite { get; } Property Value bool Is at least one of x,y,z finite. IsAnyNaN public bool IsAnyNaN { get; } Property Value bool Is any of {x,y,z} NaN. IsZero public bool IsZero { get; } Property Value bool Is zero vector. Which is x == 0 && y == 0 && z == 0. this[int] Gets or sets the element at the specified index. public double this[int dir] { get; set; } Parameters dir int Property Value double The element at the specified index. Length public double Length { get; } Property Value double Geometry length of this. LengthSquare public double LengthSquare { get; } Property Value double Geometry length ^ 2. Which is x * x + y * y + z * z. MaxAbsDir public int MaxAbsDir { get; } Property Value int Get the direction index with maximum absolute value. If the absolute of {x,y,z} is the biggest, return {0,1,2}. MaxDir public int MaxDir { get; } Property Value int Get the direction index with maximum value. If {x,y,z} is the biggest, return {0,1,2}. MaxValue public double MaxValue { get; } Property Value double The max value selected from {x,y,z}. Which is Math.Max(Math.Max(x, y), z). MinDir public int MinDir { get; } Property Value int Get the direction index with maximum value. If {x,y,z} is the biggest, return {0,1,2}. MinValue public double MinValue { get; } Property Value double The min value selected from {x,y,z}. Which is Math.Min(Math.Min(x, y), z). NaN public static Vec3d NaN { get; } Property Value Vec3d Generate Vec3d(double.NaN, double.NaN, double.NaN). NativeByteSize public static int NativeByteSize { get; } Property Value int Byte size: sizeof(double) * 3. NegativeInfinity public static Vec3d NegativeInfinity { get; } Property Value Vec3d Generate Vec3d(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity) PositiveInfinity public static Vec3d PositiveInfinity { get; } Property Value Vec3d Generate Vec3d(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity) Rank Dimension (i.e. Size) of the Vector. public int Rank { get; } Property Value int Text Gets or sets the vector as a string representation. public string Text { get; set; } Property Value string UnitX public static Vec3d UnitX { get; } Property Value Vec3d Generate Vec3d(1, 0, 0). UnitY public static Vec3d UnitY { get; } Property Value Vec3d Generate Vec3d(0, 1, 0). UnitZ public static Vec3d UnitZ { get; } Property Value Vec3d Generate Vec3d(0, 0, 1). X Value at x direction. public double X { get; set; } Property Value double XY Vec2d of X and Y. The getter gets a copied object. public Vec2d XY { get; set; } Property Value Vec2d Y Value at y direction. public double Y { get; set; } Property Value double Z Value at z direction. public double Z { get; set; } Property Value double Zero public static Vec3d Zero { get; } Property Value Vec3d Generate Vec3d(0, 0, 0). Methods All(double) Creates a vector with all components set to the specified value. public static Vec3d All(double v) Parameters v double Value to set for all components Returns Vec3d A new vector with all components set to the specified value At(int) Get the value at the dirction. Direction 0,1,2 are x,y,z. If direction index is larger than 2, the return value is at z direction. public ref double At(int dir) Parameters dir int direction index Returns double value at the direction BilinearInterpolate(Vec3d, Vec3d, Vec3d, Vec3d, double, double) Performs bilinear interpolation between four points. public static Vec3d BilinearInterpolate(Vec3d p00, Vec3d p01, Vec3d p10, Vec3d p11, double u, double v) Parameters p00 Vec3d Point at (0,0) p01 Vec3d Point at (0,1) p10 Vec3d Point at (1,0) p11 Vec3d Point at (1,1) u double Interpolation parameter in first dimension (0.0 to 1.0) v double Interpolation parameter in second dimension (0.0 to 1.0) Returns Vec3d The interpolated point Cross(Vec3d, Vec3d) Get a cross b. public static Vec3d Cross(Vec3d a, Vec3d b) Parameters a Vec3d a b Vec3d b Returns Vec3d a x b Dot(Vec3d) this dot src. public double Dot(Vec3d src) Parameters src Vec3d src Returns double dotted value Enumerate() Enumerates the components of the vector. public IEnumerable<double> Enumerate() Returns IEnumerable<double> An enumerable sequence of the vector's components (X, Y, Z) Equals(Vec3d) Indicates whether the current object is equal to another object of the same type. public bool Equals(Vec3d other) Parameters other Vec3d An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(Vec3d, double) check equals for each component with tolerance. public bool Equals(Vec3d other, double toleranceForEachComponent) Parameters other Vec3d other vec toleranceForEachComponent double tolerance for each component Returns bool check equals for each component with tolerance. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. ExpandMax(Vec3d) Find and expand maximum values from src. public void ExpandMax(Vec3d src) Parameters src Vec3d src ExpandMin(Vec3d) Find and expand minimum values from src. public void ExpandMin(Vec3d src) Parameters src Vec3d src ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetCosSquareWith(Vec3d) Get Cos(theta)^2. theta is the angle between this and src. This function is faster than GetCosWith(Vec3d) since it lacks one square root operation. public double GetCosSquareWith(Vec3d src) Parameters src Vec3d one of edge vector Returns double Cos(theta)^2 GetCosWith(Vec3d) Get Cos(theta). theta is the angle between this and v. public double GetCosWith(Vec3d v) Parameters v Vec3d a vector Returns double Cos(theta) GetCross(Vec3d) Get this cross src. public Vec3d GetCross(Vec3d src) Parameters src Vec3d src Returns Vec3d GetCsvText(string) Gets the CSV text representation of this vector with the specified format. public string GetCsvText(string format) Parameters format string Format string for the double values Returns string CSV formatted string GetEachValueAbs() Creates a new vector with the absolute value of each component. public Vec3d GetEachValueAbs() Returns Vec3d A new vector with absolute values of each component GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. GetMulEach(Vec3d) Creates a new vector by multiplying each component of this vector with the corresponding component of another vector. public Vec3d GetMulEach(Vec3d vec) Parameters vec Vec3d The vector to multiply with Returns Vec3d A new vector with component-wise multiplication results GetMulWithoutTrans(Mat4d) Get a new object by this*mat without translation part. public Vec3d GetMulWithoutTrans(Mat4d mat) Parameters mat Mat4d transform matrix Returns Vec3d new Vec3d(x * mat.At(0, 0) + y * mat.At(1, 0) + z * mat.At(2, 0) , x* mat.At(0, 1) + y* mat.At(1, 1) + z* mat.At(2, 1) , x* mat.At(0, 2) + y* mat.At(1, 2) + z* mat.At(2, 2)) GetNormalized() Generate normalized vec. public Vec3d GetNormalized() Returns Vec3d Normalized vec GetRadian(Vec3d) Get angle between this and v. The angle has no sign. This vector is not required to be an unit vector. public double GetRadian(Vec3d v) Parameters v Vec3d one of the edge vector. Not required to be an unit vector. Returns double Angle in radian GetRadian(Vec3d, Vec3d) Get angle between this and v. This function applies normal vector to determine the sign of angle. This vector is not required to be an unit vector. public double GetRadian(Vec3d v, Vec3d n) Parameters v Vec3d vector of ending edge. Not required to be an unit vector. n Vec3d normal vector. Not required to be an unit vector. Returns double angle in radian GetRadianByUnitVector(Vec3d) Get angle between this and v. The angle has no sign. This vector is not required to be an unit vector. Both this and v should be unit vector. Much efficient than GetRadian(Vec3d). public double GetRadianByUnitVector(Vec3d v) Parameters v Vec3d one of the edge vector. Not required to be an unit vector. Returns double Angle in radian GetTransform(Func<double, double>) Get the new Vec3d by transforming each element by the function. public Vec3d GetTransform(Func<double, double> transformingFunc) Parameters transformingFunc Func<double, double> Returns Vec3d GetVec2dByPlaneDir(int) Gets a 2D vector by projecting the 3D vector onto a plane. public Vec2d GetVec2dByPlaneDir(int dir) Parameters dir int Direction index: 0 for YZ plane, 1 for ZX plane, 2 for XY plane Returns Vec2d A 2D vector representing the projection GetXRotation(double) Get rotated Vec3d along x direction. CCW. Much efficient than using Mat4d multiplication. public Vec3d GetXRotation(double rad) Parameters rad double rotation radian Returns Vec3d rotated Vec3d GetYRotation(double) Get rotated Vec3d along y direction. CCW. Much efficient than using Mat4d multiplication. public Vec3d GetYRotation(double rad) Parameters rad double rotation radian Returns Vec3d rotated Vec3d GetZRotation(double) Get rotated Vec3d along z direction. CCW. Much efficient than using Mat4d multiplication. public Vec3d GetZRotation(double rad) Parameters rad double rotation radian Returns Vec3d rotated Vec3d Interpolate(Vec3d, Vec3d, double) Interpolate from a to b with ratio alpha:(1-alpha). public static Vec3d Interpolate(Vec3d a, Vec3d b, double alpha) Parameters a Vec3d a b Vec3d b alpha double ratio Returns Vec3d a * (1 - alpha) + b * alpha IsNormalized(double) Checks if the vector is normalized (has a length of approximately 1). public bool IsNormalized(double toleranceSquare = 1E-07) Parameters toleranceSquare double Square of the tolerance value for comparing with 1 (default: 1e-7) Returns bool True if the vector is normalized within the specified tolerance MulEach(Vec3d) Multiplies each component of this vector with the corresponding component of another vector. public Vec3d MulEach(Vec3d vec) Parameters vec Vec3d The vector to multiply with Returns Vec3d This vector after multiplication MulWithoutTrans(Mat4d) this*=mat without translation part. public Vec3d MulWithoutTrans(Mat4d mat) Parameters mat Mat4d transformation matrix Returns Vec3d this See Also GetMulWithoutTrans(Mat4d) Normalize() Normalize this. public Vec3d Normalize() Returns Vec3d this Parse(string) If src is not null and not empty string, return Vec3d(string); otherwise return null. public static Vec3d Parse(string src) Parameters src string src Returns Vec3d parsed Vec3d ParseByCsv(string) Parses a vector from a CSV text string. public static Vec3d ParseByCsv(string csvText) Parameters csvText string CSV formatted string containing vector components Returns Vec3d A new vector parsed from the CSV text ReadBin(BinaryReader) Reads binary data to initialize the object. public void ReadBin(BinaryReader reader) Parameters reader BinaryReader The binary reader to read from Set(Vec3d) Set values by copy. public Vec3d Set(Vec3d src) Parameters src Vec3d src Returns Vec3d this Set(vec3d) Set values by copy. public Vec3d Set(vec3d src) Parameters src vec3d src Returns Vec3d this Set(double, double, double) Set values. public Vec3d Set(double x, double y, double z) Parameters x double x y double y z double z Returns Vec3d this Set(double[]) Set values by array. public Vec3d Set(double[] xyz) Parameters xyz double[] double[]{x,y,z} Returns Vec3d this Set(Func<int, double, double>) Sets vector components using a function that maps direction index and current value to new value. public Vec3d Set(Func<int, double, double> dirToValueFunc) Parameters dirToValueFunc Func<int, double, double> Function that takes direction index (0=X, 1=Y, 2=Z) and current value, and returns the new value Returns Vec3d This vector after modification Set(Func<int, double>) Sets vector components using a function that maps direction index to value. public Vec3d Set(Func<int, double> dirToValueFunc) Parameters dirToValueFunc Func<int, double> Function that takes direction index (0=X, 1=Y, 2=Z) and returns the corresponding value Returns Vec3d This vector after modification Set(int, double, double, double) Set values by direction offset. Direction 0,1,2 indicate x,y,z respectively. public Vec3d Set(int dir, double a, double b, double c) Parameters dir int direction offset a double value at direction (0+dir)%3 b double value at direction (1+dir)%3 c double value at direction (2+dir)%3 Returns Vec3d this SetEachNanToZero() Set NaN to 0 for each value. public Vec3d SetEachNanToZero() Returns Vec3d this SetEachValueAbs() Set each value to absolute. public Vec3d SetEachValueAbs() Returns Vec3d this ToArray() return new double[] { x, y, z } public double[] ToArray() Returns double[] { x, y, z } ToBuf(double[]) Set x,y,z to the dst array. public void ToBuf(double[] dst) Parameters dst double[] dst ToBuf(double[], ref int) Set x,y,z to the dst array from postion p and increase p by the pushed number. public int ToBuf(double[] dst, ref int p) Parameters dst double[] dst p int position from dst Returns int Which is pushed number of double ToPresentDto() Convert Vec3d to presentation DTO (Data Transfer Object) for JSON serialization. The returned object includes type metadata for web API presentation. public object ToPresentDto() Returns object DTO dictionary with Type, x, y, z keys ToString() To representative string with format:(x,y,z). public override string ToString() Returns string Representative string ToString(string) To string with format: (x,y,z) public string ToString(string format) Parameters format string format of ToString(string) Returns string Representative string ToString(string, IFormatProvider) Returns a string representation of the vector formatted according to the specified format. public string ToString(string format, IFormatProvider formatProvider) Parameters format string The format to use for each component formatProvider IFormatProvider The format provider to use Returns string A formatted string representation of the vector ToString(string, int) Converts the vector to a string with the specified format and left padding. public string ToString(string format, int leftPadding) Parameters format string Format string for the double values leftPadding int Number of characters to pad on the left of each value Returns string Formatted string representation of the vector Transform(Func<double, double>) Transform each element by the function. public Vec3d Transform(Func<double, double> transformingFunc) Parameters transformingFunc Func<double, double> Returns Vec3d TryParse(string, out Vec3d) Attempts to parse a string into a Vec3d. public static bool TryParse(string src, out Vec3d dst) Parameters src string The string to parse in format “(x,y,z)” dst Vec3d When this method returns, contains the Vec3d value if parsing succeeded, or null if parsing failed Returns bool true if parsing succeeded; otherwise, false TryParseLoose(string, out Vec3d) Attempts to parse a string into a Vec3d using a loose format. Accepts various delimiters (comma, semicolon, space) and removes brackets/parentheses. public static bool TryParseLoose(string text, out Vec3d dst) Parameters text string The string to parse. Can contain brackets, parentheses, or other delimiters. dst Vec3d When this method returns, contains the parsed Vec3d if successful, or Vec3d.NaN if parsing failed. Returns bool True if parsing was successful; otherwise, false. WriteBin(BinaryWriter) Output to bytes: writer.Write(x); writer.Write(y); writer.Write(z); public void WriteBin(BinaryWriter writer) Parameters writer BinaryWriter writer Operators operator +(Vec3d, Vec3d) Plus. public static Vec3d operator +(Vec3d left, Vec3d right) Parameters left Vec3d a right Vec3d b Returns Vec3d new Vec3d(a.x + b.x, a.y + b.y, a.z + b.z) operator /(Vec3d, double) Get a new object from a scaled by 1/d. public static Vec3d operator /(Vec3d a, double d) Parameters a Vec3d d double Returns Vec3d operator ==(Vec3d, Vec3d) Equality operator for comparing two Vec3d objects. public static bool operator ==(Vec3d left, Vec3d right) Parameters left Vec3d Left operand right Vec3d Right operand Returns bool True if the vectors are equal, false otherwise operator !=(Vec3d, Vec3d) Inequality operator for comparing two Vec3d objects. public static bool operator !=(Vec3d left, Vec3d right) Parameters left Vec3d Left operand right Vec3d Right operand Returns bool True if the vectors are not equal, false otherwise operator *(Vec3d, Mat4d) Get p*src. public static Vec3d operator *(Vec3d p, Mat4d src) Parameters p Vec3d point src Mat4d transmform matrix Returns Vec3d new Vec3d(p.x * src.At(0, 0) + p.y * src.At(1, 0) + p.z * src.At(2, 0) + src.At(3, 0) , p.x* src.At(0, 1) + p.y* src.At(1, 1) + p.z* src.At(2, 1) + src.At(3, 1) , p.x* src.At(0, 2) + p.y* src.At(1, 2) + p.z* src.At(2, 2) + src.At(3, 2)) operator *(Vec3d, double) Scale a by s. public static Vec3d operator *(Vec3d a, double s) Parameters a Vec3d vector s double scale Returns Vec3d new Vec3d(a.x * s, a.y * s, a.z * s) operator -(Vec3d, Vec3d) Minus. public static Vec3d operator -(Vec3d a, Vec3d b) Parameters a Vec3d a b Vec3d b Returns Vec3d new Vec3d(a.x - b.x, a.y - b.y, a.z - b.z) operator -(Vec3d) Get negate vector. public static Vec3d operator -(Vec3d src) Parameters src Vec3d src Returns Vec3d new Vec3d(-src.x, -src.y, -src.z)"
  },
  "api/Hi.Geom.html": {
    "href": "api/Hi.Geom.html",
    "title": "Namespace Hi.Geom | HiAPI-C# 2025",
    "summary": "Namespace Hi.Geom Classes ArrayUtil Utility class for array operations. AxisAngle4d Axis(3d) and angle(1d) Box2d Lightweight 2d box. An orthogonal box which the edges are all parallel with Cartesian Coordinate. The data contains in a Box2d is Min and Max. Box2d.NoInit Flag for calling Box2d(NoInit). Box3d Lightweight 3d box. An orthogonal box which the edges are all parallel with Cartesian Coordinate. The data contains in a Box3d is Min and Max. Box3d.NoInit Flag for calling Box3d(NoInit). Cylindroid 3d Geometry of Cylindroid. DVec3d Dual Vec3d with p(Vec3d) and n(Vec3d). ExtendedCylinder An extensible cylinder geometry that generates a corresponding Cylindroid by the start section and the total length. Flat3d Represents a 3D plane defined by a unit normal vector and its signed distance from the origin. The plane equation is: Ax + By + Cz + d = 0, where (A,B,C) is the normal vector and d is the distance to origin. GenStlFuncHost A class that hosts a function to generate STL geometry at a caller-chosen resolution. GeomCombination A class that manages multiple STL sources as a single source. GeomUtil Utility of Geometry. Mat4d 4x4 Matrix. MathNetUtil Utility class for MathNet.Numerics operations. MathUtil Math Utility. NativeFraction Native wrapper for C++ fraction_t<0> (unlimited precision fraction). A fraction consists of a numerator and denominator using unlimited precision integers. NativeStl Native Stl. For purpose of efficient swept volume. ObjUtil Wavefront OBJ writer for RGB-coloured triangle buffers. PairZr Value pair of Z and R. PairZrUtil Utility class for working with PairZr objects PlyUtil Stanford PLY writer for RGB-coloured triangle buffers. Polar3d Represents a point in 3D space using polar coordinates Segment3d Represents a 3D line segment defined by two endpoints. Stl STL (stereolithography). Composed by Triangles. Provide Stl File R/W. StlFile Represents an STL file with loading and saving capabilities StlFuncHost A class that hosts a function to generate STL geometry. StlUtil Utility for Stl. TransformationGeom Represents a geometric transformation that can be applied to a geometry object. This class combines a transformer with a target geometry to produce transformed geometric results. Tri3d Basic 3D Triangle. Tri3dUtil Utility of Tri3d. Include generator of triangles from points. Vec2d Basic 2D point (or vector). Vec2i Basic 2D point (or vector). Vec3d Basic 3D point (or vector). Structs Fraction<TEva> Pure C# unlimited precision fraction. Interfaces IExpandToBox2d Object that can be expanded to a Box2d. IExpandToBox3d Object that can be expanded to a Box3d. IFlat3d Interface for a 3D plane that provides an anchor point and a normal vector. IGenStl Interface for generating STL geometry with a resolution. IGeomProperty Interface for objects that have a geometry property. IGetStl Interface for retrieving STL geometry data. IGetZrContour Interface for retrieving Z-R contour data for rotational geometries. IGetZrList Interface for getting a list of Z-R pairs. IStlSource Stl provider with xml support. ITri3d Interface for 3D triangles. IVec<T> Interface for vector types with generic element type. IZrListSourceProperty Provides a source for obtaining an IGetZrList. Enums Dir Enumeration of coordinate axis directions in 3D space. FractionStatus Status flags for Fraction and NativeFraction. Corresponds to IS_PACKED_MASK and IS_EVALUATED_MASK in C++ fraction_base_t. Mat4d.IndexFlag Specifies the indexing method for matrix construction from vectors. Stl.StlType Stl file format."
  },
  "api/Hi.HiNcKits.BasePathEnum.html": {
    "href": "api/Hi.HiNcKits.BasePathEnum.html",
    "title": "Enum BasePathEnum | HiAPI-C# 2025",
    "summary": "Enum BasePathEnum Namespace Hi.HiNcKits Assembly HiNc.dll Enumeration of base path types used in the HiNC system. [Flags] public enum BasePathEnum Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields AdminDir = 2 The administration directory path. None = 0 No specific path type. ProjectDir = 4 The project directory path. ResourceDir = 8 The resource directory path."
  },
  "api/Hi.HiNcKits.HiNcHost.html": {
    "href": "api/Hi.HiNcKits.HiNcHost.html",
    "title": "Class HiNcHost | HiAPI-C# 2025",
    "summary": "Class HiNcHost Namespace Hi.HiNcKits Assembly HiNc.dll Rich HiNC Service. Host class for HiNC functionality that provides project management, path resolution, and DB integration. public class HiNcHost : IDisposable Inheritance object HiNcHost Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HiNcHost(ProxyProjectService, ILogger) Initializes a new instance of the HiNcHost class with a proxy project service. public HiNcHost(ProxyProjectService proxyProjectService, ILogger logger = null) Parameters proxyProjectService ProxyProjectService The proxy project service to use. logger ILogger Optional logger instance. Fields HiNcUserDbMetaName Gets the name of the HiNC user database metadata. public const string HiNcUserDbMetaName = \"UserDbMeta\" Field Value string HiNcUserDbName Gets the name of the HiNC user database. public const string HiNcUserDbName = \"HiNcUserDb\" Field Value string Properties AdminDirectory Admin absolute directory. public string AdminDirectory { get; set; } Property Value string AdminExtendedNamedPath Gets the admin extended named path. public ExtendedNamedPath AdminExtendedNamedPath { get; } Property Value ExtendedNamedPath AdminNamedPath Gets the admin named path. public NamedPath AdminNamedPath { get; } Property Value NamedPath CacheDbId Gets the cache database ID. public static string CacheDbId { get; set; } Property Value string IdentityStorage Gets the SQLite identity storage instance (for user authentication). public SqliteIdentityStorage IdentityStorage { get; } Property Value SqliteIdentityStorage LocalProjectService Gets the local project service from the proxy project service. public LocalProjectService LocalProjectService { get; } Property Value LocalProjectService MachiningProject Gets the machining project from the local project service. public MachiningProject MachiningProject { get; } Property Value MachiningProject ProjectDirectory Project Absolute Directory. public string ProjectDirectory { get; } Property Value string ProjectExtendedNamedPath Gets the project extended named path. public ExtendedNamedPath ProjectExtendedNamedPath { get; } Property Value ExtendedNamedPath ProjectNamedPath Gets the project named path. public NamedPath ProjectNamedPath { get; } Property Value NamedPath ProjectRelativeDirectory Gets the relative project directory path. public string ProjectRelativeDirectory { get; } Property Value string RelativeProjectPath Gets the relative project path from the proxy project service. public string RelativeProjectPath { get; } Property Value string ResourceDir Resource absolute directory. public string ResourceDir { get; } Property Value string ResourceExtendedNamedPath Gets the resource extended named path. public ExtendedNamedPath ResourceExtendedNamedPath { get; } Property Value ExtendedNamedPath ResourceNamedPath Gets the resource named path. public NamedPath ResourceNamedPath { get; } Property Value NamedPath ResourceRelDir Relative directory from AdminDirectory for resource. public string ResourceRelDir { get; set; } Property Value string StepStorage Gets the SQLite step storage instance (for milling step data). public SqliteStepStorage StepStorage { get; } Property Value SqliteStepStorage Methods CloseProject() Closes the current project. public void CloseProject() CopyResourceIfNotExisted() Copies resources if they don't already exist in the target location. public void CopyResourceIfNotExisted() Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool GetExtendedNamedPathByNamePath(string) Gets an extended named path by its name path. public ExtendedNamedPath GetExtendedNamedPathByNamePath(string namePath) Parameters namePath string The name path to look up. Returns ExtendedNamedPath The extended named path for the specified name path, or null if not found. GetExtendedNamedPathByPath(string) Gets an extended named path by its path. public ExtendedNamedPath GetExtendedNamedPathByPath(string path) Parameters path string The path to look up. Returns ExtendedNamedPath The extended named path with the specified path, or null if not found. GetExtendedNamedPathByUriPara(string) GetExtendedNamedPath By blazor page parameter. public ExtendedNamedPath GetExtendedNamedPathByUriPara(string uriPara) Parameters uriPara string Returns ExtendedNamedPath GetExtendedNamedPathList(params BasePathEnum[]) Gets a list of extended named paths for the specified base path types. public List<ExtendedNamedPath> GetExtendedNamedPathList(params BasePathEnum[] basePathEnums) Parameters basePathEnums BasePathEnum[] The base path types to include. Returns List<ExtendedNamedPath> A list of extended named paths. GetNamedPathByName(string) Gets a named path by its name. public NamedPath GetNamedPathByName(string name) Parameters name string The name of the path to retrieve Returns NamedPath The named path with the specified name, or null if not found GetNamedPathByPath(string) Gets a named path by its path. public NamedPath GetNamedPathByPath(string path) Parameters path string The path to look up. Returns NamedPath The named path with the specified path, or null if not found. GetNamedPathList(params BasePathEnum[]) Gets a list of named paths for the specified base path types. public List<NamedPath> GetNamedPathList(params BasePathEnum[] basePathEnums) Parameters basePathEnums BasePathEnum[] The base path types to include. Returns List<NamedPath> A list of named paths. LoadProjectByRelativePath(string) Loads a project from the specified relative file path. public void LoadProjectByRelativePath(string relativeFilePathFromAdminRoot) Parameters relativeFilePathFromAdminRoot string The relative file path from the admin directory root NewProjectByRelFile(string) Creates a new project from a relative file path. public void NewProjectByRelFile(string relFilePath) Parameters relFilePath string The relative file path from the admin directory Reg(XFactory) Bootstraps XML-factory registration for the HiNC host. Equivalent to Reg(XFactory); entry points that construct HiNcHost directly (without going through LocalProjectService) should call this once at startup. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ReloadProject() Reloads the current project. public void ReloadProject() SaveAsProject(string) Saves the current project to a specified relative file path. public void SaveAsProject(string relativeFilePath) Parameters relativeFilePath string The relative file path from the admin directory root SaveProject() Save project in the current path. public void SaveProject() ShowMessageBoard(string, string, BootstrapTheme) Shows a message board with specified title, message and theme. public void ShowMessageBoard(string title, string message, BootstrapTheme bootstrapThemeColor) Parameters title string The title of the message board message string The message to display bootstrapThemeColor BootstrapTheme The bootstrap theme color for the message board Events OnShownMessageBoard Event raised when a message board is shown. public event ShowMessageBoardDelegate OnShownMessageBoard Event Type ShowMessageBoardDelegate"
  },
  "api/Hi.HiNcKits.LocalApp.html": {
    "href": "api/Hi.HiNcKits.LocalApp.html",
    "title": "Class LocalApp | HiAPI-C# 2025",
    "summary": "Class LocalApp Namespace Hi.HiNcKits Assembly HiNc.dll Local application initialization and cleanup utilities. public static class LocalApp Inheritance object LocalApp Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields DefaultLocalAppConfigPath Path to the configuration file. public const string DefaultLocalAppConfigPath = \"hinc-host-config.xml\" Field Value string Properties LocalAppConfig Gets or sets the host configuration. public static LocalAppConfig LocalAppConfig { get; set; } Property Value LocalAppConfig Methods AppBegin(LocalAppConfig, ILogger) Initializes the application with the specified configuration. public static void AppBegin(LocalAppConfig localAppConfig, ILogger logger) Parameters localAppConfig LocalAppConfig The local application configuration. logger ILogger Logger used for startup diagnostics. AppBegin(ILogger, string) Initializes the application with the specified cache database path. public static void AppBegin(ILogger logger, string cacheDbPath = null) Parameters logger ILogger Logger instance for startup diagnostics. cacheDbPath string The path to the SQLite cache database. If null, uses default path. AppBeginWithConfigFile(ILogger, string) Initializes the application with configuration from a file. public static void AppBeginWithConfigFile(ILogger logger, string hostConfigPath = null) Parameters logger ILogger Logger used when loading configuration and initializing caches. hostConfigPath string Path to the host configuration file. Uses default path if null. AppEnd() Cleans up the application by stopping services and logging out licenses. public static void AppEnd()"
  },
  "api/Hi.HiNcKits.LocalAppConfig.html": {
    "href": "api/Hi.HiNcKits.LocalAppConfig.html",
    "title": "Class LocalAppConfig | HiAPI-C# 2025",
    "summary": "Class LocalAppConfig Namespace Hi.HiNcKits Assembly HiNc.dll Configuration for host-related settings. public class LocalAppConfig Inheritance object LocalAppConfig Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors LocalAppConfig() Initializes a new instance. public LocalAppConfig() LocalAppConfig(XElement, string) Initializes a new instance of the LocalAppConfig class from XML data. public LocalAppConfig(XElement src, string baseDirectory) Parameters src XElement XML element containing configuration data baseDirectory string Base directory for resolving relative paths Properties CacheDbPath Gets or sets the cache database path (SQLite database). public string CacheDbPath { get; set; } Property Value string XName Name for XML IO. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string) public XElement MakeXmlSource(string baseDirectory, string relFile) Parameters baseDirectory string relFile string Returns XElement"
  },
  "api/Hi.HiNcKits.ProxyConfig.html": {
    "href": "api/Hi.HiNcKits.ProxyConfig.html",
    "title": "Class ProxyConfig | HiAPI-C# 2025",
    "summary": "Class ProxyConfig Namespace Hi.HiNcKits Assembly HiNc.dll Configuration for proxy-related settings. public class ProxyConfig : IMakeXmlSource Inheritance object ProxyConfig Implements IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ProxyConfig() Default constructor public ProxyConfig() ProxyConfig(XElement, string) Initializes a new instance of the ProxyConfig class from XML data. public ProxyConfig(XElement src, string baseDirectory) Parameters src XElement XML element containing configuration data baseDirectory string Base directory for resolving relative paths Properties AdminDirectory Gets or sets the admin directory path. public string AdminDirectory { get; set; } Property Value string XName Name for XML IO. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.HiNcKits.ResourceSeeder.html": {
    "href": "api/Hi.HiNcKits.ResourceSeeder.html",
    "title": "Class ResourceSeeder | HiAPI-C# 2025",
    "summary": "Class ResourceSeeder Namespace Hi.HiNcKits Assembly HiNc.dll Seeds the shipped default resources (Resource/** from the HiNc-Resource content package, next to the executable) into the admin resource directory, honoring the ResourceDefaultMarker ownership convention: Marked items (X.default.Ext files, Name.default/ folders) are system territory — they are copied in, refreshed when the shipped bytes change, and deleted when no longer shipped. Unmarked items belong to the user and are never touched. A version stamp file at the destination root records the last-seeded HiNc-Resource version; when it matches, the whole pass is skipped, so steady-state startup cost is one small file read. public static class ResourceSeeder Inheritance object ResourceSeeder Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Remarks One-time migration for pre-marker installs: an unmarked twin of a shipped item (same path with the marker stripped) whose bytes equal the shipped bytes is absorbed — deleted so the marked copy replaces it. A twin with different bytes is a user customization and is left alone. Unmarked files in the source tree are ignored entirely; stale additive-only build output therefore never propagates to the admin folder. All failures are logged as warnings — seeding never throws. Fields ResourceAssemblyFileName Assembly file probed (next to the executable) for the shipped resource version. public const string ResourceAssemblyFileName = \"HiNc-Resource.dll\" Field Value string VersionStampFileName Version stamp file name written at the destination resource root. public const string VersionStampFileName = \".hinc-resource-version\" Field Value string Methods Seed(string, ILogger) Seeds the shipped defaults into adminResourceDirectory. Source is Resource/ under BaseDirectory (the process CWD is not stable enough to anchor on). Never throws. public static void Seed(string adminResourceDirectory, ILogger logger) Parameters adminResourceDirectory string Absolute path of the admin Resource root. logger ILogger Sink for the pass summary and warnings."
  },
  "api/Hi.HiNcKits.html": {
    "href": "api/Hi.HiNcKits.html",
    "title": "Namespace Hi.HiNcKits | HiAPI-C# 2025",
    "summary": "Namespace Hi.HiNcKits Classes HiNcHost Rich HiNC Service. Host class for HiNC functionality that provides project management, path resolution, and DB integration. LocalApp Local application initialization and cleanup utilities. LocalAppConfig Configuration for host-related settings. ProxyConfig Configuration for proxy-related settings. ResourceSeeder Seeds the shipped default resources (Resource/** from the HiNc-Resource content package, next to the executable) into the admin resource directory, honoring the ResourceDefaultMarker ownership convention: Marked items (X.default.Ext files, Name.default/ folders) are system territory — they are copied in, refreshed when the shipped bytes change, and deleted when no longer shipped. Unmarked items belong to the user and are never touched. A version stamp file at the destination root records the last-seeded HiNc-Resource version; when it matches, the whole pass is skipped, so steady-state startup cost is one small file read. Enums BasePathEnum Enumeration of base path types used in the HiNC system."
  },
  "api/Hi.Licenses.AuthFeature.html": {
    "href": "api/Hi.Licenses.AuthFeature.html",
    "title": "Enum AuthFeature | HiAPI-C# 2025",
    "summary": "Enum AuthFeature Namespace Hi.Licenses Assembly HiDisp.dll Internal Use Only. public enum AuthFeature Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields AdvancedPhysics = 19 Advanced physics feature. CollisionDetectionNoLimit = 6 Collision detection with no limit feature. CubeTreeNoLimit = 2 CubeTree with no limit feature. CubeTreeStepLimit = 8 CubeTree with step limit feature. CuttingParameterConversion = 20 Cutting parameter conversion feature. FreeSwept = 13 Free swept feature. HiApi = 1 HiApi feature. HiApiSubstitute = 16 HiApi substitute feature. If no HiApi licensed, HiApiSubstitute takes the same effect. IsoCL = 5 IsoCL feature. IsoNC = 4 IsoNC feature. MillingForceNoLimit = 3 Milling force with no limit feature. MillingForceStepLimit = 17 Milling force with step limit feature. MtBuilder = 12 MtBuilder feature. NcComposition = 22 NC composition feature: registering external (non-built-in) processing units into the SoftNc pipeline, and executing NC-embedded C# scripts. Without it the built-in dialects run unchanged; external units are skipped with a diagnostic. OptNcNoLimit = 14 OptNc with no limit feature. PostProcessNoLimit = 7 Post process with no limit feature. SuppressDefaultLogo = 21 Suppress default logo feature."
  },
  "api/Hi.Licenses.AuthorizationFailedEventArgs.html": {
    "href": "api/Hi.Licenses.AuthorizationFailedEventArgs.html",
    "title": "Class AuthorizationFailedEventArgs | HiAPI-C# 2025",
    "summary": "Class AuthorizationFailedEventArgs Namespace Hi.Licenses Assembly HiDisp.dll Event arguments for authorization failure events. public class AuthorizationFailedEventArgs : EventArgs Inheritance object EventArgs AuthorizationFailedEventArgs Inherited Members EventArgs.Empty object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors AuthorizationFailedEventArgs() Initializes a new instance of the AuthorizationFailedEventArgs class. public AuthorizationFailedEventArgs() AuthorizationFailedEventArgs(string) Initializes a new instance of the AuthorizationFailedEventArgs class with a specified error message. public AuthorizationFailedEventArgs(string msg) Parameters msg string The error message associated with the authorization failure. Properties Msg Gets or sets the error message associated with the authorization failure. public string Msg { get; set; } Property Value string"
  },
  "api/Hi.Licenses.BlockType.html": {
    "href": "api/Hi.Licenses.BlockType.html",
    "title": "Enum BlockType | HiAPI-C# 2025",
    "summary": "Enum BlockType Namespace Hi.Licenses Assembly HiDisp.dll Block type. public enum BlockType Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields NoBlock = 0 No block. NoLicense = 2 No license. Block. ReachStepLimit = 1 Reach step limit. Block."
  },
  "api/Hi.Licenses.License.html": {
    "href": "api/Hi.Licenses.License.html",
    "title": "Class License | HiAPI-C# 2025",
    "summary": "Class License Namespace Hi.Licenses Assembly HiDisp.dll License of this module. public static class License Inheritance object License Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields CoreDll Core dll path. public const string CoreDll = \"core.dll\" Field Value string Methods AbortIfNotLoggedIn(AuthFeature) Aborts the application if a specific feature is not logged in. public static void AbortIfNotLoggedIn(AuthFeature feature) Parameters feature AuthFeature The feature to check. GetProducerInfo() Get Producer Info. public static string GetProducerInfo() Returns string Producer Info. IsFeatureAuth(AuthFeature) Checks if a specific feature is authorized. public static bool IsFeatureAuth(AuthFeature authFeature) Parameters authFeature AuthFeature The feature to check. Returns bool True if the feature is authorized; otherwise, false. IsLoggedIn(AuthFeature) Checks if a specific feature is logged in. public static bool IsLoggedIn(AuthFeature feature) Parameters feature AuthFeature The feature to check. Returns bool True if the feature is logged in; otherwise, false. LogInAll() Attempts to log in to all available features. public static List<AuthFeature> LogInAll() Returns List<AuthFeature> An enumeration of successfully logged in features. LogOut(AuthFeature) Logs out from a specific feature. public static void LogOut(AuthFeature feature) Parameters feature AuthFeature The feature to log out from. LogOutAll() Logs out from all features. public static void LogOutAll() Login(AuthFeature) Logs in to a specific feature. public static bool Login(AuthFeature feature) Parameters feature AuthFeature The feature to log in to. Returns bool True if login was successful; otherwise, false. SafelyEndLicenseRoutineCheck() Safely ends the license routine check. public static void SafelyEndLicenseRoutineCheck() Events AbortMessageAction Event handler for license abort events. public static event Action<string> AbortMessageAction Event Type Action<string>"
  },
  "api/Hi.Licenses.LicenseType.html": {
    "href": "api/Hi.Licenses.LicenseType.html",
    "title": "Enum LicenseType | HiAPI-C# 2025",
    "summary": "Enum LicenseType Namespace Hi.Licenses Assembly HiDisp.dll Defines the types of licenses available. public enum LicenseType Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields NoLicense = 0 No license available. StepLimit = 2 License with step limitations. UnInit = 3 License not initialized. Unlimit = 1 Unlimited license."
  },
  "api/Hi.Licenses.html": {
    "href": "api/Hi.Licenses.html",
    "title": "Namespace Hi.Licenses | HiAPI-C# 2025",
    "summary": "Namespace Hi.Licenses Classes AuthorizationFailedEventArgs Event arguments for authorization failure events. License License of this module. Enums AuthFeature Internal Use Only. BlockType Block type. LicenseType Defines the types of licenses available."
  },
  "api/Hi.Machining.FreeformRemover.html": {
    "href": "api/Hi.Machining.FreeformRemover.html",
    "title": "Class FreeformRemover | HiAPI-C# 2025",
    "summary": "Class FreeformRemover Namespace Hi.Machining Assembly HiMech.dll Represents a freeform cutting tool that can be used in machining operations. This cutter type supports complex geometries for both the noble (upper) part and the shaper (cutting) part. public class FreeformRemover : ICutter, IGetSweptable, IVolumeRemover, IAnchoredDisplayee, IDisplayee, ITopo, IGetAsmb, IGetAnchor, IGetTopoIndex, IGetAnchoredDisplayeeList, IGetFletchBuckle, IMakeXmlSource, IAbstractNote, IAnchoredCollidableStem, IAnchoredCollidableNode, IAnchoredCollidableBased, IExpandToBox3d, IDuplicate, IDisposable, IClearCache, INameNote Inheritance object FreeformRemover Implements ICutter IGetSweptable IVolumeRemover IAnchoredDisplayee IDisplayee ITopo IGetAsmb IGetAnchor IGetTopoIndex IGetAnchoredDisplayeeList IGetFletchBuckle IMakeXmlSource IAbstractNote IAnchoredCollidableStem IAnchoredCollidableNode IAnchoredCollidableBased IExpandToBox3d IDuplicate IDisposable IClearCache INameNote Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) CutterUtil.GetCutterBodyCoolingArea_mm2(ICutter) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) TopoDisplayeeUtil.Display(ITopo, Bind) TopoDisplayeeUtil.ExpandToBox3d(ITopo, Box3d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks The FreeformRemover class provides functionality for: Managing complex cutting tool geometries Supporting both spinning and non-spinning cutting operations Handling collision detection and display Managing tool assembly and anchoring Supporting XML serialization and deserialization Constructors FreeformRemover() Initializes a new instance. public FreeformRemover() Remarks This constructor initializes the cutter with default settings and creates the necessary anchors and topology bricks for both the noble and shaper parts. FreeformRemover(XElement, string, string, IProgress<IMessage>, object[]) Initializes a new instance from XML data. public FreeformRemover(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress, object[] res) Parameters src XElement The XML element containing the cutter data. baseDirectory string The base directory for resolving relative paths. relFile string The relative file path for resolving references. progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. res object[] Additional resources for initialization. Properties AbstractNote Gets a brief description of the cutter, including its height. public string AbstractNote { get; } Property Value string Remarks The abstract note includes the cutter type and its height dimension, formatted as \"Freeform-H{this.GetBox3d().Dim.Z}\". CollidableName Gets the name used for collision detection purposes. public string CollidableName { get; } Property Value string CutterTip Gets the cutter tip anchor point. On the same location of GeomAnchor. public Anchor CutterTip { get; } Property Value Anchor Remarks The cutter tip represents the reference point for the cutting edge or surface. This point is used for positioning and orientation calculations during machining operations. GeomAnchor StrutGeom and ShaperGeom locate on this anchor. On the same location of CutterTip. public Anchor GeomAnchor { get; } Property Value Anchor GeomToHolderBranch Gets the branch that transforms from GeomAnchor to Hi.Machining.FreeformRemover.HolderBuckle. public Branch GeomToHolderBranch { get; } Property Value Branch GeomToHolderTransformer Gets or sets the transformer from GeomAnchor to Hi.Machining.FreeformRemover.HolderBuckle. public ITransformer GeomToHolderTransformer { get; set; } Property Value ITransformer IsSpinningCutter Gets or sets a value indicating whether this is a spinning cutting tool. public bool IsSpinningCutter { get; set; } Property Value bool Remarks This property affects how the cutter interacts with the workpiece during machining operations. Spinning cutters typically perform rotary cutting operations, while non-spinning cutters may be used for other types of machining. KeepHolderBuckleOnTop When true, automatically translates the holder buckle to be above the highest geometry point. public bool KeepHolderBuckleOnTop { get; set; } Property Value bool Name Name. public string Name { get; set; } Property Value string Note Note. public string Note { get; set; } Property Value string ShaperGeom Gets or sets the shaper (cutting) part geometry of the cutter. public IGetStl ShaperGeom { get; set; } Property Value IGetStl Remarks The shaper geometry represents the cutting portion of the tool that directly interacts with the workpiece during machining operations. ShaperTopoBrick Gets the topology brick representing the shaper (cutting) part of the cutter. public ITopoBrick ShaperTopoBrick { get; } Property Value ITopoBrick StrutGeom Gets or sets the strut (upper) part geometry of the cutter. public IGetStl StrutGeom { get; set; } Property Value IGetStl Remarks The noble geometry represents the non-cutting portion of the tool, typically including the tool holder and shank. This geometry is important for collision checking and visualization. StrutTopoBrick Gets the topology brick representing the upper (noble) part of the cutter. public ITopoBrick StrutTopoBrick { get; } Property Value ITopoBrick XName Name for XML IO. public static string XName { get; } Property Value string Methods ClearCache() Clears all cached data associated with the cutter. public void ClearCache() Remarks This includes clearing the cached sweptable and solid representations of both the noble and shaper parts of the cutter. Display(Bind) Displays the cutter using the provided binding context. public void Display(Bind bind) Parameters bind Bind The binding context for display operations. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) Releases the unmanaged resources and optionally releases the managed resources. protected virtual void Dispose(bool disposing) Parameters disposing bool true to release both managed and unmanaged resources; false to release only unmanaged resources. Duplicate(params object[]) Creates a deep copy of the current instance. public object Duplicate(params object[] res) Parameters res object[] Additional resources for duplication. Returns object A new instance with copied geometry data. ExpandToBox3d(Box3d) Expands the given bounding box to include the cutter's geometry. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d The bounding box to expand. GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor GetAnchoredCollidableNode() Gets the anchored collidable node associated with this object. public IAnchoredCollidableNode GetAnchoredCollidableNode() Returns IAnchoredCollidableNode The anchored collidable node. GetAnchoredCollidables() Gets the list of anchored collidable nodes contained by this stem. public List<IAnchoredCollidableNode> GetAnchoredCollidables() Returns List<IAnchoredCollidableNode> A list of anchored collidable nodes. GetAnchoredDisplayeeList() Gets a list of anchored displayable objects. public List<IAnchoredDisplayee> GetAnchoredDisplayeeList() Returns List<IAnchoredDisplayee> A list of IAnchoredDisplayee objects GetAsmb() Gets the key asmb. public Asmb GetAsmb() Returns Asmb The key asmb. GetFletchBuckle() Get fletch buckle anchor. the anchor that generally connect to fixed part such as ground and triggering(motor)-side. public Anchor GetFletchBuckle() Returns Anchor buckle anchor GetShaperDisplayee() Gets the shaper displayee for visualization purposes. public IAnchoredDisplayee GetShaperDisplayee() Returns IAnchoredDisplayee An IAnchoredDisplayee representing the shaper (cutting) part of the cutter. Remarks This method creates a display representation of the shaper geometry, which can be either the raw geometry if it implements IDisplayee, or the topology brick representation. GetStrutAnchoredDisplayee() Gets the noble (upper) part displayee for visualization purposes. public AnchoredDisplayee GetStrutAnchoredDisplayee() Returns AnchoredDisplayee An AnchoredDisplayee representing the noble part of the cutter with modified display properties. Remarks This method creates a display representation of the noble geometry with slightly darker coloring to distinguish it from the shaper part during visualization. GetSweptable(double) Gets the sweptable representation of the cutter for swept volume calculations. public Sweptable GetSweptable(double fractionTolerance) Parameters fractionTolerance double The tolerance value for swept volume calculations. Returns Sweptable A Sweptable object representing the cutter's swept volume, or null if the shaper geometry is not available. Remarks The sweptable representation is cached for performance. Use ClearCache to reset the cached data. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Machining.ICutter.html": {
    "href": "api/Hi.Machining.ICutter.html",
    "title": "Interface ICutter | HiAPI-C# 2025",
    "summary": "Interface ICutter Namespace Hi.Machining Assembly HiMech.dll Interface of cutter. public interface ICutter : IGetSweptable, IVolumeRemover, IAnchoredDisplayee, IDisplayee, ITopo, IGetAsmb, IGetAnchor, IGetTopoIndex, IGetAnchoredDisplayeeList, IGetFletchBuckle, IMakeXmlSource, IAbstractNote, IAnchoredCollidableStem, IAnchoredCollidableNode, IAnchoredCollidableBased, IExpandToBox3d, IDuplicate, IDisposable, IClearCache, INameNote Inherited Members IGetSweptable.GetSweptable(double) IDisplayee.Display(Bind) IGetAsmb.GetAsmb() IGetAnchor.GetAnchor() IGetAnchoredDisplayeeList.GetAnchoredDisplayeeList() IGetFletchBuckle.GetFletchBuckle() IMakeXmlSource.MakeXmlSource(string, string, bool) IAbstractNote.AbstractNote IAnchoredCollidableStem.GetAnchoredCollidables() IAnchoredCollidableBased.CollidableName IAnchoredCollidableBased.GetAnchoredCollidableNode() IExpandToBox3d.ExpandToBox3d(Box3d) IDuplicate.Duplicate(params object[]) IDisposable.Dispose() IClearCache.ClearCache() INameNote.Name INameNote.Note Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) CutterUtil.GetCutterBodyCoolingArea_mm2(ICutter) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) TopoDisplayeeUtil.Display(ITopo, Bind) TopoDisplayeeUtil.ExpandToBox3d(ITopo, Box3d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties CutterThemeColor The default theme color for cutter body visualization. public static Vec3d CutterThemeColor { get; } Property Value Vec3d CutterTip Gets the anchor point representing the tip of the cutter. Anchor CutterTip { get; } Property Value Anchor The anchor point at the cutter tip, or null if the shaper topology brick is not available. Remarks The cutter tip is the reference point for the cutting tool, typically located at the end of the shaper part. This point is used for positioning and orientation calculations during machining operations. IsSpinningCutter Is cutter spining when machining. bool IsSpinningCutter { get; } Property Value bool Is cutter spining when machining. ShankThemeColor The default theme color for shank visualization. public static Vec3d ShankThemeColor { get; } Property Value Vec3d ShaperTopoBrick cutable part of cutter. the part cut the workpiece if overlapped. ITopoBrick ShaperTopoBrick { get; } Property Value ITopoBrick StrutTopoBrick uncutable part of cutter. the part triggers collision to workpiece if overlapped. ITopoBrick StrutTopoBrick { get; } Property Value ITopoBrick"
  },
  "api/Hi.Machining.ICutterAnchorable.html": {
    "href": "api/Hi.Machining.ICutterAnchorable.html",
    "title": "Interface ICutterAnchorable | HiAPI-C# 2025",
    "summary": "Interface ICutterAnchorable Namespace Hi.Machining Assembly HiMech.dll IGetAnchor of cutter. [Obsolete] public interface ICutterAnchorable : IGetSweptable, IVolumeRemover, IGetAnchor, IGetTopoIndex Inherited Members IGetSweptable.GetSweptable(double) IGetAnchor.GetAnchor() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Machining.IGetSweptable.html": {
    "href": "api/Hi.Machining.IGetSweptable.html",
    "title": "Interface IGetSweptable | HiAPI-C# 2025",
    "summary": "Interface IGetSweptable Namespace Hi.Machining Assembly HiCbtr.dll Interface of Get Sweptable. public interface IGetSweptable : IVolumeRemover Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetSweptable(double) Get Sweptable. Sweptable GetSweptable(double fractionTolerance) Parameters fractionTolerance double The fraction tolerance for the sweptable. Returns Sweptable Sweptable"
  },
  "api/Hi.Machining.IMachiningTool.html": {
    "href": "api/Hi.Machining.IMachiningTool.html",
    "title": "Interface IMachiningTool | HiAPI-C# 2025",
    "summary": "Interface IMachiningTool Namespace Hi.Machining Assembly HiMech.dll Interface for machining tools that combine a holder and a cutter. public interface IMachiningTool : IDisplayee, IExpandToBox3d, ITopo, IGetAsmb, IGetAnchor, IGetTopoIndex, IGetAnchoredDisplayeeList, IGetFletchBuckle, IMakeXmlSource, IAbstractNote, IDuplicate, IClearCache, IGetFluteNum Inherited Members IDisplayee.Display(Bind) IExpandToBox3d.ExpandToBox3d(Box3d) IGetAsmb.GetAsmb() IGetAnchor.GetAnchor() IGetAnchoredDisplayeeList.GetAnchoredDisplayeeList() IGetFletchBuckle.GetFletchBuckle() IMakeXmlSource.MakeXmlSource(string, string, bool) IAbstractNote.AbstractNote IDuplicate.Duplicate(params object[]) IClearCache.ClearCache() IGetFluteNum.GetFluteNum() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MillingToolUtil.GetFullH(IMachiningTool) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) TopoDisplayeeUtil.Display(ITopo, Bind) TopoDisplayeeUtil.ExpandToBox3d(ITopo, Box3d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Cutter Gets the cutting tool. ICutter Cutter { get; } Property Value ICutter ExposedCutterBendingPara_umdN Gets the exposed cutter bending parameter in micrometers per Newton. double ExposedCutterBendingPara_umdN { get; } Property Value double ExposedCutterHeight_mm Gets or sets the exposed cutter height in millimeters. double ExposedCutterHeight_mm { get; set; } Property Value double ExposedCutterZDeflectionPara_umdN Gets the exposed cutter Z-axis deflection parameter in micrometers per Newton. double ExposedCutterZDeflectionPara_umdN { get; } Property Value double Holder Gets the tool holder. IHolder Holder { get; } Property Value IHolder Note Gets or sets the note for this machining tool. string Note { get; set; } Property Value string SpindleBuckleToToolTipLength Gets the length from spindle buckle to tool tip in millimeters. double SpindleBuckleToToolTipLength { get; } Property Value double ToolTip Gets the tool tip anchor point. Anchor ToolTip { get; } Property Value Anchor"
  },
  "api/Hi.Machining.IVolumeRemover.html": {
    "href": "api/Hi.Machining.IVolumeRemover.html",
    "title": "Interface IVolumeRemover | HiAPI-C# 2025",
    "summary": "Interface IVolumeRemover Namespace Hi.Machining Assembly HiCbtr.dll Only inherit from IGetInitStickConvex and IGetSweptable. public interface IVolumeRemover Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Machining.MachiningEquipmentUtils.CollidableComponentEnum.html": {
    "href": "api/Hi.Machining.MachiningEquipmentUtils.CollidableComponentEnum.html",
    "title": "Enum CollidableComponentEnum | HiAPI-C# 2025",
    "summary": "Enum CollidableComponentEnum Namespace Hi.Machining.MachiningEquipmentUtils Assembly HiMech.dll Defines the components of a machining setup that can participate in collision detection. public enum CollidableComponentEnum Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields CutterFlute = 4 Cutter Flute. CutterShank = 3 Cutter Shank. Fixture = 1 Fixture. ToolHolder = 2 Tool Holder. Workpiece = 0 Workpiece."
  },
  "api/Hi.Machining.MachiningEquipmentUtils.IGetMachiningEquipment.html": {
    "href": "api/Hi.Machining.MachiningEquipmentUtils.IGetMachiningEquipment.html",
    "title": "Interface IGetMachiningEquipment | HiAPI-C# 2025",
    "summary": "Interface IGetMachiningEquipment Namespace Hi.Machining.MachiningEquipmentUtils Assembly HiMech.dll Interface for objects that can provide access to a machining equipment instance. public interface IGetMachiningEquipment Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetMachiningEquipment() Get the runtime MachiningEquipment. MachiningEquipment GetMachiningEquipment() Returns MachiningEquipment MachiningEquipment"
  },
  "api/Hi.Machining.MachiningEquipmentUtils.IMachiningEquipment.html": {
    "href": "api/Hi.Machining.MachiningEquipmentUtils.IMachiningEquipment.html",
    "title": "Interface IMachiningEquipment | HiAPI-C# 2025",
    "summary": "Interface IMachiningEquipment Namespace Hi.Machining.MachiningEquipmentUtils Assembly HiMech.dll Machining equipment — implemented by both topology faces of the equipment split: the authored SetupEquipment and the runtime MachiningEquipment. XML IO is NOT part of this contract — only the authored face serializes. public interface IMachiningEquipment : IDisplayee, IExpandToBox3d, IGetAnchoredDisplayeeList, IGetProgramCl, IGetAsmb, IGetAnchor, IGetTopoIndex, IGetMachiningChain Inherited Members IDisplayee.Display(Bind) IExpandToBox3d.ExpandToBox3d(Box3d) IGetAnchoredDisplayeeList.GetAnchoredDisplayeeList() IGetProgramCl.GetProgramCl() IGetAsmb.GetAsmb() IGetAnchor.GetAnchor() IGetMachiningChain.GetMachiningChain() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MachiningEquipmentUtil.AlignWorkpieceProgramZeroToIso(IMachiningEquipment, Vec3d) MachiningEquipmentUtil.GetIsoCoordinatePosition(IMachiningEquipment, Vec3d) MachiningEquipmentUtil.GetMachinePositionAtProgramZero(IMachiningEquipment) MachiningEquipmentUtil.GetMachinePositionAtTableBuckleZero(IMachiningEquipment) MachiningEquipmentUtil.GetProgramToPnMat4d(IMachiningEquipment) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Fixture Fixture of workpiece. Fixture Fixture { get; set; } Property Value Fixture MachiningTool Milling tool. IMachiningTool MachiningTool { get; set; } Property Value IMachiningTool TableToComp Component transformation from table. ITransformer TableToComp { get; set; } Property Value ITransformer Workpiece Workpiece. Workpiece Workpiece { get; set; } Property Value Workpiece WorkpieceDisplayee Displayee for workpiece rendering. Set by the runtime service layer. IDisplayee WorkpieceDisplayee { get; set; } Property Value IDisplayee"
  },
  "api/Hi.Machining.MachiningEquipmentUtils.MachiningEquipment.html": {
    "href": "api/Hi.Machining.MachiningEquipmentUtils.MachiningEquipment.html",
    "title": "Class MachiningEquipment | HiAPI-C# 2025",
    "summary": "Class MachiningEquipment Namespace Hi.Machining.MachiningEquipmentUtils Assembly HiMech.dll The runtime (execution) face of the machining equipment: the topology instance the runner drives — tool-change graph surgery, collision detection, live axis poses. Materialised from the authored face (MaterialiseMachiningEquipment(string, IProgress<IMessage>)) and NEVER serialized: runtime data cannot reach the project file by construction. public class MachiningEquipment : IMachiningEquipment, IDisplayee, IExpandToBox3d, IGetAnchoredDisplayeeList, IGetProgramCl, IGetAsmb, IGetAnchor, IGetTopoIndex, IGetMachiningChain, IGetMachiningEquipment Inheritance object MachiningEquipment Implements IMachiningEquipment IDisplayee IExpandToBox3d IGetAnchoredDisplayeeList IGetProgramCl IGetAsmb IGetAnchor IGetTopoIndex IGetMachiningChain IGetMachiningEquipment Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) MachiningEquipmentUtil.AlignWorkpieceProgramZeroToIso(IMachiningEquipment, Vec3d) MachiningEquipmentUtil.GetIsoCoordinatePosition(IMachiningEquipment, Vec3d) MachiningEquipmentUtil.GetMachinePositionAtProgramZero(IMachiningEquipment) MachiningEquipmentUtil.GetMachinePositionAtTableBuckleZero(IMachiningEquipment) MachiningEquipmentUtil.GetProgramToPnMat4d(IMachiningEquipment) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MachiningEquipment() Ctor. public MachiningEquipment() Properties Asmb Asmb of the entire equipment. public Asmb Asmb { get; } Property Value Asmb BackgroundTemperature_C Gets or sets the background temperature in Celsius. This is a convenience property that converts between Celsius and Kelvin. public double BackgroundTemperature_C { get; set; } Property Value double BackgroundTemperature_K Gets or sets the background temperature in Kelvin. Runtime-stamped from the authored face at materialise; the authored value's home is BackgroundTemperature_K. public double BackgroundTemperature_K { get; set; } Property Value double CoolantHeatCondition Gets or sets the coolant heat condition settings. Runtime-stamped from the authored face at materialise (shared reference — the runtime only reads it); the authored home is CoolantHeatCondition. public CoolantHeatCondition CoolantHeatCondition { get; set; } Property Value CoolantHeatCondition Fixture Fixture. public Fixture Fixture { get; set; } Property Value Fixture MachiningChain Body of the equipment. public IMachiningChain MachiningChain { get; set; } Property Value IMachiningChain MachiningTool Milling tool. public IMachiningTool MachiningTool { get; set; } Property Value IMachiningTool SpindleCapability Gets or sets the spindle capability configuration. Runtime-stamped from the authored face at materialise (shared reference — the runtime only reads it); the authored home is SpindleCapability. public SpindleCapability SpindleCapability { get; set; } Property Value SpindleCapability TableToComp Transformer of the branch from table buckle to workpiece side buckle. Note that the workpiece side buckle links to Fixture if fixture exist; otherwise, it links to Workpiece if workpiece exist. If Workpiece either Fixture do not exist, this property makes no effect. public ITransformer TableToComp { get; set; } Property Value ITransformer Workpiece Workpiece. public Workpiece Workpiece { get; set; } Property Value Workpiece WorkpieceDisplayee Displayee for workpiece rendering. Set by the runtime service layer. public IDisplayee WorkpieceDisplayee { get; set; } Property Value IDisplayee Methods Detect(bool) Performs collision detection. public MechCollisionResult Detect(bool addFluteAndWorkpieceDetection) Parameters addFluteAndWorkpieceDetection bool Whether to include flute and workpiece in detection. Returns MechCollisionResult Significant collision result. Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor GetAnchoredDisplayeeList() Gets a list of anchored displayable objects. public List<IAnchoredDisplayee> GetAnchoredDisplayeeList() Returns List<IAnchoredDisplayee> A list of IAnchoredDisplayee objects GetAsmb() Gets the key asmb. public Asmb GetAsmb() Returns Asmb The key asmb. GetMachiningChain() Gets the machining chain instance. public IMachiningChain GetMachiningChain() Returns IMachiningChain The machining chain instance. GetMachiningEquipment() Get the runtime MachiningEquipment. public MachiningEquipment GetMachiningEquipment() Returns MachiningEquipment MachiningEquipment GetProgramCl() Get CL (Cutter Location). Where Point is tool tip position; Normal is tool orientation. public DVec3d GetProgramCl() Returns DVec3d CL GetToolTipXyzOnProgramZero() Get tool tip xyz from workpiece geom anchor. public Vec3d GetToolTipXyzOnProgramZero() Returns Vec3d if no MachiningTool or no Workpiece equiping, return null; otherwise, return the XYZ from workpiece geomanchor to tool tip. GetTransformFromRootToProgramZero() Gets the transform matrix from the root coordinate system to the program zero coordinate system. public Mat4d GetTransformFromRootToProgramZero() Returns Mat4d A 4x4 transformation matrix representing the coordinate system transformation. IsCollisionRed(object) Whether the latest Detect(bool) pass flagged item as colliding. Display paths use this through CollisionRedScope to paint the part red. public bool IsCollisionRed(object item) Parameters item object A displayed item (typically a Solid). Returns bool true if the item is currently collision-red. PrepareCollidableItems() Prepares all collidable items for collision detection. This method should be called before performing collision detection. public void PrepareCollidableItems() ResetCollisionFlags() Resets all collision flags to their default states. This should be called after collision detection is complete, and by a runtime reset so no part stays painted red. public void ResetCollisionFlags() Tooling(int, MachiningToolHouse) Set MachiningTool by toolId and toolHouse. public bool Tooling(int toolId, MachiningToolHouse toolHouse) Parameters toolId int tool ID toolHouse MachiningToolHouse tool house Returns bool true if tool changed; otherwise, false. Exceptions ToolNotFoundException Throw If toolId does not exist on toolHouse."
  },
  "api/Hi.Machining.MachiningEquipmentUtils.MachiningEquipmentCollisionIndex.html": {
    "href": "api/Hi.Machining.MachiningEquipmentUtils.MachiningEquipmentCollisionIndex.html",
    "title": "Class MachiningEquipmentCollisionIndex | HiAPI-C# 2025",
    "summary": "Class MachiningEquipmentCollisionIndex Namespace Hi.Machining.MachiningEquipmentUtils Assembly HiMech.dll Represents a collision index for machining equipment components. This class manages collision detection between different parts of the machining equipment. public class MachiningEquipmentCollisionIndex : ICollisionIndex, IGetCollidable, IMakeXmlSource, IToXElement Inheritance object MachiningEquipmentCollisionIndex Implements ICollisionIndex IGetCollidable IMakeXmlSource IToXElement Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MachiningEquipmentCollisionIndex(MachiningEquipment, string) Initializes a new instance of the MachiningEquipmentCollisionIndex class with the specified equipment and key. public MachiningEquipmentCollisionIndex(MachiningEquipment equipment, string key) Parameters equipment MachiningEquipment The machining equipment to associate with this collision index. key string The key identifying the component in the collision system. MachiningEquipmentCollisionIndex(string) Initializes a new instance of the MachiningEquipmentCollisionIndex class with the specified key. public MachiningEquipmentCollisionIndex(string key) Parameters key string The key identifying the component in the collision system. MachiningEquipmentCollisionIndex(XElement, IGetMachiningEquipment) Initializes a new instance of the MachiningEquipmentCollisionIndex class from XML data. public MachiningEquipmentCollisionIndex(XElement src, IGetMachiningEquipment equipment) Parameters src XElement The XML element containing the collision index configuration. equipment IGetMachiningEquipment The equipment provider interface. Fields XName Gets the XML element name for serialization. public static string XName Field Value string Properties Anchor Gets the anchor point for the component identified by this index. public Anchor Anchor { get; } Property Value Anchor Remarks The anchor point returned depends on the component key: Workpiece: Geometry anchor Fixture: Geometry anchor ToolHolder: Root anchor of the holder CutterShank: Root anchor of the upper beam topo brick CutterFlute: Root anchor of the shaper topo brick Other: Machine tool component anchor Equipment Gets or sets the machining equipment associated with this collision index. When set, updates the component anchor and collidable based on the equipment's solid machining chain. public IMachiningEquipment Equipment { get; set; } Property Value IMachiningEquipment Key Gets the key identifying the component in the collision system. public string Key { get; } Property Value string WorkpieceMeshedGeomGetter Getter for meshed geometry of the workpiece. Set by the service layer. public Func<CubeTree> WorkpieceMeshedGeomGetter { get; set; } Property Value Func<CubeTree> Methods Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. GetCollidable() Gets the collidable object for the component identified by this index. public ICollidable GetCollidable() Returns ICollidable The collidable object representing the component's geometry. The type of collidable returned depends on the component key: Workpiece: Meshed geometry Fixture: Solid collidable ToolHolder: Cylindroid or freeform holder solid CutterShank: Upper beam topo brick solid CutterFlute: Shaper topo brick solid Other: Machine tool component collidable GetHashCode() Gets a hash code for the current object. public override int GetHashCode() Returns int A hash code for the current object. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.Machining.MachiningEquipmentUtils.MachiningEquipmentCollisionIndexPairsSource.html": {
    "href": "api/Hi.Machining.MachiningEquipmentUtils.MachiningEquipmentCollisionIndexPairsSource.html",
    "title": "Class MachiningEquipmentCollisionIndexPairsSource | HiAPI-C# 2025",
    "summary": "Class MachiningEquipmentCollisionIndexPairsSource Namespace Hi.Machining.MachiningEquipmentUtils Assembly HiMech.dll Source of CollisionIndexPair. The adjacent solids will not be added to the CollisionIndexPairs. public class MachiningEquipmentCollisionIndexPairsSource : ICollisionIndexPairsSource, IGetCollisionIndexPairs, IMakeXmlSource Inheritance object MachiningEquipmentCollisionIndexPairsSource Implements ICollisionIndexPairsSource IGetCollisionIndexPairs IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MachiningEquipmentCollisionIndexPairsSource(IMachiningChain, HashSet<CollisionIndexPair>) Initializes a new instance of the MachiningEquipmentCollisionIndexPairsSource class with a specified machining chain and excluded pairs. public MachiningEquipmentCollisionIndexPairsSource(IMachiningChain src, HashSet<CollisionIndexPair> excludedPairs) Parameters src IMachiningChain The solid machining chain to build collision pairs from. excludedPairs HashSet<CollisionIndexPair> The set of collision pairs to exclude from collision detection. Remarks This constructor builds the default collision index pairs from the provided machining chain and removes the specified excluded pairs from consideration. MachiningEquipmentCollisionIndexPairsSource(IMachiningChain, string) Initializes a new instance of the MachiningEquipmentCollisionIndexPairsSource class with a specified machining chain and excluded pairs string. public MachiningEquipmentCollisionIndexPairsSource(IMachiningChain src, string excludedPairsString = \"\") Parameters src IMachiningChain The solid machining chain to build collision pairs from. excludedPairsString string A string representation of collision pairs to exclude, in the format \"[Key1][Key2];[Key3][Key4]\". Remarks This constructor builds the default collision index pairs from the provided machining chain and removes the pairs specified in the excludedPairsString from consideration. MachiningEquipmentCollisionIndexPairsSource(XElement, IGetMachiningChain) Initializes a new instance of the MachiningEquipmentCollisionIndexPairsSource class from XML data. public MachiningEquipmentCollisionIndexPairsSource(XElement src, IGetMachiningChain res) Parameters src XElement The XML element containing the collision index pairs configuration. res IGetMachiningChain The solid machining chain reference used to build default index pairs. Fields XName Gets the XML element name used for serialization. public static string XName Field Value string Methods GetCollisionIndexPairs() Gets a collection of collision index pairs for collision detection. public IEnumerable<CollisionIndexPair> GetCollisionIndexPairs() Returns IEnumerable<CollisionIndexPair> A collection of CollisionIndexPair objects. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Static constructor that initializes XML serialization support. public static void Reg(XFactory factory = null) Parameters factory XFactory Remarks Registers the XML factory for deserializing MachiningEquipmentCollisionIndexPairsSource instances and ensures required XML element names are initialized."
  },
  "api/Hi.Machining.MachiningEquipmentUtils.MachiningEquipmentUtil.html": {
    "href": "api/Hi.Machining.MachiningEquipmentUtils.MachiningEquipmentUtil.html",
    "title": "Class MachiningEquipmentUtil | HiAPI-C# 2025",
    "summary": "Class MachiningEquipmentUtil Namespace Hi.Machining.MachiningEquipmentUtils Assembly HiMech.dll Utility methods for working with machining equipment. public static class MachiningEquipmentUtil Inheritance object MachiningEquipmentUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods AlignWorkpieceProgramZeroToIso(IMachiningEquipment, Vec3d) Places Fixture under the kinematic chain so that ProgramZeroAnchor coincides with the world position the spindle reaches when the machine coordinate equals isoOffset (a G54/G55/… entry). Other anchors (FixtureBuckle, ProgramZeroAnchor, WorkpieceBuckle) must already be at their intended geometric positions (typically via the buckle “general rule”: bottom/top centers of geom). Only GeomToTableTransformer is mutated. Returns the assigned translation, or null when workpiece / fixture / Xyzabc machine tool is missing. The alignment is computed in the machine-coordinate (MC) zero state: the assembly is reflected and every IDynamicRegular axis is set to Step = 0 before querying displacements. The live equipment may have its axes moved, which would otherwise distort the ToolBuckle -> FixtureTableBuckle leg (it crosses the X/Y/Z/A/B/C axes) and break the vector-chain assumption that the legs share a common orientation — isoOffset is itself an MC-zero quantity. public static Vec3d AlignWorkpieceProgramZeroToIso(this IMachiningEquipment equipment, Vec3d isoOffset) Parameters equipment IMachiningEquipment isoOffset Vec3d Returns Vec3d GetIsoCoordinatePosition(IMachiningEquipment, Vec3d) Get ISO coordinate position from the g54seriesOffset. public static Vec3d GetIsoCoordinatePosition(this IMachiningEquipment equipment, Vec3d g54seriesOffset) Parameters equipment IMachiningEquipment g54seriesOffset Vec3d Returns Vec3d GetMachinePositionAtProgramZero(IMachiningEquipment) Gets the machine coordinate when the attacher is at program zero. The machine coordinate are all assumed to be zero. public static Vec3d GetMachinePositionAtProgramZero(this IMachiningEquipment equipment) Parameters equipment IMachiningEquipment The machining equipment. Returns Vec3d The machine coordinate vector. GetMachinePositionAtTableBuckleZero(IMachiningEquipment) Gets the machine coordinate when the attacher is at table buckle zero. public static Vec3d GetMachinePositionAtTableBuckleZero(this IMachiningEquipment equipment) Parameters equipment IMachiningEquipment The machining equipment. Returns Vec3d The machine coordinate vector. GetProgramToPnMat4d(IMachiningEquipment) Gets the rigid transform that maps a point in program (workpiece) coordinates — the ProgramZeroAnchor frame — into the kinematic Pn frame (the chain's table-buckle anchor frame that XyzabcSolver solves in). Both anchors live on the same rigid table-side subtree (the table-buckle→fixture→workpiece leg crosses no machine axis), so the transform is pose-independent and is queried on the live assembly — no MC-zero reflection needed (this runs per parsed motion block; a whole-assembly TopoReflection clone here would dominate large-file parse time). Falls back to identity (program frame ≡ table-buckle frame) when the workpiece has no ProgramZeroAnchor; returns null when the chain has no table buckle. public static Mat4d GetProgramToPnMat4d(this IMachiningEquipment equipment) Parameters equipment IMachiningEquipment The machining equipment. Returns Mat4d The program→Pn transform, or null."
  },
  "api/Hi.Machining.MachiningEquipmentUtils.SetupEquipment.html": {
    "href": "api/Hi.Machining.MachiningEquipmentUtils.SetupEquipment.html",
    "title": "Class SetupEquipment | HiAPI-C# 2025",
    "summary": "Class SetupEquipment Namespace Hi.Machining.MachiningEquipmentUtils Assembly HiMech.dll The authored (setup) face of the machining equipment: the machine chain, workpiece, fixture, environment data and the Setup-page tool selection, with the project XML IO. This is the ONLY face that persists — the runtime face (MachiningEquipment) is materialised from it and never serialized, so a mid-run save can no longer write live poses or the runner-equipped tool into the project file. The XML wire name stays \"MachiningEquipment\" (see XName): shipped project files keep their layout, only the deserialized object changed. public class SetupEquipment : IMachiningEquipment, IDisplayee, IExpandToBox3d, IGetAnchoredDisplayeeList, IGetProgramCl, IGetAsmb, IGetAnchor, IGetTopoIndex, IGetMachiningChain, IMakeXmlSource Inheritance object SetupEquipment Implements IMachiningEquipment IDisplayee IExpandToBox3d IGetAnchoredDisplayeeList IGetProgramCl IGetAsmb IGetAnchor IGetTopoIndex IGetMachiningChain IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) MachiningEquipmentUtil.AlignWorkpieceProgramZeroToIso(IMachiningEquipment, Vec3d) MachiningEquipmentUtil.GetIsoCoordinatePosition(IMachiningEquipment, Vec3d) MachiningEquipmentUtil.GetMachinePositionAtProgramZero(IMachiningEquipment) MachiningEquipmentUtil.GetMachinePositionAtTableBuckleZero(IMachiningEquipment) MachiningEquipmentUtil.GetProgramToPnMat4d(IMachiningEquipment) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SetupEquipment() Ctor. public SetupEquipment() SetupEquipment(XElement, string, string, IProgress<IMessage>) Initializes a new instance of the SetupEquipment class from XML data. public SetupEquipment(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress) Parameters src XElement The XML element containing the equipment configuration. baseDirectory string The base directory for resolving relative file paths. relFile string The relative file path for XML serialization. progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. Properties Asmb Asmb of the entire authored equipment topology. public Asmb Asmb { get; } Property Value Asmb BackgroundTemperature_C Gets or sets the background temperature in Celsius. This is a convenience property that converts between Celsius and Kelvin. public double BackgroundTemperature_C { get; set; } Property Value double BackgroundTemperature_K Gets or sets the background temperature in Kelvin. This represents the ambient temperature of the machining environment. public double BackgroundTemperature_K { get; set; } Property Value double CoolantHeatCondition Gets or sets the coolant heat condition settings. This includes coolant temperature and heat transfer coefficients. public CoolantHeatCondition CoolantHeatCondition { get; set; } Property Value CoolantHeatCondition CoolantHeatConditionFile Gets or sets the file path of the coolant heat condition (WorkpieceMaterial pattern: when set, XML IO externalizes CoolantHeatCondition to this side-file; when null the condition serializes inline). public string CoolantHeatConditionFile { get; set; } Property Value string Fixture Fixture. public Fixture Fixture { get; set; } Property Value Fixture MachiningChain Body of the equipment — the authored machine topology instance. The runtime face gets its own instance from MaterialiseMachiningEquipment(string, IProgress<IMessage>); the two never share graph objects (only leaf Solid geometry is shared). public IMachiningChain MachiningChain { get; set; } Property Value IMachiningChain MachiningChainFile Gets or sets the file path of the solid machining chain. This is used for XML serialization and file management. public string MachiningChainFile { get; set; } Property Value string MachiningTool The Setup-page selected tool (persisted as the project's <MillingTool>). Never the tool-house instance itself — see Tooling(int, MachiningToolHouse). public IMachiningTool MachiningTool { get; set; } Property Value IMachiningTool SpindleCapability Gets or sets the spindle capability configuration. This defines the operational capabilities and limits of the spindle. public SpindleCapability SpindleCapability { get; set; } Property Value SpindleCapability SpindleCapabilityFile Gets or sets the file path of the spindle capability configuration. This is used for XML serialization and file management. public string SpindleCapabilityFile { get; set; } Property Value string TableToComp Transformer of the branch from table buckle to workpiece side buckle. Note that the workpiece side buckle links to Fixture if fixture exist; otherwise, it links to Workpiece if workpiece exist. If Workpiece either Fixture do not exist, this property makes no effect. public ITransformer TableToComp { get; set; } Property Value ITransformer Workpiece Workpiece. public Workpiece Workpiece { get; set; } Property Value Workpiece WorkpieceDisplayee Displayee for workpiece rendering. Optional on the authored face — setup views typically draw the workpiece through their own display composition instead. public IDisplayee WorkpieceDisplayee { get; set; } Property Value IDisplayee XName Name for XML IO. Pinned to the shipped wire name “MachiningEquipment” — the type was split off the runtime face, the file layout was not. public static string XName { get; } Property Value string Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor GetAnchoredDisplayeeList() Gets a list of anchored displayable objects. public List<IAnchoredDisplayee> GetAnchoredDisplayeeList() Returns List<IAnchoredDisplayee> A list of IAnchoredDisplayee objects GetAsmb() Gets the key asmb. public Asmb GetAsmb() Returns Asmb The key asmb. GetMachiningChain() Gets the machining chain instance. public IMachiningChain GetMachiningChain() Returns IMachiningChain The machining chain instance. GetProgramCl() Get CL (Cutter Location). Where Point is tool tip position; Normal is tool orientation. public DVec3d GetProgramCl() Returns DVec3d CL GetToolTipXyzOnProgramZero() Get tool tip xyz from workpiece geom anchor. public Vec3d GetToolTipXyzOnProgramZero() Returns Vec3d if no MachiningTool or no Workpiece equiping, return null; otherwise, return the XYZ from workpiece geomanchor to tool tip. GetTransformFromRootToProgramZero() Gets the transform matrix from the root coordinate system to the program zero coordinate system. public Mat4d GetTransformFromRootToProgramZero() Returns Mat4d A 4x4 transformation matrix representing the coordinate system transformation. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. MaterialiseMachiningEquipment(string, IProgress<IMessage>) Builds the runtime face from this authored face: a fresh MachiningEquipment whose topology is an XML round-trip copy of this one (chain, fixture, workpiece, table transformer, tool), with the heavy machine-body and fixture Solid instances SHARED (this face keeps their lifecycle), axis poses copied, and the environment data stamped by reference. Information flows one way: the returned instance never writes back into this one. public MachiningEquipment MaterialiseMachiningEquipment(string baseDirectory, IProgress<IMessage> progress) Parameters baseDirectory string The project base directory this equipment's relative paths (e.g. MachiningChainFile) resolve against. progress IProgress<IMessage> Progress reporter for diagnostics during the copy. Returns MachiningEquipment The materialised runtime equipment. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Tooling(int, MachiningToolHouse) Selects the Setup-page tool by toolId from toolHouse. The authored face never hosts the tool-house instance itself: the runtime face equips house instances (and mutates their tessellation mid-run), and one tool's Asmb cannot live in two topologies — so this hosts a private duplicate. Clear the selection (“do not show”) by setting MachiningTool to null. public bool Tooling(int toolId, MachiningToolHouse toolHouse) Parameters toolId int tool ID toolHouse MachiningToolHouse tool house Returns bool true if the selection changed; otherwise, false. Exceptions ToolNotFoundException Throw If toolId does not exist on toolHouse."
  },
  "api/Hi.Machining.MachiningEquipmentUtils.html": {
    "href": "api/Hi.Machining.MachiningEquipmentUtils.html",
    "title": "Namespace Hi.Machining.MachiningEquipmentUtils | HiAPI-C# 2025",
    "summary": "Namespace Hi.Machining.MachiningEquipmentUtils Classes MachiningEquipment The runtime (execution) face of the machining equipment: the topology instance the runner drives — tool-change graph surgery, collision detection, live axis poses. Materialised from the authored face (MaterialiseMachiningEquipment(string, IProgress<IMessage>)) and NEVER serialized: runtime data cannot reach the project file by construction. MachiningEquipmentCollisionIndex Represents a collision index for machining equipment components. This class manages collision detection between different parts of the machining equipment. MachiningEquipmentCollisionIndexPairsSource Source of CollisionIndexPair. The adjacent solids will not be added to the CollisionIndexPairs. MachiningEquipmentUtil Utility methods for working with machining equipment. SetupEquipment The authored (setup) face of the machining equipment: the machine chain, workpiece, fixture, environment data and the Setup-page tool selection, with the project XML IO. This is the ONLY face that persists — the runtime face (MachiningEquipment) is materialised from it and never serialized, so a mid-run save can no longer write live poses or the runner-equipped tool into the project file. The XML wire name stays \"MachiningEquipment\" (see XName): shipped project files keep their layout, only the deserialized object changed. Interfaces IGetMachiningEquipment Interface for objects that can provide access to a machining equipment instance. IMachiningEquipment Machining equipment — implemented by both topology faces of the equipment split: the authored SetupEquipment and the runtime MachiningEquipment. XML IO is NOT part of this contract — only the authored face serializes. Enums CollidableComponentEnum Defines the components of a machining setup that can participate in collision detection."
  },
  "api/Hi.Machining.MachiningToolHouse.html": {
    "href": "api/Hi.Machining.MachiningToolHouse.html",
    "title": "Class MachiningToolHouse | HiAPI-C# 2025",
    "summary": "Class MachiningToolHouse Namespace Hi.Machining Assembly HiMech.dll Tool House. public class MachiningToolHouse : Dictionary<int, IMachiningTool>, IDictionary<int, IMachiningTool>, ICollection<KeyValuePair<int, IMachiningTool>>, IReadOnlyDictionary<int, IMachiningTool>, IReadOnlyCollection<KeyValuePair<int, IMachiningTool>>, IEnumerable<KeyValuePair<int, IMachiningTool>>, IDictionary, ICollection, IEnumerable, IDeserializationCallback, ISerializable, INcDependency, IMakeXmlSource Inheritance object Dictionary<int, IMachiningTool> MachiningToolHouse Implements IDictionary<int, IMachiningTool> ICollection<KeyValuePair<int, IMachiningTool>> IReadOnlyDictionary<int, IMachiningTool> IReadOnlyCollection<KeyValuePair<int, IMachiningTool>> IEnumerable<KeyValuePair<int, IMachiningTool>> IDictionary ICollection IEnumerable IDeserializationCallback ISerializable INcDependency IMakeXmlSource Inherited Members Dictionary<int, IMachiningTool>.Add(int, IMachiningTool) Dictionary<int, IMachiningTool>.Clear() Dictionary<int, IMachiningTool>.ContainsKey(int) Dictionary<int, IMachiningTool>.ContainsValue(IMachiningTool) Dictionary<int, IMachiningTool>.EnsureCapacity(int) Dictionary<int, IMachiningTool>.GetAlternateLookup<TAlternateKey>() Dictionary<int, IMachiningTool>.GetEnumerator() Dictionary<int, IMachiningTool>.OnDeserialization(object) Dictionary<int, IMachiningTool>.Remove(int) Dictionary<int, IMachiningTool>.Remove(int, out IMachiningTool) Dictionary<int, IMachiningTool>.TrimExcess() Dictionary<int, IMachiningTool>.TrimExcess(int) Dictionary<int, IMachiningTool>.TryAdd(int, IMachiningTool) Dictionary<int, IMachiningTool>.TryGetAlternateLookup<TAlternateKey>(out Dictionary<int, IMachiningTool>.AlternateLookup<TAlternateKey>) Dictionary<int, IMachiningTool>.TryGetValue(int, out IMachiningTool) Dictionary<int, IMachiningTool>.Comparer Dictionary<int, IMachiningTool>.Count Dictionary<int, IMachiningTool>.Capacity Dictionary<int, IMachiningTool>.this[int] Dictionary<int, IMachiningTool>.Keys Dictionary<int, IMachiningTool>.Values object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) DictionaryUtil.Retrieve<K, V>(Dictionary<K, V>, K, out V, bool) DictionaryUtil.GetOrCreate<TKey, TValue>(IDictionary<TKey, TValue>, TKey, TValue) DictionaryUtil.GetOrCreate<TKey, TValue>(IDictionary<TKey, TValue>, TKey, Func<TValue>) DictionaryUtil.TryGetValueByKeys<TKey, TValue>(IDictionary<TKey, TValue>, IEnumerable<TKey>, out TValue) StringUtil.ToDotSplitedString<T>(IEnumerable<T>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MachiningToolHouse() Ctor. public MachiningToolHouse() MachiningToolHouse(XElement, string, string, IProgress<IMessage>) Ctor. public MachiningToolHouse(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress) Parameters src XElement XML baseDirectory string Base directory path for resolving relative paths relFile string Relative file path progress IProgress<IMessage> The progress reporter. Properties XName Name for XML IO. public static string XName { get; } Property Value string Methods CreateStickMillingTool() Create a new Tool for UI. The tool ID is 1 if no tool existed; otherwise, the tool ID is the max tool ID plus 1. public KeyValuePair<int, MillingTool> CreateStickMillingTool() Returns KeyValuePair<int, MillingTool> the generated tool id and the generated tool MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetToolId(int, IMachiningTool) the function Typically used if the tool has already in the tool house. public void SetToolId(int toolId, IMachiningTool millingTool) Parameters toolId int millingTool IMachiningTool Exceptions ArgumentException throw if toolId has already existed."
  },
  "api/Hi.Machining.MachiningVolumeRemovalProc.StepMotionSnapshot.html": {
    "href": "api/Hi.Machining.MachiningVolumeRemovalProc.StepMotionSnapshot.html",
    "title": "Class MachiningVolumeRemovalProc.StepMotionSnapshot | HiAPI-C# 2025",
    "summary": "Class MachiningVolumeRemovalProc.StepMotionSnapshot Namespace Hi.Machining Assembly HiMech.dll Represents a snapshot of the machining motion state. public record MachiningVolumeRemovalProc.StepMotionSnapshot : IEquatable<MachiningVolumeRemovalProc.StepMotionSnapshot> Inheritance object MachiningVolumeRemovalProc.StepMotionSnapshot Implements IEquatable<MachiningVolumeRemovalProc.StepMotionSnapshot> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors StepMotionSnapshot(DVec3d, DVec3d, SeqPair<Mat4d>, Dictionary<Anchor, Mat4d>, double[], bool, IMachiningTool, WorkpieceService, double, CoolantHeatCondition, SortedList<double, double>, DVec3d) Represents a snapshot of the machining motion state. public StepMotionSnapshot(DVec3d GeomCl, DVec3d ProgramCl, SeqPair<Mat4d> Seq, Dictionary<Anchor, Mat4d> AnchorTransformDictionary, double[] McValues, bool EnableSweeping, IMachiningTool MachiningTool, WorkpieceService WorkpieceService, double BackgroundTemperature_K, CoolantHeatCondition CoolantHeatCondition, SortedList<double, double> FluteZToDzList, DVec3d PreTipPose = null) Parameters GeomCl DVec3d The geometric CL point. ProgramCl DVec3d The program CL point. Seq SeqPair<Mat4d> The sequence pair of transformation matrices. AnchorTransformDictionary Dictionary<Anchor, Mat4d> Dictionary mapping anchors to their transformation matrices. McValues double[] Array of machine values. EnableSweeping bool Whether sweeping is enabled. MachiningTool IMachiningTool The machining tool being used. WorkpieceService WorkpieceService Service that owns the workpiece being machined. BackgroundTemperature_K double Background temperature in Kelvin. CoolantHeatCondition CoolantHeatCondition The coolant heat condition. FluteZToDzList SortedList<double, double> Sorted list mapping flute Z positions to their deltas. PreTipPose DVec3d The tip pose the previous StepMotion(bool, double, Mat4d) call fed to the valve, on the workpiece-geometry coordinate – whether or not that call produced a step (the valve skips a collinear return over a segment it already covered). Null on the first call after a reset. The one-step reference for the real tip feedrate; Seq.pre is not, it may span two steps back. Properties AnchorTransformDictionary Dictionary mapping anchors to their transformation matrices. public Dictionary<Anchor, Mat4d> AnchorTransformDictionary { get; init; } Property Value Dictionary<Anchor, Mat4d> BackgroundTemperature_K Background temperature in Kelvin. public double BackgroundTemperature_K { get; init; } Property Value double CoolantHeatCondition The coolant heat condition. public CoolantHeatCondition CoolantHeatCondition { get; init; } Property Value CoolantHeatCondition EnableSweeping Whether sweeping is enabled. public bool EnableSweeping { get; init; } Property Value bool FluteZToDzList Sorted list mapping flute Z positions to their deltas. public SortedList<double, double> FluteZToDzList { get; init; } Property Value SortedList<double, double> GeomCl The geometric CL point. public DVec3d GeomCl { get; init; } Property Value DVec3d MachiningTool The machining tool being used. public IMachiningTool MachiningTool { get; init; } Property Value IMachiningTool McValues Array of machine values. public double[] McValues { get; init; } Property Value double[] PreTipPose The tip pose the previous StepMotion(bool, double, Mat4d) call fed to the valve, on the workpiece-geometry coordinate – whether or not that call produced a step (the valve skips a collinear return over a segment it already covered). Null on the first call after a reset. The one-step reference for the real tip feedrate; Seq.pre is not, it may span two steps back. public DVec3d PreTipPose { get; init; } Property Value DVec3d ProgramCl The program CL point. public DVec3d ProgramCl { get; init; } Property Value DVec3d Seq The sequence pair of transformation matrices. public SeqPair<Mat4d> Seq { get; init; } Property Value SeqPair<Mat4d> Workpiece The workpiece data model. public Workpiece Workpiece { get; } Property Value Workpiece WorkpieceService Service that owns the workpiece being machined. public WorkpieceService WorkpieceService { get; init; } Property Value WorkpieceService"
  },
  "api/Hi.Machining.MachiningVolumeRemovalProc.html": {
    "href": "api/Hi.Machining.MachiningVolumeRemovalProc.html",
    "title": "Class MachiningVolumeRemovalProc | HiAPI-C# 2025",
    "summary": "Class MachiningVolumeRemovalProc Namespace Hi.Machining Assembly HiMech.dll Handles the machining volume removal process and related operations. public class MachiningVolumeRemovalProc Inheritance object MachiningVolumeRemovalProc Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MachiningVolumeRemovalProc(Func<MachiningEquipment>, Func<WorkpieceService>) Initializes a new instance of the MachiningVolumeRemovalProc class. public MachiningVolumeRemovalProc(Func<MachiningEquipment> machiningEquipmentGetter, Func<WorkpieceService> workpieceServiceGetter) Parameters machiningEquipmentGetter Func<MachiningEquipment> workpieceServiceGetter Func<WorkpieceService> Properties ClMachiningValve Gets the CL machining valve used to control the machining process. public ClMachiningValve ClMachiningValve { get; } Property Value ClMachiningValve Methods ClearCache() Clears the internal cache, including the CL machining valve state and step-related caches. public void ClearCache() StepAssignDummyAttach(WorkpieceService, ClStrip, DVec3d) Creates a dummy attachment point in the CL strip. public static ClStripPos StepAssignDummyAttach(WorkpieceService workpieceService, ClStrip clStrip, DVec3d programCl) Parameters workpieceService WorkpieceService Service that owns the workpiece to attach to. clStrip ClStrip The CL strip to add the attachment to. programCl DVec3d The program CL point for the attachment. Returns ClStripPos The created CL strip position. StepGetGeomBoolCache(ICutter, double, SeqPair<Mat4d>, bool, bool?) Gets a geometric boolean cache for the current step based on cutter and motion parameters. public static GeomBoolCache StepGetGeomBoolCache(ICutter cutter, double stepPreferredCubeWidth, SeqPair<Mat4d> seq, bool enableSweeping, bool? isFluteTouchingWorkpiece) Parameters cutter ICutter The cutter to use for the operation. stepPreferredCubeWidth double The preferred cube width for discretization. seq SeqPair<Mat4d> The sequence pair of transformation matrices. enableSweeping bool Whether to enable sweeping operation. isFluteTouchingWorkpiece bool? Optional flag indicating if the flute is touching the workpiece. Returns GeomBoolCache A geometric boolean cache containing the operation data. Remarks Note that it is hard to know if flute is touching the workpiece by sweeping without making sweeping volume. Checking by non-sweeping geometry may miss the touching part of the sweeping volume. Hence isFluteTouchingWorkpiece should be kept null and be considered obsolete. There is no performance gain from that parameter. Events CutterChanged Event that is triggered when the cutter is changed, providing the previous and current cutter. public event Action<SeqPair<ICutter>> CutterChanged Event Type Action<SeqPair<ICutter>>"
  },
  "api/Hi.Machining.MatInterpolationKit.html": {
    "href": "api/Hi.Machining.MatInterpolationKit.html",
    "title": "Class MatInterpolationKit | HiAPI-C# 2025",
    "summary": "Class MatInterpolationKit Namespace Hi.Machining Assembly HiMech.dll Provides functionality for interpolating between two transformation matrices. public class MatInterpolationKit Inheritance object MatInterpolationKit Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MatInterpolationKit(Mat4d, Mat4d) Initializes a new instance of the MatInterpolationKit class with two matrices. public MatInterpolationKit(Mat4d m0, Mat4d m1) Parameters m0 Mat4d The first matrix. m1 Mat4d The second matrix. Properties Mat0 Gets the first matrix. public Mat4d Mat0 { get; } Property Value Mat4d Mat1 Gets the second matrix. public Mat4d Mat1 { get; } Property Value Mat4d RotationAxisAngle Gets the rotation axis and angle between the two matrices. public AxisAngle4d RotationAxisAngle { get; } Property Value AxisAngle4d Trans Gets the translation vector between the two matrices. public Vec3d Trans { get; } Property Value Vec3d Methods GetInterpolation(double) Gets an interpolated matrix between the two matrices. public Mat4d GetInterpolation(double alpha) Parameters alpha double The interpolation factor between 0 and 1. Returns Mat4d The interpolated matrix."
  },
  "api/Hi.Machining.MatRelation.html": {
    "href": "api/Hi.Machining.MatRelation.html",
    "title": "Enum MatRelation | HiAPI-C# 2025",
    "summary": "Enum MatRelation Namespace Hi.Machining Assembly HiMech.dll Defines the relationship between two matrices. public enum MatRelation Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Identity = 0 Matrices are identical. Linear = 1 Matrices have a linear relationship. NonLinear = 2 Matrices have a non-linear relationship."
  },
  "api/Hi.Machining.MatRelationUtil.html": {
    "href": "api/Hi.Machining.MatRelationUtil.html",
    "title": "Class MatRelationUtil | HiAPI-C# 2025",
    "summary": "Class MatRelationUtil Namespace Hi.Machining Assembly HiMech.dll Utility methods for determining relationships between matrices. public static class MatRelationUtil Inheritance object MatRelationUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetMatRelation(SeqPair<Mat4d>) Gets the relationship between two matrices in a sequence pair. public static MatRelation GetMatRelation(SeqPair<Mat4d> seq) Parameters seq SeqPair<Mat4d> The sequence pair containing two matrices. Returns MatRelation The relationship between the matrices. GetMatRelation(Mat4d, Mat4d) Gets the relationship between two matrices. public static MatRelation GetMatRelation(Mat4d m0, Mat4d m1) Parameters m0 Mat4d The first matrix. m1 Mat4d The second matrix. Returns MatRelation The relationship between the matrices."
  },
  "api/Hi.Machining.Sweptable.html": {
    "href": "api/Hi.Machining.Sweptable.html",
    "title": "Class Sweptable | HiAPI-C# 2025",
    "summary": "Class Sweptable Namespace Hi.Machining Assembly HiCbtr.dll Sweptable geometry. public class Sweptable : IGetSweptable, IVolumeRemover, IExpandToBox3d, IDisposable Inheritance object Sweptable Implements IGetSweptable IVolumeRemover IExpandToBox3d IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Sweptable(Stl, double) Ctor. public Sweptable(Stl stl, double nativeTopoStlFractionTolerance) Parameters stl Stl stl nativeTopoStlFractionTolerance double Fraction tolerance for native topology STL. Properties NativeStl Get geometry. public NativeStl NativeStl { get; } Property Value NativeStl geoemtry NativeTopoStl3d Get geometry. public NativeTopoStl3d NativeTopoStl3d { get; } Property Value NativeTopoStl3d geoemtry NativeTopoStl3wfr Gets the native topology STL with fraction tolerance. public NativeTopoStl3wfr NativeTopoStl3wfr { get; } Property Value NativeTopoStl3wfr Stl Gets the STL geometry. public Stl Stl { get; } Property Value Stl Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetSweptable(double) Get Sweptable. public Sweptable GetSweptable(double fractionTolerance) Parameters fractionTolerance double The fraction tolerance for the sweptable. Returns Sweptable Sweptable Sweep(Mat4d, Mat4d) Get swept geometry. public CachedTris Sweep(Mat4d pre, Mat4d cur) Parameters pre Mat4d previous transform matrix cur Mat4d current transform matrix Returns CachedTris Swept geometry Sweep(Mat4d, double) Sweep. only available for the geometry that does not contains near point or points on the same line on the same plane. public CachedTris Sweep(Mat4d cur, double fractionTolerance) Parameters cur Mat4d Current transform matrix fractionTolerance double Fraction tolerance for the operation Returns CachedTris Swept geometry as cached triangles"
  },
  "api/Hi.Machining.SweptableUtil.html": {
    "href": "api/Hi.Machining.SweptableUtil.html",
    "title": "Class SweptableUtil | HiAPI-C# 2025",
    "summary": "Class SweptableUtil Namespace Hi.Machining Assembly HiCbtr.dll Util for Sweptable. public static class SweptableUtil Inheritance object SweptableUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods AddBySweepingVolume(CubeTree, IGetSweptable, Mat4d, Mat4d, double, double, bool, bool) Add volume by sweeping volume — the boolean-union dual of RemoveBySweepingVolume(CubeTree, IGetSweptable, Mat4d, Mat4d, double, double, bool, bool). Deposits the swept solid into the geometry (additive manufacturing: weld / cladding / FDM bead), rather than removing it. public static UnmanagedAddition AddBySweepingVolume(this CubeTree cubeTree, IGetSweptable sweptable, Mat4d beginMat, Mat4d endMat, double preferredCubeWidth = 0, double fractionTolerance = 0, bool enableBuildingContactContours = false, bool isAggressiveAdd = false) Parameters cubeTree CubeTree geom to be volume-added sweptable IGetSweptable swaptable beginMat Mat4d previous transformation matrix in sequence endMat Mat4d current transformation matrix in sequence preferredCubeWidth double preferred cube width for the operation, defaults to cubeTree's resolution if 0 fractionTolerance double fraction tolerance for the sweptable, defaults to preferredCubeWidth * 1e-4 if 0 enableBuildingContactContours bool enable building contours of the newly created surface isAggressiveAdd bool whether to use aggressive adding mode Returns UnmanagedAddition Addition RemoveBySweepingVolume(CubeTree, IGetSweptable, Mat4d, Mat4d, double, double, bool, bool) Remove volume by sweeping volume. public static UnmanagedSubstraction RemoveBySweepingVolume(this CubeTree cubeTree, IGetSweptable sweptable, Mat4d beginMat, Mat4d endMat, double preferredCubeWidth = 0, double fractionTolerance = 0, bool enableBuildingContactContours = false, bool isAggressiveCut = false) Parameters cubeTree CubeTree geom to be volume-removed sweptable IGetSweptable swaptable beginMat Mat4d previous transformation matrix in sequence endMat Mat4d current transformation matrix in sequence preferredCubeWidth double preferred cube width for the operation, defaults to cubeTree's resolution if 0 fractionTolerance double fraction tolerance for the sweptable, defaults to preferredCubeWidth * 1e-4 if 0 enableBuildingContactContours bool enable building contact contours isAggressiveCut bool whether to use aggressive cutting mode Returns UnmanagedSubstraction Removal"
  },
  "api/Hi.Machining.ToolNotFoundException.html": {
    "href": "api/Hi.Machining.ToolNotFoundException.html",
    "title": "Class ToolNotFoundException | HiAPI-C# 2025",
    "summary": "Class ToolNotFoundException Namespace Hi.Machining Assembly HiMech.dll Exception thrown when a tool with the specified ID is not found. public class ToolNotFoundException : Exception, ISerializable Inheritance object Exception ToolNotFoundException Implements ISerializable Inherited Members Exception.GetBaseException() Exception.GetType() Exception.ToString() Exception.Data Exception.HelpLink Exception.HResult Exception.InnerException Exception.Message Exception.Source Exception.StackTrace Exception.TargetSite Exception.SerializeObjectState object.Equals(object) object.Equals(object, object) object.GetHashCode() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ToolNotFoundException(int) Initializes a new instance of the ToolNotFoundException class with the specified tool ID. public ToolNotFoundException(int toolId) Parameters toolId int The ID of the tool that was not found. ToolNotFoundException(int, string) Initializes a new instance of the ToolNotFoundException class with the specified tool ID and error message. public ToolNotFoundException(int toolId, string msg) Parameters toolId int The ID of the tool that was not found. msg string The error message that explains the reason for the exception. Properties ToolId Gets or sets the ID of the tool that was not found. public int ToolId { get; set; } Property Value int"
  },
  "api/Hi.Machining.html": {
    "href": "api/Hi.Machining.html",
    "title": "Namespace Hi.Machining | HiAPI-C# 2025",
    "summary": "Namespace Hi.Machining Classes FreeformRemover Represents a freeform cutting tool that can be used in machining operations. This cutter type supports complex geometries for both the noble (upper) part and the shaper (cutting) part. MachiningToolHouse Tool House. MachiningVolumeRemovalProc Handles the machining volume removal process and related operations. MachiningVolumeRemovalProc.StepMotionSnapshot Represents a snapshot of the machining motion state. MatInterpolationKit Provides functionality for interpolating between two transformation matrices. MatRelationUtil Utility methods for determining relationships between matrices. Sweptable Sweptable geometry. SweptableUtil Util for Sweptable. ToolNotFoundException Exception thrown when a tool with the specified ID is not found. Interfaces ICutter Interface of cutter. ICutterAnchorable IGetAnchor of cutter. IGetSweptable Interface of Get Sweptable. IMachiningTool Interface for machining tools that combine a holder and a cutter. IVolumeRemover Only inherit from IGetInitStickConvex and IGetSweptable. Enums MatRelation Defines the relationship between two matrices."
  },
  "api/Hi.MachiningProcs.AllowNoActiveSessionAttribute.html": {
    "href": "api/Hi.MachiningProcs.AllowNoActiveSessionAttribute.html",
    "title": "Class AllowNoActiveSessionAttribute | HiAPI-C# 2025",
    "summary": "Class AllowNoActiveSessionAttribute Namespace Hi.MachiningProcs Assembly HiNc.dll Marks a session-scoped controller action as callable without an active session, exempting it from RequireActiveSessionAttribute. Use on the session lifecycle entry points (BeginSession / EndSession), which by definition run when no session exists yet. [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)] public sealed class AllowNoActiveSessionAttribute : Attribute Inheritance object Attribute AllowNoActiveSessionAttribute Inherited Members Attribute.Equals(object) Attribute.GetCustomAttribute(Assembly, Type) Attribute.GetCustomAttribute(Assembly, Type, bool) Attribute.GetCustomAttribute(MemberInfo, Type) Attribute.GetCustomAttribute(MemberInfo, Type, bool) Attribute.GetCustomAttribute(Module, Type) Attribute.GetCustomAttribute(Module, Type, bool) Attribute.GetCustomAttribute(ParameterInfo, Type) Attribute.GetCustomAttribute(ParameterInfo, Type, bool) Attribute.GetCustomAttributes(Assembly) Attribute.GetCustomAttributes(Assembly, bool) Attribute.GetCustomAttributes(Assembly, Type) Attribute.GetCustomAttributes(Assembly, Type, bool) Attribute.GetCustomAttributes(MemberInfo) Attribute.GetCustomAttributes(MemberInfo, bool) Attribute.GetCustomAttributes(MemberInfo, Type) Attribute.GetCustomAttributes(MemberInfo, Type, bool) Attribute.GetCustomAttributes(Module) Attribute.GetCustomAttributes(Module, bool) Attribute.GetCustomAttributes(Module, Type) Attribute.GetCustomAttributes(Module, Type, bool) Attribute.GetCustomAttributes(ParameterInfo) Attribute.GetCustomAttributes(ParameterInfo, bool) Attribute.GetCustomAttributes(ParameterInfo, Type) Attribute.GetCustomAttributes(ParameterInfo, Type, bool) Attribute.GetHashCode() Attribute.IsDefaultAttribute() Attribute.IsDefined(Assembly, Type) Attribute.IsDefined(Assembly, Type, bool) Attribute.IsDefined(MemberInfo, Type) Attribute.IsDefined(MemberInfo, Type, bool) Attribute.IsDefined(Module, Type) Attribute.IsDefined(Module, Type, bool) Attribute.IsDefined(ParameterInfo, Type) Attribute.IsDefined(ParameterInfo, Type, bool) Attribute.Match(object) Attribute.TypeId object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.MachiningProcs.AllowNoLoadedProjectAttribute.html": {
    "href": "api/Hi.MachiningProcs.AllowNoLoadedProjectAttribute.html",
    "title": "Class AllowNoLoadedProjectAttribute | HiAPI-C# 2025",
    "summary": "Class AllowNoLoadedProjectAttribute Namespace Hi.MachiningProcs Assembly HiNc.dll Marks a project-level controller action as callable without a loaded project, exempting it from RequireLoadedProjectAttribute. Use on the endpoints that create or load a project (which by definition run when no project is open yet). [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)] public sealed class AllowNoLoadedProjectAttribute : Attribute Inheritance object Attribute AllowNoLoadedProjectAttribute Inherited Members Attribute.Equals(object) Attribute.GetCustomAttribute(Assembly, Type) Attribute.GetCustomAttribute(Assembly, Type, bool) Attribute.GetCustomAttribute(MemberInfo, Type) Attribute.GetCustomAttribute(MemberInfo, Type, bool) Attribute.GetCustomAttribute(Module, Type) Attribute.GetCustomAttribute(Module, Type, bool) Attribute.GetCustomAttribute(ParameterInfo, Type) Attribute.GetCustomAttribute(ParameterInfo, Type, bool) Attribute.GetCustomAttributes(Assembly) Attribute.GetCustomAttributes(Assembly, bool) Attribute.GetCustomAttributes(Assembly, Type) Attribute.GetCustomAttributes(Assembly, Type, bool) Attribute.GetCustomAttributes(MemberInfo) Attribute.GetCustomAttributes(MemberInfo, bool) Attribute.GetCustomAttributes(MemberInfo, Type) Attribute.GetCustomAttributes(MemberInfo, Type, bool) Attribute.GetCustomAttributes(Module) Attribute.GetCustomAttributes(Module, bool) Attribute.GetCustomAttributes(Module, Type) Attribute.GetCustomAttributes(Module, Type, bool) Attribute.GetCustomAttributes(ParameterInfo) Attribute.GetCustomAttributes(ParameterInfo, bool) Attribute.GetCustomAttributes(ParameterInfo, Type) Attribute.GetCustomAttributes(ParameterInfo, Type, bool) Attribute.GetHashCode() Attribute.IsDefaultAttribute() Attribute.IsDefined(Assembly, Type) Attribute.IsDefined(Assembly, Type, bool) Attribute.IsDefined(MemberInfo, Type) Attribute.IsDefined(MemberInfo, Type, bool) Attribute.IsDefined(Module, Type) Attribute.IsDefined(Module, Type, bool) Attribute.IsDefined(ParameterInfo, Type) Attribute.IsDefined(ParameterInfo, Type, bool) Attribute.Match(object) Attribute.TypeId object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.MachiningProcs.ApiActionResult.html": {
    "href": "api/Hi.MachiningProcs.ApiActionResult.html",
    "title": "Class ApiActionResult | HiAPI-C# 2025",
    "summary": "Class ApiActionResult Namespace Hi.MachiningProcs Assembly HiNc.dll The shared outcome envelope for a web-API action: whether it succeeded and the messages it reported, in order. Returned by the project-level surface (LocalProjectServiceController) and, on the no-active-session boundary, by the session-scoped surface (SessionShellController via RequireActiveSessionAttribute). A REST / AI caller therefore reads the progress / success / error notifications inline in the HTTP response instead of only out-of-band via the SignalR sinks, and can branch on Success without parsing severities. public record ApiActionResult : IEquatable<ApiActionResult> Inheritance object ApiActionResult Implements IEquatable<ApiActionResult> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ApiActionResult(bool, IReadOnlyList<MessageDto>) The shared outcome envelope for a web-API action: whether it succeeded and the messages it reported, in order. Returned by the project-level surface (LocalProjectServiceController) and, on the no-active-session boundary, by the session-scoped surface (SessionShellController via RequireActiveSessionAttribute). A REST / AI caller therefore reads the progress / success / error notifications inline in the HTTP response instead of only out-of-band via the SignalR sinks, and can branch on Success without parsing severities. public ApiActionResult(bool Success, IReadOnlyList<MessageDto> Messages) Parameters Success bool False when any reported message is an error; true otherwise. Messages IReadOnlyList<MessageDto> The messages reported during the call, in arrival order. Properties Messages The messages reported during the call, in arrival order. public IReadOnlyList<MessageDto> Messages { get; init; } Property Value IReadOnlyList<MessageDto> Success False when any reported message is an error; true otherwise. public bool Success { get; init; } Property Value bool Methods FromCollector(MessageCollector, bool?) Builds a result from a per-call MessageCollector. Success is inferred as “no error-severity message was reported” unless success overrides it. public static ApiActionResult FromCollector(MessageCollector collector, bool? success = null) Parameters collector MessageCollector The per-call sink whose messages to flatten. success bool? Explicit success flag, or null to infer from the messages. Returns ApiActionResult The outcome envelope. NoActiveSession() The canonical “no active session” result: a single configuration error telling the caller to start a session first. Returned (with HTTP 409) by RequireActiveSessionAttribute when a session-scoped endpoint is invoked outside a session. public static ApiActionResult NoActiveSession() Returns ApiActionResult An unsuccessful envelope carrying the guidance message. NoProjectLoaded() The canonical “no project loaded” result: a single configuration error telling the caller to create or load a project first. Returned (with HTTP 409) by RequireLoadedProjectAttribute when a project-level endpoint is invoked before any project is open. public static ApiActionResult NoProjectLoaded() Returns ApiActionResult An unsuccessful envelope carrying the guidance message."
  },
  "api/Hi.MachiningProcs.ConfigStepFunc.html": {
    "href": "api/Hi.MachiningProcs.ConfigStepFunc.html",
    "title": "Delegate ConfigStepFunc | HiAPI-C# 2025",
    "summary": "Delegate ConfigStepFunc Namespace Hi.MachiningProcs Assembly HiMech.dll Delegate for configuring a milling step with additional arguments. public delegate object ConfigStepFunc(MachiningStep millingStep, object arg) Parameters millingStep MachiningStep The milling step to configure. arg object Additional arguments for configuration. Returns object The configuration result. Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.MachiningProcs.IMachiningProjectGetter.html": {
    "href": "api/Hi.MachiningProcs.IMachiningProjectGetter.html",
    "title": "Interface IMachiningProjectGetter | HiAPI-C# 2025",
    "summary": "Interface IMachiningProjectGetter Namespace Hi.MachiningProcs Assembly HiNc.dll Interface for objects that can provide a MachiningProject instance. public interface IMachiningProjectGetter Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetMachiningProject() Gets the MachiningProject instance. MachiningProject GetMachiningProject() Returns MachiningProject The MachiningProject instance."
  },
  "api/Hi.MachiningProcs.IProjectService.html": {
    "href": "api/Hi.MachiningProcs.IProjectService.html",
    "title": "Interface IProjectService | HiAPI-C# 2025",
    "summary": "Interface IProjectService Namespace Hi.MachiningProcs Assembly HiNc.dll Interface for services that manage machining projects. public interface IProjectService : IMachiningProjectGetter Inherited Members IMachiningProjectGetter.GetMachiningProject() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties MachiningProject Gets or sets the machining project instance. MachiningProject MachiningProject { get; set; } Property Value MachiningProject Methods GetLocalProjectService() Get Local Project Service as base-service. LocalProjectService GetLocalProjectService() Returns LocalProjectService Local Project Service"
  },
  "api/Hi.MachiningProcs.LocalProjectService.MachiningProjectChangedDelegate.html": {
    "href": "api/Hi.MachiningProcs.LocalProjectService.MachiningProjectChangedDelegate.html",
    "title": "Delegate LocalProjectService.MachiningProjectChangedDelegate | HiAPI-C# 2025",
    "summary": "Delegate LocalProjectService.MachiningProjectChangedDelegate Namespace Hi.MachiningProcs Assembly HiNc.dll Delegate for machining project changed events. public delegate void LocalProjectService.MachiningProjectChangedDelegate(MachiningProject project, string projectPath) Parameters project MachiningProject The new machining project. projectPath string The path to the project file. Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.MachiningProcs.LocalProjectService.html": {
    "href": "api/Hi.MachiningProcs.LocalProjectService.html",
    "title": "Class LocalProjectService | HiAPI-C# 2025",
    "summary": "Class LocalProjectService Namespace Hi.MachiningProcs Assembly HiNc.dll Root(Local) project service. Apply absolute file path. public class LocalProjectService : IProjectService, IMachiningProjectGetter, IMachiningService, IGetMachiningEquipment, IStepPropertyAccessHost, IDisposable Inheritance object LocalProjectService Implements IProjectService IMachiningProjectGetter IMachiningService IGetMachiningEquipment IStepPropertyAccessHost IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks LocalProjectService handles the runtime data and cache generally not requires configuration IO. Compare to MachiningProject, LocalProjectService also handles events that does not reset on the MachiningProject been reloaded. Constructors LocalProjectService(ILogger<LocalProjectService>) Ctor. public LocalProjectService(ILogger<LocalProjectService> logger = null) Parameters logger ILogger<LocalProjectService> Optional logger instance. Properties ActiveNcRunner Gets the active NC runner based on EnableSoftNcRunner. public INcRunner ActiveNcRunner { get; } Property Value INcRunner BaseDirectory Gets the project base directory (relative-path root). public string BaseDirectory { get; } Property Value string BoundSelectorHost Gets the bound selector host for managing selection boundaries. public BoundSelectorHost BoundSelectorHost { get; } Property Value BoundSelectorHost ClRunner Gets the NX-CL (CLSF) runner of the project (NxClRunner); null when there is no project. public INcRunner ClRunner { get; } Property Value INcRunner ClStrip Gets the cutter location strip containing the machining steps. public ClStrip ClStrip { get; } Property Value ClStrip CsvRunner Gets the CSV runner — the CSV suit's pipeline (GeneralCsvRunner); null when there is no project. public INcRunner CsvRunner { get; } Property Value INcRunner DictionaryColorGuide Gets the color guide for dictionary-based coloring. public DictionaryColorGuide DictionaryColorGuide { get; } Property Value DictionaryColorGuide EnablePauseOnFailure Gets or sets whether to pause execution on failure. public bool EnablePauseOnFailure { get; set; } Property Value bool EnableSoftNcRunner Switches between SoftNcRunner and the legacy HardNcRunner. Default true (2026-07-17): SoftNcRunner is the flagship NC pipeline; set false to fall back to HardNcRunner for the features that still depend on it (e.g. Hi.NcOpt.NcOptProc optimization reads NcLines). Will be removed when HardNcRunner is fully replaced. public bool EnableSoftNcRunner { get; set; } Property Value bool EnableStrokeLimitCheck Gets or sets whether stroke limit checking is enabled. public bool EnableStrokeLimitCheck { get; set; } Property Value bool Fixture Gets or sets the authored fixture (setup face). The runtime face follows by rebuild; runtime readers use MachiningEquipment.Fixture. public Fixture Fixture { get; set; } Property Value Fixture Global global variable for SessionShell. Not save on XML. public Dictionary<object, object> Global { get; set; } Property Value Dictionary<object, object> InspectingKey Gets or sets the current inspecting key for visualization. When set, updates the inspecting quantity function. public string InspectingKey { get; set; } Property Value string InspectingQuantityFunc Gets the function that retrieves the quantity value for the current inspecting key. public Func<MachiningStep, double?> InspectingQuantityFunc { get; } Property Value Func<MachiningStep, double?> IsCollisionDetectionEnabled Gets whether collision detection is currently enabled. public bool IsCollisionDetectionEnabled { get; } Property Value bool LastMillingParaTrainResult Snapshot of the most recent TrainMillingPara(SampleFlag, bool, double, string, CancellationToken, ICuttingPara, IProgress<IMessage>) / ReTrainMillingPara(SampleFlag, double, string, CancellationToken, IProgress<IMessage>) outcome — sampleFlags, correlation R, filtered sample count, output file and the built parameter's XML — so a caller (e.g. the webservice) can read the training result without re-opening the output .mp file. Service lifetime, last-wins; null until the first training call completes. Deliberately not cleared by ResetRuntime(IProgress<IMessage>) so the result stays readable after a post-run reset. public MillingParaTrainResult LastMillingParaTrainResult { get; } Property Value MillingParaTrainResult Logger Gets the logger instance for this service. public ILogger<LocalProjectService> Logger { get; } Property Value ILogger<LocalProjectService> MachiningActRunner Gets the machining act runner responsible for executing machining operations. public MachiningActRunner MachiningActRunner { get; } Property Value MachiningActRunner MachiningChain Gets or sets the authored machining chain (setup face). The runtime face follows by rebuild; runtime readers use MachiningEquipment.MachiningChain. public IMachiningChain MachiningChain { get; set; } Property Value IMachiningChain MachiningChainFile Gets or sets the file path of the solid machining chain. This is used for XML serialization and file management. public string MachiningChainFile { get; set; } Property Value string MachiningEquipment The runtime (execution) equipment face — service-owned, materialised from SetupEquipment at project assignment and session boundaries, never serialized. Runtime consumers (runner, physics, collision, execution display) read this. public MachiningEquipment MachiningEquipment { get; } Property Value MachiningEquipment MachiningMotionResolution Gets or sets the machining motion resolution strategy (project-level; backed by MachiningActRunner). public IMachiningMotionResolution MachiningMotionResolution { get; set; } Property Value IMachiningMotionResolution MachiningProject Gets or sets the machining project. The setter runs the full change lifecycle (teardown of the outgoing project, then Hi.MachiningProcs.LocalProjectService.OnMachiningProjectChanged()), so external assignment — e.g. through MachiningProject or a desktop host — can no longer bypass the hooks and leave the runner config un-wired (equipment-split P2). public MachiningProject MachiningProject { get; set; } Property Value MachiningProject MachiningProjectPath public string MachiningProjectPath { get; set; } Property Value string MachiningResolution_mm Gets the machining resolution (mm) — the act-runner value, or the workpiece bottom resolution when unset. Set via SetMachiningResolution_mm(double, IProgress<IMessage>) (have-both: the caller injects the message host). Seeded from InitResolution when a project is loaded/assigned; an explicit setting then survives ResetRuntime(IProgress<IMessage>) and workpiece swaps. public double MachiningResolution_mm { get; } Property Value double MachiningSession Gets the current machining session. public MachiningSession MachiningSession { get; set; } Property Value MachiningSession MachiningTool Gets or sets the Setup-page selected tool (setup face). The tool the runner currently drives is MachiningEquipment.MachiningTool. public IMachiningTool MachiningTool { get; set; } Property Value IMachiningTool MachiningToolHouse Gets or sets the machining tool house containing tool configurations. public MachiningToolHouse MachiningToolHouse { get; set; } Property Value MachiningToolHouse MachiningToolHouseFile Gets or sets the file path to the milling tool house configuration. public string MachiningToolHouseFile { get; set; } Property Value string MillingStepLuggageReader Gets the reader for accessing milling step luggage data. public ParallelBulkReader<MillingStepLuggage> MillingStepLuggageReader { get; } Property Value ParallelBulkReader<MillingStepLuggage> NcDiagnosticProgress NC-pipeline diagnostic sink on the IMessage channel — sibling of StepDiagnosticProgress. Stable for the service lifetime (created in the ctor, only Cleared on reset, never swapped per session). public NcDiagnosticProgress NcDiagnosticProgress { get; } Property Value NcDiagnosticProgress NcManipulationDiagnosticProgress Gets the NC-manipulation diagnostic sink — the second diagnostic home, for operations that rework an already-played NC/CL program (writeback conversion, NC optimization) as opposed to the play-time pipeline diagnostics in NcDiagnosticProgress. Keeping the two scenarios in separate homes lets a play reset clear run diagnostics without discarding manipulation results, and vice versa; each manipulation run clears this home at its start so it always holds the latest run. public NcDiagnosticProgress NcManipulationDiagnosticProgress { get; } Property Value NcDiagnosticProgress NcOptProc Gets the NC optimization processor for optimizing NC programs. public NcOptProc NcOptProc { get; } Property Value NcOptProc NcRunner Gets the legacy NC runner. public HardNcRunner NcRunner { get; } Property Value HardNcRunner PacePlayer Gets the pace player for controlling execution pace of milling operations. public PacePlayer PacePlayer { get; } Property Value PacePlayer ProjectDirectory Gets the directory containing the machining project. public string ProjectDirectory { get; } Property Value string ScriptOptions Project-level Roslyn script options for session script execution. Initialized from DefaultScriptOptions. public ScriptOptions ScriptOptions { get; set; } Property Value ScriptOptions SessionShell Gets the shell API for the active session. Created at BeginSession(), nulled at EndSession(); null outside a session — its lifetime is unified with MachiningSession, so a non-null instance always implies an active session. public SessionShell SessionShell { get; } Property Value SessionShell SetupEquipment The authored (setup) equipment face of the loaded project — the only persisted face. Authoring surfaces (setup pages, equipment editors) read and write this; runtime follows by rebuild (see NotifySetupEquipmentEdited()). public SetupEquipment SetupEquipment { get; } Property Value SetupEquipment ShellProgress Session-level routine / lifecycle message sink on the IMessage channel (cache reset, file progress, …). Owned by MachiningSession (truly session-scoped); null outside a session. Use null-safely. public ShellProgress ShellProgress { get; } Property Value ShellProgress SoftNcRunner Facade over the active suit's NC pipeline (MachiningProject.NcRunnerSuit.SoftNcRunner). The getter is null-safe (returns null when there is no project/suit). The setter is the single rewiring entry point: it assigns the suit's runner and re-binds everything that depends on it (proxy hosts, kinematics provider, session script dictionaries, and the per-session NcRunnerSessionState). public SoftNcRunner SoftNcRunner { get; set; } Property Value SoftNcRunner StepDiagnosticProgress Step-anchored message sink on the IMessage channel, threaded through the runner / act-processing chain. public StepDiagnosticProgress StepDiagnosticProgress { get; } Property Value StepDiagnosticProgress StepPropertyAccessDictionary Gets the dictionary mapping property keys to their access methods. public ConcurrentDictionary<string, PropertyAccess<MachiningStep>> StepPropertyAccessDictionary { get; } Property Value ConcurrentDictionary<string, PropertyAccess<MachiningStep>> TimeMapping Gets or sets the time mapping for synchronizing different time-based data streams. public TimeMapping TimeMapping { get; set; } Property Value TimeMapping Workpiece Gets or sets the authored workpiece (setup face). The runtime face follows by rebuild; runtime readers use MachiningEquipment.Workpiece. public Workpiece Workpiece { get; set; } Property Value Workpiece WorkpieceService Gets the workpiece runtime service. public WorkpieceService WorkpieceService { get; } Property Value WorkpieceService XyzabcSolver Gets the shared kinematics solver — the third topology entity of the equipment split, owned by the service (runtime side) rather than the persisted project graph. Rebuilt by Hi.MachiningProcs.LocalProjectService.BuildCoordinateConverter() whenever the machine chain changes. public XyzabcSolver XyzabcSolver { get; } Property Value XyzabcSolver Methods Act(IAct, ISentenceCarrier, CancellationToken?) Executes an act and collects all results. public void Act(IAct act, ISentenceCarrier sourceCommand = null, CancellationToken? cancellationToken = null) Parameters act IAct The act to execute. sourceCommand ISentenceCarrier The source command that triggered the act. cancellationToken CancellationToken? Cancellation token to cancel the operation. BeginNcRunner() Prepares the NC runner for a play session by initializing the workpiece meshed geometry (when not already initialized), reporting progress through ShellProgress. public void BeginNcRunner() BeginSession() Initiate a simulation session. Clear the state from previous session (if existed). public void BeginSession() CheckStrokeLimitOnStep() Checks stroke limit at the current MC position. Uses IStrokeLimitConfig when EnableSoftNcRunner is active, otherwise falls back to CheckStrokeLimit(DVec3d, IProgress<IMessage>). public bool CheckStrokeLimitOnStep() Returns bool True if within limits or no limits configured. CloseProject() Closes the current project. public void CloseProject() ConvertClToNcFiles(string, IProgress<IMessage>) Converts the CLSF play of the current session into Fanuc NC files (writeback synthesis — MSYS tilt becomes G68.2, RTCP becomes G43.4). Play a CL file on an XYZABC machine chain first, then convert; see ConvertClToNcFiles(string, string, IProgress<IMessage>). public IReadOnlyList<string> ConvertClToNcFiles(string relNcFileTemplate = \"Output/[NcName].nc\", IProgress<IMessage> messageProgress = null) Parameters relNcFileTemplate string Output path template; [NcName] is replaced by the source file name. messageProgress IProgress<IMessage> Optional message sink for lifecycle reporting. Returns IReadOnlyList<string> Written NC file paths, relative to the project base directory. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool EnableCollisionDetection(bool, IProgress<IMessage>) Enables or disables collision detection. When enabling, prepares the collidable items; when disabling, resets collision flags. Progress is reported to the injected messageProgress. public void EnableCollisionDetection(bool value, IProgress<IMessage> messageProgress = null) Parameters value bool Whether collision detection should be enabled. messageProgress IProgress<IMessage> Sink-agnostic message host for progress reporting. EndSession() Ends the current machining session and releases associated resources. public void EndSession() EnsureExecutionEquipment() Ensures the runtime MachiningEquipment reflects the authored setup face — re-materialising it when setup edits are pending (equipment split: follow = rebuild at session boundaries). Default: no-op, for hosts without a setup face (e.g. test stubs). public void EnsureExecutionEquipment() FixedPace(double, double) Creates a fixed machining motion resolution with the specified linear (mm) and rotary (deg) resolutions. public FixedMachiningMotionResolution FixedPace(double linearResolution_mm, double rotaryResolution_deg) Parameters linearResolution_mm double Linear resolution in millimeters. rotaryResolution_deg double Rotary resolution in degrees. Returns FixedMachiningMotionResolution ForwardSetupEnvironmentToExecution() Forwards the authored environment values (background temperature, coolant condition, spindle capability) onto the runtime face. These are pure data with no topology involvement, so eager forwarding is safe and keeps environment edits immediate — a full materialise is not needed for them. Call after writing the environment members on SetupEquipment. public void ForwardSetupEnvironmentToExecution() GetInspectingKeyPresentName(StringLocalizer) Gets the localized presentation name for the current inspecting key. public string GetInspectingKeyPresentName(StringLocalizer stringLocalizer) Parameters stringLocalizer StringLocalizer The string localizer to use for localization Returns string The localized presentation name GetLocalProjectService() Get Local Project Service as base-service. public LocalProjectService GetLocalProjectService() Returns LocalProjectService Local Project Service GetMachiningEquipment() Get the runtime MachiningEquipment. public MachiningEquipment GetMachiningEquipment() Returns MachiningEquipment MachiningEquipment GetMachiningProject() Gets the MachiningProject instance. public MachiningProject GetMachiningProject() Returns MachiningProject The MachiningProject instance. GetSessionShell() Returns the session shell that exposes the runtime surface of the active machining session. public ISessionShell GetSessionShell() Returns ISessionShell LoadProject(string, IProgress<IMessage>) Loads a project by absolute file path. Load-time diagnostics (a machine or part STL the project references but that is missing on disk, an unloadable child XML, …) do not fail the load: the project comes up without that geometry and each problem is reported as an IMessage — always to the service logger, and also to messageProgress when the caller injects one. public void LoadProject(string projectPath, IProgress<IMessage> messageProgress = null) Parameters projectPath string The absolute file path messageProgress IProgress<IMessage> Optional caller-injected sink for the load-time diagnostics (e.g. a MessageCollector a web controller hands back in its response). Null keeps logger-only reporting. NewProject(string) Creates a new project by file path. public void NewProject(string projectPath) Parameters projectPath string The absolute file path NotifySetupEquipmentEdited() Marks the authored face edited so the runtime face follows. Follow is a REBUILD (never live incremental sync): immediately when no session is active, otherwise at the next session boundary (BeginSession() / the next play's EnsureExecutionEquipment() / a player reset). The facade setters call this; call it manually after mutating SetupEquipment members in place. public void NotifySetupEquipmentEdited() PlayBrandNcFile(string, string) Plays a famous-brand NC code file from the specified path with pace control (no kind dispatch — always the brand runner). public void PlayBrandNcFile(string baseDirectory, string relFilePath) Parameters baseDirectory string Base directory for resolving relative paths relFilePath string Relative path to the NC file PlayClFile(string, string) Plays an NX-CL (CLSF) file from the specified path. public void PlayClFile(string baseDirectory, string relFilePath) Parameters baseDirectory string Base directory for resolving relative paths. relFilePath string Relative path to the CLSF file. PlayCsvFile(string, string) Plays a CSV file from the specified path. public void PlayCsvFile(string baseDirectory, string relFilePath) Parameters baseDirectory string Base directory for resolving relative paths. relFilePath string Relative path to the CSV file. PlayNc(string, string) Plays NC commands from raw text with pace control. public void PlayNc(string ncText, string fileNameAlternative = \"--\") Parameters ncText string The NC command text to execute fileNameAlternative string Alternative name to associate with the NC program PlayNcFile(string, string, NcKind) Plays an NC program file from the specified path, the runner picked by kind (Auto = by file extension: known CL/CSV extensions map to those runners, anything else plays as brand NC). public void PlayNcFile(string baseDirectory, string relFilePath, NcKind kind = NcKind.Auto) Parameters baseDirectory string Base directory for resolving relative paths. relFilePath string Relative path to the NC program file. kind NcKind Which runner plays the file; Auto detects by extension. PowerReset() Performs a controller power reset, modelling a power-off / power-on cycle: Every IPowerResettable dependency clears its volatile subset. Persistent dependency state (controller parameters, Fanuc #500-#999, etc.) is left intact. The active MachiningSession's NcRunnerSessionState is reset so the per-layer SyntaxPiece dataflow — including Vars.Volatile, modal carries, and the init seed — is dropped. The next RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) call re-initialises everything from scratch. Without the second step, calling PowerReset while a project is loaded would leave volatile commons alive across the supposed power cycle (they live in the SyntaxPiece JSON dataflow rather than in any IPowerResettable dependency). public void PowerReset() ProcAct(IAct, ISentenceCarrier, CancellationToken?) Processes an act and returns the results. public IEnumerable<object> ProcAct(IAct act, ISentenceCarrier sourceCommand = null, CancellationToken? cancellationToken = null) Parameters act IAct The act to process. sourceCommand ISentenceCarrier The source command that triggered the act. cancellationToken CancellationToken? Cancellation token to cancel the operation. Returns IEnumerable<object> Enumerable of results from processing the act. ReTrainMillingPara(SampleFlag, double, string, CancellationToken, IProgress<IMessage>) Train Milling Parameter. public void ReTrainMillingPara(SampleFlag sampleFlags, double outlierRatio, string dstRelFile, CancellationToken cancellationToken, IProgress<IMessage> messageProgress = null) Parameters sampleFlags SampleFlag outlierRatio double dstRelFile string cancellationToken CancellationToken messageProgress IProgress<IMessage> ReadNcRunnerSuit(string) Reads an NcRunnerSuit from relFile (project relative) and makes it the active suit — switching the active parser (NC or CSV) — then re-binds every host hookup (see Hi.MachiningProcs.LocalProjectService.RewireForActiveSuit()). Refused while an NC program is playing: the runner's per-session layers are mid-enumeration and cannot be safely reset (an IProgress<T> error is reported instead). public void ReadNcRunnerSuit(string relFile) Parameters relFile string RefreshDrawing() Refreshes the visual display of the milling course. public void RefreshDrawing() Reg(XFactory) Bootstraps XML-factory registration for the simulation pipeline. Entry points must call this once at startup before any project XML is deserialized. Pass a custom XFactory for test isolation, or null to populate Default. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory RegisterStepVariable(string, string, string, string, Func<MachiningStep, object>) Registers a step variable so downstream components (strip charts, CSV exports, scripting) can read it from MachiningStep. Idempotent on key. public void RegisterStepVariable(string key, string name, string unit, string formatString, Func<MachiningStep, object> variableFunc = null) Parameters key string Unique key. name string Human-readable name; may equal key. unit string Physical unit name (PhysicsUnit); nullable. formatString string Display format string; nullable. variableFunc Func<MachiningStep, object> Optional value extractor; nullable when the value comes from the step's flex dictionary. ReloadProject(IProgress<IMessage>) Reloads the current project from disk, discarding in-memory edits. Load-time diagnostics are reported the same way as in LoadProject(string, IProgress<IMessage>). public void ReloadProject(IProgress<IMessage> messageProgress = null) Parameters messageProgress IProgress<IMessage> Optional caller-injected sink for the load-time diagnostics; null keeps logger-only reporting. ResetRuntime(IProgress<IMessage>) Reset the runtime states including: meshed geometry, collision flags, machine tool position, CL strips, message buffer and etc.. MachiningResolution_mm is deliberately left untouched so an explicit setting survives resets; it is seeded from InitResolution only when a project is loaded/assigned. public void ResetRuntime(IProgress<IMessage> messageProgress = null) Parameters messageProgress IProgress<IMessage> RunBrandNcFile(string, string) Runs a famous-brand NC code file from the specified path (no kind dispatch — always the brand runner). public IEnumerable<Action> RunBrandNcFile(string baseDirectory, string relFilePath) Parameters baseDirectory string Base directory for resolving relative paths. If the value is null, BaseDirectory substitutes the value. relFilePath string Relative path to the NC file. Returns IEnumerable<Action> An enumerable of actions to be executed. RunClFile(string, string) Runs an NX-CL (CLSF) file from the specified path. public IEnumerable<Action> RunClFile(string baseDirectory, string relFilePath) Parameters baseDirectory string Base directory for resolving relative paths. relFilePath string Relative path to the CLSF file. Returns IEnumerable<Action> An enumerable of actions to be executed. RunCsvFile(string, string) Runs a CSV file from the specified path. public IEnumerable<Action> RunCsvFile(string baseDirectory, string relFilePath) Parameters baseDirectory string Base directory for resolving relative paths. relFilePath string Relative path to the CSV file. Returns IEnumerable<Action> An enumerable of actions to be executed. RunNc(string, string) Runs NC commands from raw text. public IEnumerable<Action> RunNc(string ncText, string fileNameAlternative = \"--\") Parameters ncText string The NC command text to execute fileNameAlternative string Alternative name to associate with the NC program Returns IEnumerable<Action> An enumerable of actions to be executed RunNcFile(string, string, NcKind) Runs an NC program file from the specified path, the runner picked by kind (Auto = by file extension: known CL/CSV extensions map to those runners, anything else runs as brand NC). public IEnumerable<Action> RunNcFile(string baseDirectory, string relFilePath, NcKind kind = NcKind.Auto) Parameters baseDirectory string Base directory for resolving relative paths. relFilePath string Relative path to the NC program file. kind NcKind Which runner runs the file; Auto detects by extension. Returns IEnumerable<Action> An enumerable of actions to be executed. RunToLineEnd() Advances the player by one NC/CSV line and pauses. public void RunToLineEnd() SaveAsProject(string) Saves the current project to a specified relative file path. public void SaveAsProject(string projectPath) Parameters projectPath string The absolute file path SaveProject() Save project by project path. public void SaveProject() SetMachiningResolution_mm(double, IProgress<IMessage>) Sets the machining resolution (mm). Progress is reported to the injected messageProgress. public void SetMachiningResolution_mm(double value, IProgress<IMessage> messageProgress = null) Parameters value double The machining resolution in millimeters. messageProgress IProgress<IMessage> Sink-agnostic message host for progress reporting. TrainMillingPara(SampleFlag, bool, double, string, CancellationToken, ICuttingPara, IProgress<IMessage>) Train Milling Parameter. public void TrainMillingPara(SampleFlag sampleFlags, bool enableFzOnlyDuringDrilling, double outlierRatio, string dstRelFile, CancellationToken cancellationToken, ICuttingPara paraTemplate, IProgress<IMessage> messageProgress = null) Parameters sampleFlags SampleFlag enableFzOnlyDuringDrilling bool outlierRatio double dstRelFile string cancellationToken CancellationToken paraTemplate ICuttingPara messageProgress IProgress<IMessage> UpdateByMachiningChain() Updates components when the machining chain changes. public void UpdateByMachiningChain() UpdateByMachiningEquipment() Re-binds everything derived from the runtime equipment face. Runs as the tail of Hi.MachiningProcs.LocalProjectService.MaterialiseExecutionEquipment(); call manually only after mutating the runtime face outside the service. public void UpdateByMachiningEquipment() UpdateIdealMillingToolOffsetTableByToolHouse() Updates the ideal milling tool offset table based on the current tool house configuration. public void UpdateIdealMillingToolOffsetTableByToolHouse() WriteNcRunnerSuit(string) Writes the active NcRunnerSuit to relFile (project relative). Pure file IO — does not update any in-memory pointer. public void WriteNcRunnerSuit(string relFile) Parameters relFile string WriteShotFile(TimeSpan, string, IProgress<IMessage>) Writes time-based shot data to a file with the specified sampling period. public void WriteShotFile(TimeSpan samplingPeriod, string relFileTemplate = \"Output/[NcName].shot.csv\", IProgress<IMessage> messageProgress = null) Parameters samplingPeriod TimeSpan The time period between samples relFileTemplate string Template for the output file path, can include [NcName] placeholder messageProgress IProgress<IMessage> Optional caller-supplied progress sink for start/finish messages. WriteStepFile(string, IProgress<IMessage>) Writes step-based data to a file. public void WriteStepFile(string relFileTemplate = \"Output/[NcName].step.csv\", IProgress<IMessage> messageProgress = null) Parameters relFileTemplate string Template for the output file path, can include [NcName] placeholder messageProgress IProgress<IMessage> Optional caller-supplied progress sink for start/finish messages. Events MachiningProjectChanged Event raised when the machining project changes. public event LocalProjectService.MachiningProjectChangedDelegate MachiningProjectChanged Event Type LocalProjectService.MachiningProjectChangedDelegate MachiningStepBuilt event to configure steps. The first parameter is the previous step; the second parameter is the current step. The previous step is null if no previous step exists. public event MachiningActRunner.MachiningStepBuiltDelegate MachiningStepBuilt Event Type MachiningActRunner.MachiningStepBuiltDelegate OnNcFileRan Event triggered after an NC file is executed. public event Action OnNcFileRan Event Type Action OnShellMessageAdded App-lifetime bridge for ShellProgress appends. Because ShellProgress is session-scoped (recreated at BeginSession(), null outside a session), a consumer that wants every session's shell messages subscribes here once instead of chasing the swapping instance — BeginSession() re-wires the bridge to the new sink each session, the same way OnSourcedActEntry is bridged. Carries the append index and the message. public event Action<int, IMessage> OnShellMessageAdded Event Type Action<int, IMessage> OnShellMessageCleared App-lifetime bridge for ShellProgress clears (see OnShellMessageAdded). public event Action OnShellMessageCleared Event Type Action OnSourcedActEntry App-lifetime event triggered for each SourcedActEntry produced during NC/CSV execution. public event Action<SourcedActEntry> OnSourcedActEntry Event Type Action<SourcedActEntry> OnSyntaxPieceRan Raised after each SyntaxPiece has been run during NC execution (app lifetime). public event Action<SyntaxPiece> OnSyntaxPieceRan Event Type Action<SyntaxPiece> OnUpdatedInspectingQuantityFunc Event triggered when the inspecting quantity function is updated. public event Action OnUpdatedInspectingQuantityFunc Event Type Action WorkpieceChanged Event that is raised when the workpiece is changed. public event Action<SeqPair<Workpiece>> WorkpieceChanged Event Type Action<SeqPair<Workpiece>> Remarks This event is triggered whenever the workpiece property is modified. Subscribers can use this event to respond to changes in the workpiece configuration, such as updating visualizations or recalculating machining parameters. The event provides both the previous and new workpiece values through a SeqPair."
  },
  "api/Hi.MachiningProcs.LocalProjectServiceController.html": {
    "href": "api/Hi.MachiningProcs.LocalProjectServiceController.html",
    "title": "Class LocalProjectServiceController | HiAPI-C# 2025",
    "summary": "Class LocalProjectServiceController Namespace Hi.MachiningProcs Assembly HiNc.dll HTTP controller exposing the project-level (session-independent) operations of Hi.MachiningProcs.LocalProjectServiceController.LocalProjectService — the lean API-user surface, parallel to SessionShellController (which mirrors the session-scoped SessionShell). A controller mirrors exactly one body; project-level settings belong here, not bolted onto the session controller. [ApiController] [Route(\"api/[controller]/[action]\")] [ProducesResponseType(typeof(ApiActionResult), 409)] public class LocalProjectServiceController : ControllerBase Inheritance object ControllerBase LocalProjectServiceController Inherited Members ControllerBase.StatusCode(int) ControllerBase.StatusCode(int, object) ControllerBase.Content(string) ControllerBase.Content(string, string) ControllerBase.Content(string, string, Encoding) ControllerBase.Content(string, MediaTypeHeaderValue) ControllerBase.NoContent() ControllerBase.Ok() ControllerBase.Ok(object) ControllerBase.Redirect(string) ControllerBase.RedirectPermanent(string) ControllerBase.RedirectPreserveMethod(string) ControllerBase.RedirectPermanentPreserveMethod(string) ControllerBase.LocalRedirect(string) ControllerBase.LocalRedirectPermanent(string) ControllerBase.LocalRedirectPreserveMethod(string) ControllerBase.LocalRedirectPermanentPreserveMethod(string) ControllerBase.RedirectToAction() ControllerBase.RedirectToAction(string) ControllerBase.RedirectToAction(string, object) ControllerBase.RedirectToAction(string, string) ControllerBase.RedirectToAction(string, string, object) ControllerBase.RedirectToAction(string, string, string) ControllerBase.RedirectToAction(string, string, object, string) ControllerBase.RedirectToActionPreserveMethod(string, string, object, string) ControllerBase.RedirectToActionPermanent(string) ControllerBase.RedirectToActionPermanent(string, object) ControllerBase.RedirectToActionPermanent(string, string) ControllerBase.RedirectToActionPermanent(string, string, string) ControllerBase.RedirectToActionPermanent(string, string, object) ControllerBase.RedirectToActionPermanent(string, string, object, string) ControllerBase.RedirectToActionPermanentPreserveMethod(string, string, object, string) ControllerBase.RedirectToRoute(string) ControllerBase.RedirectToRoute(object) ControllerBase.RedirectToRoute(string, object) ControllerBase.RedirectToRoute(string, string) ControllerBase.RedirectToRoute(string, object, string) ControllerBase.RedirectToRoutePreserveMethod(string, object, string) ControllerBase.RedirectToRoutePermanent(string) ControllerBase.RedirectToRoutePermanent(object) ControllerBase.RedirectToRoutePermanent(string, object) ControllerBase.RedirectToRoutePermanent(string, string) ControllerBase.RedirectToRoutePermanent(string, object, string) ControllerBase.RedirectToRoutePermanentPreserveMethod(string, object, string) ControllerBase.RedirectToPage(string) ControllerBase.RedirectToPage(string, object) ControllerBase.RedirectToPage(string, string) ControllerBase.RedirectToPage(string, string, object) ControllerBase.RedirectToPage(string, string, string) ControllerBase.RedirectToPage(string, string, object, string) ControllerBase.RedirectToPagePermanent(string) ControllerBase.RedirectToPagePermanent(string, object) ControllerBase.RedirectToPagePermanent(string, string) ControllerBase.RedirectToPagePermanent(string, string, string) ControllerBase.RedirectToPagePermanent(string, string, object, string) ControllerBase.RedirectToPagePreserveMethod(string, string, object, string) ControllerBase.RedirectToPagePermanentPreserveMethod(string, string, object, string) ControllerBase.File(byte[], string) ControllerBase.File(byte[], string, bool) ControllerBase.File(byte[], string, string) ControllerBase.File(byte[], string, string, bool) ControllerBase.File(byte[], string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.File(byte[], string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.File(byte[], string, string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.File(byte[], string, string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.File(Stream, string) ControllerBase.File(Stream, string, bool) ControllerBase.File(Stream, string, string) ControllerBase.File(Stream, string, string, bool) ControllerBase.File(Stream, string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.File(Stream, string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.File(Stream, string, string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.File(Stream, string, string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.File(string, string) ControllerBase.File(string, string, bool) ControllerBase.File(string, string, string) ControllerBase.File(string, string, string, bool) ControllerBase.File(string, string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.File(string, string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.File(string, string, string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.File(string, string, string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.PhysicalFile(string, string) ControllerBase.PhysicalFile(string, string, bool) ControllerBase.PhysicalFile(string, string, string) ControllerBase.PhysicalFile(string, string, string, bool) ControllerBase.PhysicalFile(string, string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.PhysicalFile(string, string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.PhysicalFile(string, string, string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.PhysicalFile(string, string, string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.Unauthorized() ControllerBase.Unauthorized(object) ControllerBase.NotFound() ControllerBase.NotFound(object) ControllerBase.BadRequest() ControllerBase.BadRequest(object) ControllerBase.BadRequest(ModelStateDictionary) ControllerBase.UnprocessableEntity() ControllerBase.UnprocessableEntity(object) ControllerBase.UnprocessableEntity(ModelStateDictionary) ControllerBase.Conflict() ControllerBase.Conflict(object) ControllerBase.Conflict(ModelStateDictionary) ControllerBase.Problem(string, string, int?, string, string) ControllerBase.Problem(string, string, int?, string, string, IDictionary<string, object>) ControllerBase.ValidationProblem(ValidationProblemDetails) ControllerBase.ValidationProblem(ModelStateDictionary) ControllerBase.ValidationProblem() ControllerBase.ValidationProblem(string, string, int?, string, string, ModelStateDictionary) ControllerBase.ValidationProblem(string, string, int?, string, string, ModelStateDictionary, IDictionary<string, object>) ControllerBase.Created() ControllerBase.Created(string, object) ControllerBase.Created(Uri, object) ControllerBase.CreatedAtAction(string, object) ControllerBase.CreatedAtAction(string, object, object) ControllerBase.CreatedAtAction(string, string, object, object) ControllerBase.CreatedAtRoute(string, object) ControllerBase.CreatedAtRoute(object, object) ControllerBase.CreatedAtRoute(string, object, object) ControllerBase.Accepted() ControllerBase.Accepted(object) ControllerBase.Accepted(Uri) ControllerBase.Accepted(string) ControllerBase.Accepted(string, object) ControllerBase.Accepted(Uri, object) ControllerBase.AcceptedAtAction(string) ControllerBase.AcceptedAtAction(string, string) ControllerBase.AcceptedAtAction(string, object) ControllerBase.AcceptedAtAction(string, string, object) ControllerBase.AcceptedAtAction(string, object, object) ControllerBase.AcceptedAtAction(string, string, object, object) ControllerBase.AcceptedAtRoute(object) ControllerBase.AcceptedAtRoute(string) ControllerBase.AcceptedAtRoute(string, object) ControllerBase.AcceptedAtRoute(object, object) ControllerBase.AcceptedAtRoute(string, object, object) ControllerBase.Challenge() ControllerBase.Challenge(params string[]) ControllerBase.Challenge(AuthenticationProperties) ControllerBase.Challenge(AuthenticationProperties, params string[]) ControllerBase.Forbid() ControllerBase.Forbid(params string[]) ControllerBase.Forbid(AuthenticationProperties) ControllerBase.Forbid(AuthenticationProperties, params string[]) ControllerBase.SignIn(ClaimsPrincipal) ControllerBase.SignIn(ClaimsPrincipal, string) ControllerBase.SignIn(ClaimsPrincipal, AuthenticationProperties) ControllerBase.SignIn(ClaimsPrincipal, AuthenticationProperties, string) ControllerBase.SignOut() ControllerBase.SignOut(AuthenticationProperties) ControllerBase.SignOut(params string[]) ControllerBase.SignOut(AuthenticationProperties, params string[]) ControllerBase.TryUpdateModelAsync<TModel>(TModel) ControllerBase.TryUpdateModelAsync<TModel>(TModel, string) ControllerBase.TryUpdateModelAsync<TModel>(TModel, string, IValueProvider) ControllerBase.TryUpdateModelAsync<TModel>(TModel, string, params Expression<Func<TModel, object>>[]) ControllerBase.TryUpdateModelAsync<TModel>(TModel, string, Func<ModelMetadata, bool>) ControllerBase.TryUpdateModelAsync<TModel>(TModel, string, IValueProvider, params Expression<Func<TModel, object>>[]) ControllerBase.TryUpdateModelAsync<TModel>(TModel, string, IValueProvider, Func<ModelMetadata, bool>) ControllerBase.TryUpdateModelAsync(object, Type, string) ControllerBase.TryUpdateModelAsync(object, Type, string, IValueProvider, Func<ModelMetadata, bool>) ControllerBase.TryValidateModel(object) ControllerBase.TryValidateModel(object, string) ControllerBase.HttpContext ControllerBase.Request ControllerBase.Response ControllerBase.RouteData ControllerBase.ModelState ControllerBase.ControllerContext ControllerBase.MetadataProvider ControllerBase.ModelBinderFactory ControllerBase.Url ControllerBase.ObjectValidator ControllerBase.ProblemDetailsFactory ControllerBase.User ControllerBase.Empty object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks This controller also demonstrates the per-request message-return pattern: each mutating action injects a fresh MessageCollector into the have-both project-level function (one taking IProgress<IMessage> messageProgress) and returns the collected IMessage items in its HTTP response. A REST / AI caller therefore sees the progress / success / error notifications inline in the response, rather than only out-of-band via the SignalR broadcast. The shared ApiActionResult envelope is also used by the session-scoped surface: RequireActiveSessionAttribute returns it (with HTTP 409) to answer a “no active session” call, rather than throwing a null-reference 500. Constructors LocalProjectServiceController(LocalProjectService) Initializes a new instance. Hi.MachiningProcs.LocalProjectServiceController.LocalProjectService is a DI singleton. public LocalProjectServiceController(LocalProjectService projectService) Parameters projectService LocalProjectService Methods EnableCollisionDetection(bool) Enables or disables collision detection and returns the messages reported during the call (e.g. the “preparing collision items” progress / done notifications). [HttpPost] public ApiActionResult EnableCollisionDetection(bool value) Parameters value bool Whether collision detection should be enabled. Returns ApiActionResult IsCollisionDetectionEnabled() Gets whether collision detection is currently enabled (project-level read; no session needed). [HttpGet] public bool IsCollisionDetectionEnabled() Returns bool SetMachiningResolution_mm(double) Sets the machining resolution (mm) and returns the messages reported during the call. [HttpPost] public ApiActionResult SetMachiningResolution_mm(double value) Parameters value double The machining resolution in millimeters. Returns ApiActionResult"
  },
  "api/Hi.MachiningProcs.MachiningActRunner.MachiningStepBuiltDelegate.html": {
    "href": "api/Hi.MachiningProcs.MachiningActRunner.MachiningStepBuiltDelegate.html",
    "title": "Delegate MachiningActRunner.MachiningStepBuiltDelegate | HiAPI-C# 2025",
    "summary": "Delegate MachiningActRunner.MachiningStepBuiltDelegate Namespace Hi.MachiningProcs Assembly HiMech.dll Delegate for configuring a step with previous and current step information. public delegate void MachiningActRunner.MachiningStepBuiltDelegate(MachiningStep preStep, MachiningStep curStep) Parameters preStep MachiningStep The previous milling step. curStep MachiningStep The current milling step. Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.MachiningProcs.MachiningActRunner.html": {
    "href": "api/Hi.MachiningProcs.MachiningActRunner.html",
    "title": "Class MachiningActRunner | HiAPI-C# 2025",
    "summary": "Class MachiningActRunner Namespace Hi.MachiningProcs Assembly HiMech.dll Represents a runner for machining actions that manages milling steps, tool paths, and collision detection. public class MachiningActRunner : IDisposable Inheritance object MachiningActRunner Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MachiningActRunner(Action<Exception>, Action<IEnumerable<MillingStepLuggage>>, Func<MachiningToolHouse>, Func<MachiningEquipment>, Func<WorkpieceService>, Action) Initializes a new instance. public MachiningActRunner(Action<Exception> reportException, Action<IEnumerable<MillingStepLuggage>> stepStorageWriter, Func<MachiningToolHouse> machiningToolHouseGetter, Func<MachiningEquipment> machiningEquipmentGetter, Func<WorkpieceService> workpieceServiceGetter, Action resetMillingStepLuggageDbAction) Parameters reportException Action<Exception> Error sink for the runner's background infrastructure tasks (bulk writer flush, attachment-memory loose runner) which run outside any single call. Request-scoped progress is passed by method argument, not held here. stepStorageWriter Action<IEnumerable<MillingStepLuggage>> The action to write milling step luggages to storage. machiningToolHouseGetter Func<MachiningToolHouse> The getter function for the machining tool house. machiningEquipmentGetter Func<MachiningEquipment> The getter function for the machining equipment. workpieceServiceGetter Func<WorkpieceService> The getter function for the workpiece runtime service. resetMillingStepLuggageDbAction Action Action to reset the milling step luggage database. Fields InternalMachiningStepBuilt Internal callback fired when a step is built (same timing as MachiningStepBuilt); used by host services before UI subscribers. public MachiningActRunner.MachiningStepBuiltDelegate InternalMachiningStepBuilt Field Value MachiningActRunner.MachiningStepBuiltDelegate Properties ClStrip Gets the cutter location strip. public ClStrip ClStrip { get; } Property Value ClStrip Config Gets or sets the runner configuration. public MachiningActRunnerConfig Config { get; set; } Property Value MachiningActRunnerConfig EnableMotionDependentMachiningResolution EnableMotionDependentMachiningResolution. It works on feed per cycle and feed per tooth motion resolution. MachiningResolution_mm changed by the LinearResolution_mm. public bool EnableMotionDependentMachiningResolution { get; set; } Property Value bool EnableSweeping Gets whether sweeping is enabled based on the motion resolution type. public bool EnableSweeping { get; } Property Value bool GrpcPostStepAction Gets or sets the action to be performed after each step for GRPC service. This is for internal use only. public static Action<MachiningStep> GrpcPostStepAction { get; set; } Property Value Action<MachiningStep> MachiningMotionResolution Gets or sets the machining motion resolution. public IMachiningMotionResolution MachiningMotionResolution { get; set; } Property Value IMachiningMotionResolution MachiningResolution_mm Gets or sets the preferred cube width for steps. public double MachiningResolution_mm { get; set; } Property Value double MachiningToolHouse Gets or sets the machining tool house. public MachiningToolHouse MachiningToolHouse { get; } Property Value MachiningToolHouse MachiningVolumeRemovalProc Gets the machining volume removal processor. public MachiningVolumeRemovalProc MachiningVolumeRemovalProc { get; } Property Value MachiningVolumeRemovalProc ShellThreadStepIndex The motion-step index currently managed on the shell session main thread — the index the next ClStripPos will receive, read straight from StripPosesCount (the strip is the single source of truth). Decoupled from the parallel-physics StepTaskBundle.StepIndex, which tracks a different (emit-thread) progress and may diverge. Use this to anchor a StepDiagnostic to its motion step. public int ShellThreadStepIndex { get; } Property Value int StateActRunner Gets the state act runner. This property is provided as a member value getter and should not be modified. public StateActRunner StateActRunner { get; } Property Value StateActRunner XyzabcChain Gets the XYZABC kinematic chain if the current machining chain supports it; otherwise null. public IXyzabcChain XyzabcChain { get; } Property Value IXyzabcChain Methods AdjustAptCutterStlResolutionByNcResolutionAndWorkpieceResolution() Adjusts the APT cutter STL resolution based on NC resolution and workpiece resolution. The derived value is runtime data: it is equipped by swapping the shaper and strut solids (SetShaperStlResolution(PolarResolution2d) / SetStrutStlResolution(PolarResolution2d)), never written onto the authored cutter. On the shipped configurations the derived value is constant within a play, so the repeated calls keep the same solid; with EnableMotionDependentMachiningResolution (an unshipped scripting switch, default false) the feed-derived value varies and each change swaps the solid — the mesh-rebuild cost is that mode's price. public void AdjustAptCutterStlResolutionByNcResolutionAndWorkpieceResolution() Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToActMcStep(IAct, StepDiagnosticProgress) Expands an act into machine control steps. public IEnumerable<IAct> ExpandToActMcStep(IAct act, StepDiagnosticProgress stepDiagnosticProgress) Parameters act IAct The act to expand. stepDiagnosticProgress StepDiagnosticProgress Progress sink for cutter-location strip / per-step updates. Returns IEnumerable<IAct> A sequence of machine control steps. GetMillingActRunner() Gets the current milling act runner instance. public MachiningActRunner GetMillingActRunner() Returns MachiningActRunner The current milling act runner instance. ProcAct(IAct, MachiningSession, IMachiningService, ISentenceCarrier, CancellationToken, StepDiagnosticProgress) Processes an act with the given parameters. public IEnumerable<object> ProcAct(IAct act, MachiningSession machiningSession, IMachiningService host, ISentenceCarrier sourceCommand, CancellationToken cancellationToken, StepDiagnosticProgress stepDiagnosticProgress) Parameters act IAct The act to process. machiningSession MachiningSession The milling session. host IMachiningService The milling step host. sourceCommand ISentenceCarrier The source command. cancellationToken CancellationToken The cancellation token. stepDiagnosticProgress StepDiagnosticProgress Progress sink for cutter-location strip / per-step updates. Returns IEnumerable<object> A sequence of processed objects. ResetMillingStepLuggageDb(StepDiagnosticProgress, IProgress<IMessage>) Resets the milling step luggage database. public void ResetMillingStepLuggageDb(StepDiagnosticProgress stepDiagnosticProgress, IProgress<IMessage> messageHost) Parameters stepDiagnosticProgress StepDiagnosticProgress The step-aligned IMessage-channel sink. messageHost IProgress<IMessage> Sink-agnostic IMessage host; injected by the caller, may be null outside a session. ResetStateAndClStrip(StepDiagnosticProgress, IProgress<IMessage>) Resets the state and cutter location strip. public void ResetStateAndClStrip(StepDiagnosticProgress stepDiagnosticProgress, IProgress<IMessage> messageHost) Parameters stepDiagnosticProgress StepDiagnosticProgress The step-aligned IMessage-channel sink. messageHost IProgress<IMessage> Sink-agnostic IMessage host; injected by the caller, may be null outside a session. UpdateByMachiningChain() Update By MachiningChain. Internal Use Only. public void UpdateByMachiningChain() UpdateByMachiningEquipment() Update By Hi.MachiningProcs.MachiningActRunner.MachiningEquipment. Internal Use Only. public void UpdateByMachiningEquipment() WaitAll() Waits for all pending operations to complete. public void WaitAll() WarnIfCurrentToolCutterGeometryUnreasonable(MachiningSession, StepDiagnosticProgress, int?) Emit one-shot session ConfigurationErrors naming the root cause when the currently equipped tool's MillingCutter has an unreasonable upper-beam / shank geometry (see GetUpperBeamGeometryIssues()) — e.g. an ExtendedCylinder beam whose FullLength sits below the flute height. Before this check, such a setting surfaced only as a per-step NullReferenceException cascade inside the thermal physics, with nothing naming the beam. Additionally emits a Cutter-Shank–ThermalModelUnavailable ConfigurationWarning when the shank thermal model cannot be built for a reason no geometry issue names (e.g. no beam configured at all) — this is the once-per-tool announcement of the silent per-step fallback in MillingTemperatureUtil.GetStepTemperature, which is deliberately quiet at the fallback site to avoid per-step message flooding. Gated by EnablePhysics; deduped per tool reference via WarnedCutterGeometryTools, mirroring WarnIfCurrentToolFluteMaterialMissing(MachiningSession, StepDiagnosticProgress, int?) (same two emission points: each IActTooling and BeginSession). public void WarnIfCurrentToolCutterGeometryUnreasonable(MachiningSession machiningSession, StepDiagnosticProgress stepDiagnosticProgress, int? toolId = null) Parameters machiningSession MachiningSession stepDiagnosticProgress StepDiagnosticProgress toolId int? WarnIfCurrentToolFluteCountZero(MachiningSession, StepDiagnosticProgress, int?) Emit a one-shot session warning if the currently equipped Hi.MachiningProcs.MachiningActRunner.MachiningEquipment.MachiningTool is a MillingCutter whose flute count resolves to zero (a null or empty Fluting). A zero flute count silently poisons the physics chain with nothing naming the tool: feed-per-tooth divides by zero, the force side fills Vec3d.NaN for every rotation division and the thermal side returns null. Gated by EnablePhysics; deduped per tool reference via WarnedFluteCountZeroTools, mirroring WarnIfCurrentToolFluteMaterialMissing(MachiningSession, StepDiagnosticProgress, int?) (same two emission points: each IActTooling and BeginSession). public void WarnIfCurrentToolFluteCountZero(MachiningSession machiningSession, StepDiagnosticProgress stepDiagnosticProgress, int? toolId = null) Parameters machiningSession MachiningSession stepDiagnosticProgress StepDiagnosticProgress toolId int? WarnIfCurrentToolFluteMaterialMissing(MachiningSession, StepDiagnosticProgress, int?) Emit a one-shot session warning if the currently equipped Hi.MachiningProcs.MachiningActRunner.MachiningEquipment.MachiningTool is a MillingCutter without a FluteMaterial. Gated by EnablePhysics; deduped per tool reference via WarnedFluteMaterialMissingTools so each offending tool is mentioned at most once per session. Pass toolId when known (e.g. from an IActTooling) and the warning will name the ID; omit it (the BeginSession path) and the warning falls back to “the currently equipped tool” — the equipped tool may have been set externally and not appear in MachiningToolHouse, so reverse-looking up an ID is unreliable and reference equality is the right unit of dedup anyway. public void WarnIfCurrentToolFluteMaterialMissing(MachiningSession machiningSession, StepDiagnosticProgress stepDiagnosticProgress, int? toolId = null) Parameters machiningSession MachiningSession stepDiagnosticProgress StepDiagnosticProgress toolId int? Events MachiningStepBuilt event to configure steps. The first parameter is the previous step; the second parameter is the current step. The previous step is null if no previous step exists. public event MachiningActRunner.MachiningStepBuiltDelegate MachiningStepBuilt Event Type MachiningActRunner.MachiningStepBuiltDelegate UiPostStepAction Event raised after each step for UI updates. This is for internal use only. public event Action<MachiningStep> UiPostStepAction Event Type Action<MachiningStep>"
  },
  "api/Hi.MachiningProcs.MachiningActRunnerConfig.html": {
    "href": "api/Hi.MachiningProcs.MachiningActRunnerConfig.html",
    "title": "Class MachiningActRunnerConfig | HiAPI-C# 2025",
    "summary": "Class MachiningActRunnerConfig Namespace Hi.MachiningProcs Assembly HiMech.dll Represents the configuration for a milling act runner. Provides settings for physics simulation, evaluation, and temperature control. public class MachiningActRunnerConfig : IMakeXmlSource Inheritance object MachiningActRunnerConfig Implements IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MachiningActRunnerConfig() Initializes a new instance. public MachiningActRunnerConfig() MachiningActRunnerConfig(XElement, string, IProgress<IMessage>) Initializes a new instance of the MachiningActRunnerConfig class from XML. public MachiningActRunnerConfig(XElement src, string baseDirectory, IProgress<IMessage> progress) Parameters src XElement The source XML element. baseDirectory string The base directory for resolving relative paths. progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. Properties EnableCollisionDetection Gets or sets whether collision detection is enabled. public bool EnableCollisionDetection { get; set; } Property Value bool EnableDeflectionTransformation Gets or sets whether deflection transformation is enabled. Note: This feature is pending testing. public bool EnableDeflectionTransformation { get; set; } Property Value bool EnableNativeMillingPhysics Gets or sets whether the per-step physics runs on the native (core.dll) kernels. Default is true, and in shipping builds the native kernel is the only physics implementation: setting this to false requires the managed reference implementation (not shipped; registered at startup by dev/test hosts) and throws without it. Both implementations produce the same results. Runtime-only (not persisted to project XML), in the EnableSoftNcRunner progressive-switch convention. Delegates to the kernel-level switch on EnableNativeMillingPhysics, which is process-global like RotationDivisionNum. public bool EnableNativeMillingPhysics { get; set; } Property Value bool EnablePauseOnFailure Enable Pause On Failure Detected. Only take effect if the EnableStrokeLimitCheck or EnableCollisionDetection is enabled. public bool EnablePauseOnFailure { get; set; } Property Value bool EnablePhysics Gets or sets whether milling force evaluation is enabled. public bool EnablePhysics { get; set; } Property Value bool EnableStrokeLimitCheck Gets or sets whether stroke limit checking is enabled. public bool EnableStrokeLimitCheck { get; set; } Property Value bool EnableWearEffect Gets or sets whether to enable coating wear effects. Note: This function is not fully prepared yet. Only affects further wear by the wear coefficient of inner material. public bool EnableWearEffect { get; set; } Property Value bool InitSpindleTemperature_C Gets or sets the initial spindle temperature in Celsius. public double InitSpindleTemperature_C { get; set; } Property Value double InitSpindleTemperature_K Gets or sets the initial spindle temperature in Kelvin. The temperature is initialized when a working session is restarted or a new session is started. public double InitSpindleTemperature_K { get; set; } Property Value double IsIdealOffsetDependentOnToolHouse Gets or sets whether the ideal tool offset is automatically populated from the tool house geometry before simulation. public bool IsIdealOffsetDependentOnToolHouse { get; set; } Property Value bool XName Gets the XML element name for serialization. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.MachiningProcs.MachiningParallelProc.StepTaskBundle.html": {
    "href": "api/Hi.MachiningProcs.MachiningParallelProc.StepTaskBundle.html",
    "title": "Class MachiningParallelProc.StepTaskBundle | HiAPI-C# 2025",
    "summary": "Class MachiningParallelProc.StepTaskBundle Namespace Hi.MachiningProcs Assembly HiMech.dll Represents a bundle of tasks related to a milling step. public class MachiningParallelProc.StepTaskBundle Inheritance object MachiningParallelProc.StepTaskBundle Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors StepTaskBundle(double, double) Initializes a new instance of the MachiningParallelProc.StepTaskBundle class with background and spindle temperatures. public StepTaskBundle(double backgroundTemperature_K, double spindleTemperature_K) Parameters backgroundTemperature_K double The background temperature in Kelvin. spindleTemperature_K double The spindle temperature in Kelvin. Properties MachineMotionStep Gets the machining step. public MachineMotionStep MachineMotionStep { get; } Property Value MachineMotionStep StepIndex Gets the index of the step. public int StepIndex { get; } Property Value int Methods Wait(CancellationToken) Waits for the completion of the post-sequential physics task. public void Wait(CancellationToken token) Parameters token CancellationToken The cancellation token."
  },
  "api/Hi.MachiningProcs.MachiningParallelProc.SubstractionResult.html": {
    "href": "api/Hi.MachiningProcs.MachiningParallelProc.SubstractionResult.html",
    "title": "Class MachiningParallelProc.SubstractionResult | HiAPI-C# 2025",
    "summary": "Class MachiningParallelProc.SubstractionResult Namespace Hi.MachiningProcs Assembly HiMech.dll Represents the result of a subtraction operation. public record MachiningParallelProc.SubstractionResult : IEquatable<MachiningParallelProc.SubstractionResult> Inheritance object MachiningParallelProc.SubstractionResult Implements IEquatable<MachiningParallelProc.SubstractionResult> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SubstractionResult(Substraction, ClStripPos) Represents the result of a subtraction operation. public SubstractionResult(Substraction Substraction, ClStripPos ClStripPos) Parameters Substraction Substraction ClStripPos ClStripPos Properties ClStripPos public ClStripPos ClStripPos { get; init; } Property Value ClStripPos Substraction public Substraction Substraction { get; init; } Property Value Substraction"
  },
  "api/Hi.MachiningProcs.MachiningParallelProc.html": {
    "href": "api/Hi.MachiningProcs.MachiningParallelProc.html",
    "title": "Class MachiningParallelProc | HiAPI-C# 2025",
    "summary": "Class MachiningParallelProc Namespace Hi.MachiningProcs Assembly HiMech.dll Represents a parallel processing system for milling operations that manages various tasks such as sweeping, subtraction, force calculation, and physics simulation. public class MachiningParallelProc : IDisposable Inheritance object MachiningParallelProc Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MachiningParallelProc(MachiningActRunner) Initializes a new instance of the MachiningParallelProc class. public MachiningParallelProc(MachiningActRunner millingActRunner) Parameters millingActRunner MachiningActRunner The machining act runner to manage milling operations. Properties MachiningActRunner Gets the machining act runner that manages the milling operations. public MachiningActRunner MachiningActRunner { get; } Property Value MachiningActRunner Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) Releases the unmanaged resources used by the MachiningParallelProc and optionally releases the managed resources. protected virtual void Dispose(bool disposing) Parameters disposing bool True to release both managed and unmanaged resources; false to release only unmanaged resources. WaitAll() Waits for all tasks to complete. public void WaitAll()"
  },
  "api/Hi.MachiningProcs.MachiningProject.html": {
    "href": "api/Hi.MachiningProcs.MachiningProject.html",
    "title": "Class MachiningProject | HiAPI-C# 2025",
    "summary": "Class MachiningProject Namespace Hi.MachiningProcs Assembly HiNc.dll Represents a milling project that manages the execution, simulation, and analysis of NC programs. public class MachiningProject : IDisposable, IMakeXmlSource, IMachiningProjectGetter Inheritance object MachiningProject Implements IDisposable IMakeXmlSource IMachiningProjectGetter Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MachiningProject(string) Initializes a new instance with the specified directory. public MachiningProject(string baseDirectory) Parameters baseDirectory string Base directory for file operations MachiningProject(XElement, string, IProgress<IMessage>) Initializes a new instance from XML data. public MachiningProject(XElement src, string baseDirectory, IProgress<IMessage> progress) Parameters src XElement XML element containing configuration data baseDirectory string Base directory for resolving relative paths progress IProgress<IMessage> Progress reporter for XML deserialization. Properties ApiVersion Gets the API version from the HiNc assembly (where MachiningProject is defined). public static Version ApiVersion { get; } Property Value Version BaseDirectory Gets the base directory where project files are located. public string BaseDirectory { get; } Property Value string ClsfRunnerSuit A third runner suit dedicated to the NX-CL (CLSF) pipeline (NxClRunner), held alongside the NC NcRunnerSuit and the CsvRunnerSuit. Backs LocalProjectService.ClRunner. public NcRunnerSuit ClsfRunnerSuit { get; set; } Property Value NcRunnerSuit CsvRunnerSuit A second runner suit dedicated to the CSV pipeline (the flagship GeneralCsvRunner), held alongside the NC NcRunnerSuit. Backs LocalProjectService.CsvRunner; the suit owns the CSV column config (replacing the former flat CsvRunnerConfig project member). public NcRunnerSuit CsvRunnerSuit { get; set; } Property Value NcRunnerSuit DictionaryColorGuide public DictionaryColorGuide DictionaryColorGuide { get; } Property Value DictionaryColorGuide MachiningActRunnerConfig Gets or sets the configuration for the milling act runner. public MachiningActRunnerConfig MachiningActRunnerConfig { get; set; } Property Value MachiningActRunnerConfig MachiningToolHouse Gets or sets the machining tool house containing tool configurations. public MachiningToolHouse MachiningToolHouse { get; set; } Property Value MachiningToolHouse MachiningToolHouseFile Gets or sets the file path to the milling tool house configuration. public string MachiningToolHouseFile { get; set; } Property Value string MillingGuide Gets or sets the milling guide containing visualization and analysis configurations. public MillingGuide MillingGuide { get; set; } Property Value MillingGuide NcEnv Gets or sets the NC environment settings. public HardNcEnv NcEnv { get; set; } Property Value HardNcEnv NcRunnerSuit The active runner suit — the per-machine SoftNcRunner (plus its optional side-file path) bundled with the per-workpiece PerCaseNcDependencyList its proxies resolve against. The suit is the proxies' INcDependencyListHost; swap the whole suit (e.g. via LocalProjectService.ReadNcRunnerSuit) to switch the active parser within a session. The project XML serializes the suit's two members flat for back-compat. public NcRunnerSuit NcRunnerSuit { get; set; } Property Value NcRunnerSuit PlayerCommand Gets the command to execute when playing the machining project. public ISessionCommand PlayerCommand { get; set; } Property Value ISessionCommand SetupEquipment The authored equipment face — the ONLY equipment face this project persists. The runtime face (MachiningEquipment) lives on LocalProjectService, materialised from this one, and never reaches the project file. public SetupEquipment SetupEquipment { get; set; } Property Value SetupEquipment TimeMapping Gets or sets the time mapping for synchronizing different time-based data streams. public TimeMapping TimeMapping { get; set; } Property Value TimeMapping XName Name for XML IO. public static string XName { get; } Property Value string Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool GetMachiningProject() Gets the MachiningProject instance. public MachiningProject GetMachiningProject() Returns MachiningProject The MachiningProject instance. GetSetupEquipment() Get SetupEquipment — the authored equipment face. public SetupEquipment GetSetupEquipment() Returns SetupEquipment SetupEquipment LoadFile(string, IProgress<IMessage>) Loads a machining project from the specified file path. public static MachiningProject LoadFile(string projectFilePath, IProgress<IMessage> progress) Parameters projectFilePath string Path to the project file to load progress IProgress<IMessage> Progress reporter for XML deserialization. Returns MachiningProject A new machining project instance loaded from the file MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer (and its legacy aliases) with the given XFactory (or Default when factory is null), and chains Reg(factory) on dependents so the registration graph is observable. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.MachiningProcs.MachiningSession.html": {
    "href": "api/Hi.MachiningProcs.MachiningSession.html",
    "title": "Class MachiningSession | HiAPI-C# 2025",
    "summary": "Class MachiningSession Namespace Hi.MachiningProcs Assembly HiMech.dll Represents a machining session that manages the execution and optimization of machining operations. Provides functionality for controlling the machining process, handling optimization options, and managing session state. Implements IDisposable to clean up SessionWriters on session end. public class MachiningSession : IDisposable Inheritance object MachiningSession Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MachiningSession(IMachiningService) Creates a machining session bound to its hosting IMachiningService. public MachiningSession(IMachiningService host) Parameters host IMachiningService Properties CurrentSourceCommand Gets or sets the current source command being processed. public IIndexedFileLine CurrentSourceCommand { get; set; } Property Value IIndexedFileLine FileIndexOnRunCommand File index counter, auto-incremented per RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) call within this session. Legacy use only. Read and incremented by HardNcRunner and CsvRunner. SoftNcRunner no longer touches this field — it allocates file indices through FileIndexCounterDependency, which both the runner and inlined-subprogram syntaxes (SubProgramCallSyntax) share so every loaded file (top-level program plus every M98 / M198 inline, including each L repetition) gets a distinct index. Do not introduce new readers; the field will be removed once the legacy runners retire. public int FileIndexOnRunCommand { get; set; } Property Value int Host The project-level service hosting this session — injected so the session can reach project-level resources (act runner, NC runners, player, sinks, base directory, …) it needs to run NC program lines. public IMachiningService Host { get; } Property Value IMachiningService IsNcOptOptionListUpdatedByStep Internal Use Only. public bool IsNcOptOptionListUpdatedByStep { get; set; } Property Value bool IsRunningNcLines True while an NC program file is actively being played through the runner (the paced PlayNcFile(string, string, NcKind) loop). A runner-suit switch must not run while this is true: the runner's RunNcLines iterator is mid-enumeration and holds this session's SyntaxPieceLayers, so resetting NcRunnerSessionState underneath it would corrupt the in-flight walk. The switch entry point checks this and refuses otherwise. public bool IsRunningNcLines { get; } Property Value bool IsSteppingSentence True while the player is stepping sentence-by-sentence (pauses at each source-command boundary). Session-run state. public bool IsSteppingSentence { get; set; } Property Value bool NcConversions Writeback conversions retained from the latest ConvertClToNcFiles(string, string, IProgress<IMessage>) run (one per written NC file, in written order): the destination SyntaxPiece streams plus the src↔dst Hi.NcParsers.NcWriteback.NcPieceMaps. This is the hook point for GUI cross-navigation (click a source line ↔ jump to its converted lines). Cleared at the start of each conversion run. public List<NcConversion> NcConversions { get; } Property Value List<NcConversion> NcOptOption Gets or sets the NC optimization options for UI operations. public NcOptOption NcOptOption { get; set; } Property Value NcOptOption NcOptimizations Writeback conversions retained from the latest OptimizeNcFiles(string, string, ICuttingPara, IProgress<IMessage>, CancellationToken, Func<int, MillingStepLuggage>, Action) run (one per written optimized NC file, in written order): the destination SyntaxPiece streams plus the src↔dst Hi.NcParsers.NcWriteback.NcPieceMaps, for GUI cross-navigation. Deliberately separate from NcConversions so a conversion run and an optimization run do not clear each other's results. Cleared at the start of each optimization run. public List<NcConversion> NcOptimizations { get; } Property Value List<NcConversion> NcRunnerSessionState Per-session NC pipeline state shared across RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) calls. Holds lazy-initialized NcDiagnosticProgress and the per-layer LazyLinkedList<T> chain used for cross-file modal continuity. public NcRunnerSessionState NcRunnerSessionState { get; } Property Value NcRunnerSessionState PacePlayee Internal set only. public PacePlayee PacePlayee { get; set; } Property Value PacePlayee PostBlockScripts Per-line scripts injected externally (without modifying NC files). Key: FileLineIndex of the NC block. Value: C# script text to execute after the NC block. Consumed by CsScriptEndSemantic. public Dictionary<FileLineIndex, string> PostBlockScripts { get; } Property Value Dictionary<FileLineIndex, string> PreBlockScripts Per-line scripts injected externally (without modifying NC files). Key: FileLineIndex of the NC block. Value: C# script text to execute before the NC block. Consumed by CsScriptBeginSemantic. public Dictionary<FileLineIndex, string> PreBlockScripts { get; } Property Value Dictionary<FileLineIndex, string> SessionWriters StreamWriters registered during the session (e.g. by diagnostic output methods). Key: relative output file path. Disposed automatically when the session ends. public Dictionary<string, StreamWriter> SessionWriters { get; } Property Value Dictionary<string, StreamWriter> ShellProgress Session-level routine / lifecycle message sink on the IMessage channel (cache reset, file progress, session start/done). Owned here so it is truly session-scoped — created with the session, released at EndSession. public ShellProgress ShellProgress { get; } Property Value ShellProgress StepIndexToNcOptOptionSortedList Gets or sets the mapping of step indices to NC optimization options. For internal use only. Takes effect during internal optimization process. public SortedList<int, NcOptOption> StepIndexToNcOptOptionSortedList { get; set; } Property Value SortedList<int, NcOptOption> StepTaskBundle Gets or sets the current step task bundle. public MachiningParallelProc.StepTaskBundle StepTaskBundle { get; set; } Property Value MachiningParallelProc.StepTaskBundle WarnedCutterGeometryTools Tools already surfaced via an unreasonable cutter-geometry ConfigurationError (see WarnIfCurrentToolCutterGeometryUnreasonable(MachiningSession, StepDiagnosticProgress, int?)). Same keying and emission-point rationale as WarnedFluteMaterialMissingTools. public HashSet<IMachiningTool> WarnedCutterGeometryTools { get; } Property Value HashSet<IMachiningTool> WarnedFluteCountZeroTools Tools already surfaced via a zero-flute-count ConfigurationWarning (see WarnIfCurrentToolFluteCountZero(MachiningSession, StepDiagnosticProgress, int?)). Same keying and emission-point rationale as WarnedFluteMaterialMissingTools. public HashSet<IMachiningTool> WarnedFluteCountZeroTools { get; } Property Value HashSet<IMachiningTool> WarnedFluteMaterialMissingTools Tools already surfaced via “FluteMaterial not set” warning. Keyed by IMachiningTool reference so the dedup is stable across the two emission points: ProcAct(IAct, MachiningSession, IMachiningService, ISentenceCarrier, CancellationToken, StepDiagnosticProgress) at each IActTooling, and BeginSession for the tool that may already be equipped before the session begins (which has no tool ID to dedup with). Reference equality is more precise than tool ID — the same tool object equipped twice should warn once, regardless of how it was reached. public HashSet<IMachiningTool> WarnedFluteMaterialMissingTools { get; } Property Value HashSet<IMachiningTool> Methods BeginPreserve() Begins a preserve section in the optimization process. public void BeginPreserve() ConvertClToNcFiles(string, string, IProgress<IMessage>) Converts the CLSF play of this session into Fanuc NC files — writeback synthesis mode, two stages (Hi.NcParsers.NcWriteback.NcSynthesisConverter over Hi.NcParsers.NcWriteback.FanucNcSentenceComposer): walks the final SyntaxPieceLayers layer, groups pieces per source file, converts each group into a destination piece stream with the src↔dst map (stage one; retained in NcConversions), and serializes the destination stream to text (stage two, ToLines(IEnumerable<SyntaxPiece>)). The synthesis re-serializes the brand-neutral sections into Fanuc vocabulary (MSYS tilt → G68.2, RTCP → G43.4, motions → G00/G01/G02/G03 with rotary words). Requires a prior play (e.g. PlayClFile(string, string)) on an XYZABC machine chain — a pure-CL milling device leaves no machine-solved sections to serialize. Conversion diagnostics go to the manipulation home (NcManipulationDiagnosticProgress, cleared at run start) — not to the play-time NcDiagnosticProgress. GUI consumers observe that home directly (webservice: NC Manipulation message tab); messageProgress carries only the lifecycle messages. public IReadOnlyList<string> ConvertClToNcFiles(string baseDirectory, string relNcFileTemplate = \"Output/[NcName].nc\", IProgress<IMessage> messageProgress = null) Parameters baseDirectory string Project root; null falls back to BaseDirectory. relNcFileTemplate string Output path template; [NcName] is replaced by the source file name, [NcFile] by its slash-flattened relative path. messageProgress IProgress<IMessage> Optional message sink for lifecycle reporting; session callers inject the shell sink, out-of-session callers pass their own (or null). Returns IReadOnlyList<string> Written NC file paths, relative to baseDirectory. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() EndPreserve() Ends a preserve section in the optimization process. public void EndPreserve() GetToolPhysicsPack(int) Gets the frozen physics pack for a tool id — building it on first access — or null when the id is not in the tool house. The para-dependent members are keyed to the current workpiece cutting para. Safe to call from parallel step tasks: the pack is immutable and published atomically, and a concurrent rebuild computes identical content. public MillingToolPhysicsPack GetToolPhysicsPack(int toolId) Parameters toolId int The tool-house id of the tool. Returns MillingToolPhysicsPack The frozen pack, or null for an unknown tool id. InvalidateToolPhysicsPacks() Drops every cached physics pack so the next access rebuilds from the live objects. Called by the paths that know the tool/cutter/para state may have changed: every run-op start (RunNcLines(INcRunner, string, IEnumerable<string>, CancellationToken), so edits made between plays always take effect) and the tool-change act. An editor that must take effect in the middle of a running play calls this explicitly — otherwise a mid-play edit lands on the next play, which is also the only mode with a deterministic outcome. public void InvalidateToolPhysicsPacks() OptimizeNcFiles(string, string, ICuttingPara, IProgress<IMessage>, CancellationToken, Func<int, MillingStepLuggage>, Action) Optimizes the NC program played in this session (SoftNc pipeline) and writes the optimized NC files: classifies the final SyntaxPieceLayers layer, solves the per-step feed adjustments from milling physics, patches the F words onto the verbatim source text and writes one output file per source NC file by relNcFileTemplate. Conversions are retained in NcOptimizations; piece-anchored diagnostics go to the manipulation home (NcManipulationDiagnosticProgress, cleared at run start). Requires a prior play and a logged-in OptNcNoLimit license. public List<string> OptimizeNcFiles(string baseDirectory, string relNcFileTemplate, ICuttingPara millingPara, IProgress<IMessage> messageProgress, CancellationToken cancellationToken, Func<int, MillingStepLuggage> luggageGetter = null, Action clearLuggageCache = null) Parameters baseDirectory string Project root; null falls back to BaseDirectory. relNcFileTemplate string Output path template; [NcName] is replaced by the source file name, [NcFile] by its slash-flattened relative path. millingPara ICuttingPara The cutting parameters; null disables physics-computable optimization. messageProgress IProgress<IMessage> Optional message sink for lifecycle / progress reporting. cancellationToken CancellationToken Cancellation token to cancel the operation. luggageGetter Func<int, MillingStepLuggage> Optional thread-safe map from step index to MillingStepLuggage; defaults to MillingStepLuggageReader. clearLuggageCache Action Optional end-of-run cache clear hook; defaults to the luggage reader's cache clear. Returns List<string> Written NC file paths, relative to baseDirectory. PlayBrandNcFile(string, string) Plays a famous-brand NC code file with pace control (no kind dispatch — always ActiveNcRunner). public void PlayBrandNcFile(string baseDirectory, string relFilePath) Parameters baseDirectory string relFilePath string PlayClFile(string, string) Plays an NX-CL (CLSF) file with pace control. public void PlayClFile(string baseDirectory, string relFilePath) Parameters baseDirectory string relFilePath string PlayCsvFile(string, string) Plays a CSV file with pace control. public void PlayCsvFile(string baseDirectory, string relFilePath) Parameters baseDirectory string relFilePath string PlayNc(string, string) Plays NC text with pace control. public void PlayNc(string ncText, string fileNameAlternative = \"--\") Parameters ncText string fileNameAlternative string PlayNcFile(string, string, NcKind) Plays an NC program file with pace control, the runner picked by kind (Auto = by file extension, see DetectByPath(string)). public void PlayNcFile(string baseDirectory, string relFilePath, NcKind kind = NcKind.Auto) Parameters baseDirectory string relFilePath string kind NcKind Preserve() Preserves one line of NC code in the optimization process. public void Preserve() RunBrandNcFile(string, string) Runs a famous-brand NC code file (no pacing, no kind dispatch — always ActiveNcRunner); returns the player actions. public IEnumerable<Action> RunBrandNcFile(string baseDirectory, string relFilePath) Parameters baseDirectory string relFilePath string Returns IEnumerable<Action> RunClFile(string, string) Runs an NX-CL (CLSF) file (no pacing); returns the player actions. public IEnumerable<Action> RunClFile(string baseDirectory, string relFilePath) Parameters baseDirectory string relFilePath string Returns IEnumerable<Action> RunCsvFile(string, string) Runs a CSV file (no pacing); returns the player actions. public IEnumerable<Action> RunCsvFile(string baseDirectory, string relFilePath) Parameters baseDirectory string relFilePath string Returns IEnumerable<Action> RunMachiningStepBuilt(MachiningStep, MachiningStep) Internal use only. Invokes MachiningStepBuilt. public void RunMachiningStepBuilt(MachiningStep preStep, MachiningStep curStep) Parameters preStep MachiningStep curStep MachiningStep RunMachiningStepSelected(MachiningStep) Internal use only. Invokes MachiningStepSelected. public void RunMachiningStepSelected(MachiningStep machiningStep) Parameters machiningStep MachiningStep RunNc(string, string) Runs NC text (no pacing); returns the player actions. public IEnumerable<Action> RunNc(string ncText, string fileNameAlternative = \"--\") Parameters ncText string fileNameAlternative string Returns IEnumerable<Action> RunNcFile(string, string, NcKind) Runs an NC program file (no pacing), the runner picked by kind (Auto = by file extension, see DetectByPath(string)); returns the player actions. public IEnumerable<Action> RunNcFile(string baseDirectory, string relFilePath, NcKind kind = NcKind.Auto) Parameters baseDirectory string relFilePath string kind NcKind Returns IEnumerable<Action> RunNcFileRan() Internal use only. Invokes NcFileRan. public void RunNcFileRan() RunNcLines(INcRunner, string, IEnumerable<string>, CancellationToken) Runs the NC program lines through ncRunner, producing the player actions. Session-scoped run loop; reaches project-level resources via Host. public IEnumerable<Action> RunNcLines(INcRunner ncRunner, string relNcFilePath, IEnumerable<string> lines, CancellationToken cancellationToken) Parameters ncRunner INcRunner The NC runner that parses and runs the lines. relNcFilePath string Name/path associated with the program. lines IEnumerable<string> The NC/CSV lines to run. cancellationToken CancellationToken Cancellation token. Returns IEnumerable<Action> The sequence of player actions. RunSourcedActEntry(SourcedActEntry) Internal use only. Invokes SourcedActEntry. public void RunSourcedActEntry(SourcedActEntry entry) Parameters entry SourcedActEntry RunSyntaxPieceRan(SyntaxPiece) Internal use only. Invokes SyntaxPieceRan. public void RunSyntaxPieceRan(SyntaxPiece syntaxPiece) Parameters syntaxPiece SyntaxPiece UpdateNcOptOptionMapIfNeeded(int) Records the current NcOptOption at stepIndex when it differs from the most recently recorded one, so the map stays a sparse list of change points — which is what its readers expect: they resolve a step's option by GetFloor (see UpdateNcOptOption(Action<NcOptOption>) and the optimization procs), so an unchanged stretch needs no entries at all. Internal use only. public bool UpdateNcOptOptionMapIfNeeded(int stepIndex) Parameters stepIndex int The index of the step to update. Returns bool True if the map was updated; otherwise, false. Events MachiningStepBuilt Event triggered when a machining step is built. public event MachiningActRunner.MachiningStepBuiltDelegate MachiningStepBuilt Event Type MachiningActRunner.MachiningStepBuiltDelegate MachiningStepSelected Event triggered when a machining step is selected. public event Action<MachiningStep> MachiningStepSelected Event Type Action<MachiningStep> NcFileRan Event triggered after an NC/CSV file finishes running (session-scoped). Bridged to the app-lifetime LocalProjectService.OnNcFileRan in BeginSession. public event Action NcFileRan Event Type Action OnCurrentLineEnd Event raised when the current line ends. The event buffer is cleared on every line change. public event Action<CancellationToken> OnCurrentLineEnd Event Type Action<CancellationToken> SourcedActEntry Event triggered for each SourcedActEntry produced during NC/CSV execution. public event Action<SourcedActEntry> SourcedActEntry Event Type Action<SourcedActEntry> SyntaxPieceRan Event triggered when a syntax piece has been executed. public event Action<SyntaxPiece> SyntaxPieceRan Event Type Action<SyntaxPiece>"
  },
  "api/Hi.MachiningProcs.MessageDto.html": {
    "href": "api/Hi.MachiningProcs.MessageDto.html",
    "title": "Class MessageDto | HiAPI-C# 2025",
    "summary": "Class MessageDto Namespace Hi.MachiningProcs Assembly HiNc.dll One reported IMessage, flattened for JSON transport. public record MessageDto : IEquatable<MessageDto> Inheritance object MessageDto Implements IEquatable<MessageDto> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MessageDto(string, string, string, string) One reported IMessage, flattened for JSON transport. public MessageDto(string Severity, string Category, string Id, string Notification) Parameters Severity string The importance level (Message / Success / Progress / Warning / Error). Category string The classification (System / Unsupported / Validation / Configuration). Id string The structured id used for filtering / suppression; may be null. Notification string The end-user friendly text. Properties Category The classification (System / Unsupported / Validation / Configuration). public string Category { get; init; } Property Value string Id The structured id used for filtering / suppression; may be null. public string Id { get; init; } Property Value string Notification The end-user friendly text. public string Notification { get; init; } Property Value string Severity The importance level (Message / Success / Progress / Warning / Error). public string Severity { get; init; } Property Value string Methods From(IMessage) Flattens one IMessage into a transport DTO. public static MessageDto From(IMessage message) Parameters message IMessage The message to flatten. Returns MessageDto The flattened DTO."
  },
  "api/Hi.MachiningProcs.MillingUtil.html": {
    "href": "api/Hi.MachiningProcs.MillingUtil.html",
    "title": "Class MillingUtil | HiAPI-C# 2025",
    "summary": "Class MillingUtil Namespace Hi.MachiningProcs Assembly HiMech.dll Provides utility methods for milling calculations and operations. public static class MillingUtil Inheritance object MillingUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetFeedPerCycle_mm(double, double) Calculates the feed per cycle in millimeters. public static double GetFeedPerCycle_mm(double feedrate_mmds, double spindleSpeed_radds) Parameters feedrate_mmds double The feed rate in millimeters per second. spindleSpeed_radds double The spindle speed in radians per second. Returns double The feed per cycle in millimeters. GetFeedPerTooth_mm(double, double, int) Calculates the feed per tooth in millimeters. public static double GetFeedPerTooth_mm(double feedrate_mmds, double spindleSpeed_radds, int fluteNum) Parameters feedrate_mmds double The feed rate in millimeters per second. spindleSpeed_radds double The spindle speed in radians per second. fluteNum int The number of flutes on the tool. Returns double The feed per tooth in millimeters. GetFeedrate_mmds(double, double, int) Calculates the feed rate in millimeters per second. public static double GetFeedrate_mmds(double feedPerTooth_mmdrev, double spindleSpeed_radds, int fluteNum) Parameters feedPerTooth_mmdrev double The feed per tooth in millimeters per revolution. spindleSpeed_radds double The spindle speed in radians per second. fluteNum int The number of flutes on the tool. Returns double The feed rate in millimeters per second. GetFluteZToDzListByGapResolutionSwitch(SortedList<double, double>, double, Box3d, List<PairZr>) Gets a list of Z coordinates and their corresponding delta Z values for flute engagement, with resolution switching based on chip height. public static SortedList<double, double> GetFluteZToDzListByGapResolutionSwitch(SortedList<double, double> fluteZToDzListByWorkpieceResolution, double workpieceResolution, Box3d boundingBoxOnToolRunningCoordinate, List<PairZr> fluteZAscendentZrContour) Parameters fluteZToDzListByWorkpieceResolution SortedList<double, double> The initial list of Z coordinates and delta Z values based on workpiece resolution. workpieceResolution double The resolution of the workpiece. boundingBoxOnToolRunningCoordinate Box3d The bounding box of the tool path in tool running coordinates. fluteZAscendentZrContour List<PairZr> The ascending Z coordinates of the flute contour. Returns SortedList<double, double> A sorted list of Z coordinates and their corresponding delta Z values."
  },
  "api/Hi.MachiningProcs.NcKind.html": {
    "href": "api/Hi.MachiningProcs.NcKind.html",
    "title": "Enum NcKind | HiAPI-C# 2025",
    "summary": "Enum NcKind Namespace Hi.MachiningProcs Assembly HiMech.dll Kind of an NC program file — selects which of the session's runners plays it (ActiveNcRunner / ClRunner / CsvRunner). public enum NcKind Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Auto = 0 Detect from the file extension — see DetectByPath(string). BrandNc = 1 Famous-brand controller code (G-code dialects) — the catch-all default. Cl = 2 NX-CL (CLSF) cutter-location file. Csv = 3 CSV control table. Remarks Vocabulary note: Nc is the umbrella term for any machine-readable program the session can play (brand controller code, CL, CSV — matching INcRunner / RunNcFile); BrandNc is the narrow term for the famous-brand controller dialects (Fanuc / Siemens / Heidenhain G-code families)."
  },
  "api/Hi.MachiningProcs.NcKindUtil.html": {
    "href": "api/Hi.MachiningProcs.NcKindUtil.html",
    "title": "Class NcKindUtil | HiAPI-C# 2025",
    "summary": "Class NcKindUtil Namespace Hi.MachiningProcs Assembly HiMech.dll NcKind helpers. public static class NcKindUtil Inheritance object NcKindUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods DetectByPath(string) Detects an NC program file's NcKind from its extension. CL (.cl / .cls / .clsf) and CSV (.csv) are closed extension sets; everything else — the open world of brand controller extensions (.nc, .ptp, .tap, .h, …) — maps to BrandNc, so an exotic brand extension can never be misrouted. public static NcKind DetectByPath(string filePath) Parameters filePath string Returns NcKind"
  },
  "api/Hi.MachiningProcs.NcRunnerSessionState.html": {
    "href": "api/Hi.MachiningProcs.NcRunnerSessionState.html",
    "title": "Class NcRunnerSessionState | HiAPI-C# 2025",
    "summary": "Class NcRunnerSessionState Namespace Hi.MachiningProcs Assembly HiMech.dll NC pipeline state held on a MachiningSession and shared across multiple RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) calls within that session. The per-layer SyntaxPieceLayers are extended via AppendSource(IEnumerable<T>) for each subsequent file so that Previous/Next connectivity (and thus ModalCarrySyntax deep-clone) crosses file boundaries. public sealed class NcRunnerSessionState : IDisposable Inheritance object NcRunnerSessionState Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties EffectiveNcDependencyList Proxy-resolved dependency list — output of GetEffectiveNcDependencyList(), computed once on the first RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) call and reused for every file and pipeline stage in the session so each INcDependencyProxy resolves to one stable instance. Set only by RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) (and cleared by Reset()); readable for inspection. public List<INcDependency> EffectiveNcDependencyList { get; } Property Value List<INcDependency> EffectiveNcInitializationList Session-scoped initializer list used to seed the init SyntaxPiece — gated like EffectiveNcSyntaxList. public List<INcInitializer> EffectiveNcInitializationList { get; } Property Value List<INcInitializer> EffectiveNcSemanticList Session-scoped semantic list actually driven over the final syntax layer — gated like EffectiveNcSyntaxList. public List<INcSemantic> EffectiveNcSemanticList { get; } Property Value List<INcSemantic> EffectiveNcSyntaxList Session-scoped syntax list actually driven by the layer pipeline — stamped at session initialization by ResolveEffectivePipeline(SoftNcRunner, NcRunnerSessionState, NcDiagnosticProgress). Same reference as NcSyntaxList unless the composition gate skipped external units for this session; the runner's persisted list is never mutated. public List<INcSyntax> EffectiveNcSyntaxList { get; } Property Value List<INcSyntax> EffectiveSegmenter Session-scoped segmenter actually used to split NC text — the runner's own Segmenter, or the built-in fallback when the composition gate rejected an external one. public ISegmenter EffectiveSegmenter { get; } Property Value ISegmenter FreezeExecutedPieces Whether executed SyntaxPieces are frozen to their compact UTF-8 form (Freeze()) once they leave the executing window. Default true — a session retains every executed piece for its whole lifetime, and the live JsonObject graph costs ~13× the frozen bytes (multi-million-line programs OOM a client machine without this). Set false only for A/B measurement or when a custom post-play consumer must mutate executed pieces in place. public bool FreezeExecutedPieces { get; set; } Property Value bool InitializedByNcRunner The runner whose first RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) call built the pipeline. The layer count and the cached EffectiveNcDependencyList are sized/bound to THIS runner, so a subsequent call from a DIFFERENT runner (e.g. a CSV play after a brand-NC play in the same session) must be refused — it would index past the layer list or silently run with the wrong dependency list. Cleared by Reset(). public INcRunner InitializedByNcRunner { get; } Property Value INcRunner IsInitialized True after the first call has built the layered pipeline. public bool IsInitialized { get; } Property Value bool SyntaxPieceLayers One LazyLinkedList<T> per pipeline layer. Index 0 is the source layer (init seed + sentence-derived pieces); indices 1..NcSyntaxList.Count are the post-NcSyntax layers. Subsequent RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) calls extend each layer in place via AppendSource(IEnumerable<T>). public List<LazyLinkedList<SyntaxPiece>> SyntaxPieceLayers { get; set; } Property Value List<LazyLinkedList<SyntaxPiece>> Methods DeferFreeze(SyntaxPiece) Hands an executed piece to the deferred-freeze window: it stays live for the next Hi.MachiningProcs.NcRunnerSessionState.FreezeLagPieceCount piece boundaries, then freezes. No-op when FreezeExecutedPieces is false or piece is null. Called by RunNcLines(INcRunner, string, IEnumerable<string>, CancellationToken) at each source-command boundary — the point where the previous piece's syntax builds and semantics have all completed. public void DeferFreeze(SyntaxPiece piece) Parameters piece SyntaxPiece Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() FlushDeferredFreezes() Freezes everything still in the deferred-freeze window. Called at the end-of-play action (after the act runner's WaitAll) so a finished play retains only frozen pieces; when FreezeExecutedPieces is false the window is just dropped. public void FlushDeferredFreezes() Reset() Drops the per-layer pipeline state so the next RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) call re-builds from scratch. Use this for a controller power reset (where in-flight SyntaxPiece JSON dataflow — including Vars.Volatile, modal carries, and the init seed — must vanish) without disposing the owning MachiningSession itself. Idempotent and reusable: after Reset() the object is in the same lazy-uninitialised state as a freshly constructed instance, so the first subsequent RunNcLines hits the !IsInitialized branch and re-creates everything. public void Reset()"
  },
  "api/Hi.MachiningProcs.ProjectFileBusyException.html": {
    "href": "api/Hi.MachiningProcs.ProjectFileBusyException.html",
    "title": "Class ProjectFileBusyException | HiAPI-C# 2025",
    "summary": "Class ProjectFileBusyException Namespace Hi.MachiningProcs Assembly HiNc.dll Thrown when a project-file operation (New / Load / Save / SaveAs / Reload) is requested while another one is already in progress. The newcomer is cancelled rather than queued; controllers surface this as HTTP 409 Conflict. public sealed class ProjectFileBusyException : Exception, ISerializable Inheritance object Exception ProjectFileBusyException Implements ISerializable Inherited Members Exception.GetBaseException() Exception.GetType() Exception.ToString() Exception.Data Exception.HelpLink Exception.HResult Exception.InnerException Exception.Message Exception.Source Exception.StackTrace Exception.TargetSite object.Equals(object) object.Equals(object, object) object.GetHashCode() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ProjectFileBusyException() Initializes a new instance with the default busy message. public ProjectFileBusyException()"
  },
  "api/Hi.MachiningProcs.ProxyProjectService.html": {
    "href": "api/Hi.MachiningProcs.ProxyProjectService.html",
    "title": "Class ProxyProjectService | HiAPI-C# 2025",
    "summary": "Class ProxyProjectService Namespace Hi.MachiningProcs Assembly HiNc.dll Delegate (User-based) Project Service. Apply relative file path from AdminDirectory. public class ProxyProjectService : IProjectService, IMachiningProjectGetter Inheritance object ProxyProjectService Implements IProjectService IMachiningProjectGetter Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ProxyProjectService(LocalProjectService, ProxyConfig) Initializes a new instance of the ProxyProjectService class. public ProxyProjectService(LocalProjectService localProjectService, ProxyConfig proxyConfig) Parameters localProjectService LocalProjectService The local project service. proxyConfig ProxyConfig The proxy configuration options. Properties AdminDirectory Gets the admin directory path from the proxy configuration. public string AdminDirectory { get; set; } Property Value string LocalProjectService Gets the local project service instance. public LocalProjectService LocalProjectService { get; } Property Value LocalProjectService ProxyConfig Gets the proxy configuration options. public ProxyConfig ProxyConfig { get; } Property Value ProxyConfig RelativeProjectPath Gets the project path relative to the AdminDirectory. public string RelativeProjectPath { get; } Property Value string Methods CloseProject() Closes the current project. public void CloseProject() GetLocalProjectService() Get Local Project Service as base-service. public LocalProjectService GetLocalProjectService() Returns LocalProjectService Local Project Service GetMachiningProject() Gets the MachiningProject instance. public MachiningProject GetMachiningProject() Returns MachiningProject The MachiningProject instance. LoadProject(string, IProgress<IMessage>) Loads a project by file path relative to the admin directory. public void LoadProject(string relativeFilePath, IProgress<IMessage> messageProgress = null) Parameters relativeFilePath string The relative file path from the admin directory root messageProgress IProgress<IMessage> Optional caller-injected sink for the load-time diagnostics (see LoadProject(string, IProgress<IMessage>)); null keeps logger-only reporting. NewProject(string) Creates a new project by file path relative to the admin directory. public void NewProject(string relativeFilePath) Parameters relativeFilePath string The relative file path from the admin directory ReloadProject(IProgress<IMessage>) Reloads the current project. public void ReloadProject(IProgress<IMessage> messageProgress = null) Parameters messageProgress IProgress<IMessage> Optional caller-injected sink for the load-time diagnostics (see ReloadProject(IProgress<IMessage>)); null keeps logger-only reporting. SaveAsProject(string) Saves the current project to a specified relative file path. public void SaveAsProject(string relativeFilePath) Parameters relativeFilePath string The relative file path from the admin directory root SaveProject() Saves the current project. public void SaveProject()"
  },
  "api/Hi.MachiningProcs.RenderingFlag.html": {
    "href": "api/Hi.MachiningProcs.RenderingFlag.html",
    "title": "Enum RenderingFlag | HiAPI-C# 2025",
    "summary": "Enum RenderingFlag Namespace Hi.MachiningProcs Assembly HiNc.dll Flags that control which elements are rendered in the visualization. public enum RenderingFlag Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields ClStrip = 1 Cutter location strip rendering flag. ColorScaleBar = 10 Color scale bar rendering flag. Category: Foreground. DimensionBar = 9 Dimension bar rendering flag. Category: Foreground. Dummy = 0 Dummy placeholder flag. Fixture = 4 Fixture rendering flag. Category: Solid. HeidenhainCoordinate = 8 Heidenhain Coordinate rendering flag. Category: Anchor (Coordinate Mark). IsoCoordinate = 7 Iso Coordinate rendering flag. Category: Anchor (Coordinate Mark). Mech = 5 Mechanical components rendering flag. This flag covers the flags WorkpieceGeom, Tool and Fixture. Category: Solid. ProgramZero = 6 Program Zero rendering flag. Category: Anchor (Coordinate Mark). Tool = 3 Tool rendering flag. Category: Solid. WorkpieceGeom = 2 Workpiece geometry rendering flag. Category: Solid."
  },
  "api/Hi.MachiningProcs.RequireActiveSessionAttribute.html": {
    "href": "api/Hi.MachiningProcs.RequireActiveSessionAttribute.html",
    "title": "Class RequireActiveSessionAttribute | HiAPI-C# 2025",
    "summary": "Class RequireActiveSessionAttribute Namespace Hi.MachiningProcs Assembly HiNc.dll Action filter for the session-scoped web-API surface: before a guarded action runs, verifies a machining session is active (SessionShell is non-null). When none is active it short-circuits with HTTP 409 and an NoActiveSession() envelope, so a REST / AI caller gets a helpful “call BeginSession() first” notice instead of a null-reference 500. Apply at the controller level; exempt the session lifecycle entry points (BeginSession / EndSession) with AllowNoActiveSessionAttribute. [AttributeUsage(AttributeTargets.Class|AttributeTargets.Method, AllowMultiple = false)] public sealed class RequireActiveSessionAttribute : Attribute, IActionFilter, IFilterMetadata Inheritance object Attribute RequireActiveSessionAttribute Implements IActionFilter IFilterMetadata Inherited Members Attribute.Equals(object) Attribute.GetCustomAttribute(Assembly, Type) Attribute.GetCustomAttribute(Assembly, Type, bool) Attribute.GetCustomAttribute(MemberInfo, Type) Attribute.GetCustomAttribute(MemberInfo, Type, bool) Attribute.GetCustomAttribute(Module, Type) Attribute.GetCustomAttribute(Module, Type, bool) Attribute.GetCustomAttribute(ParameterInfo, Type) Attribute.GetCustomAttribute(ParameterInfo, Type, bool) Attribute.GetCustomAttributes(Assembly) Attribute.GetCustomAttributes(Assembly, bool) Attribute.GetCustomAttributes(Assembly, Type) Attribute.GetCustomAttributes(Assembly, Type, bool) Attribute.GetCustomAttributes(MemberInfo) Attribute.GetCustomAttributes(MemberInfo, bool) Attribute.GetCustomAttributes(MemberInfo, Type) Attribute.GetCustomAttributes(MemberInfo, Type, bool) Attribute.GetCustomAttributes(Module) Attribute.GetCustomAttributes(Module, bool) Attribute.GetCustomAttributes(Module, Type) Attribute.GetCustomAttributes(Module, Type, bool) Attribute.GetCustomAttributes(ParameterInfo) Attribute.GetCustomAttributes(ParameterInfo, bool) Attribute.GetCustomAttributes(ParameterInfo, Type) Attribute.GetCustomAttributes(ParameterInfo, Type, bool) Attribute.GetHashCode() Attribute.IsDefaultAttribute() Attribute.IsDefined(Assembly, Type) Attribute.IsDefined(Assembly, Type, bool) Attribute.IsDefined(MemberInfo, Type) Attribute.IsDefined(MemberInfo, Type, bool) Attribute.IsDefined(Module, Type) Attribute.IsDefined(Module, Type, bool) Attribute.IsDefined(ParameterInfo, Type) Attribute.IsDefined(ParameterInfo, Type, bool) Attribute.Match(object) Attribute.TypeId object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods OnActionExecuted(ActionExecutedContext) Called after the action executes, before the action result. public void OnActionExecuted(ActionExecutedContext context) Parameters context ActionExecutedContext The ActionExecutedContext. OnActionExecuting(ActionExecutingContext) Called before the action executes, after model binding is complete. public void OnActionExecuting(ActionExecutingContext context) Parameters context ActionExecutingContext The ActionExecutingContext."
  },
  "api/Hi.MachiningProcs.RequireLoadedProjectAttribute.html": {
    "href": "api/Hi.MachiningProcs.RequireLoadedProjectAttribute.html",
    "title": "Class RequireLoadedProjectAttribute | HiAPI-C# 2025",
    "summary": "Class RequireLoadedProjectAttribute Namespace Hi.MachiningProcs Assembly HiNc.dll Action filter for the project-level web-API surface: before a guarded action runs, verifies a project is loaded (MachiningProject is non-null). When none is loaded it short-circuits with HTTP 409 and an NoProjectLoaded() envelope, so a REST / AI caller gets a helpful “create or load a project first” notice instead of a null-reference 500 (the project-level members — MachiningActRunner.Config, workpiece, runners — are null until a project is open). Apply at the controller level; exempt the endpoints that create or load a project with AllowNoLoadedProjectAttribute. [AttributeUsage(AttributeTargets.Class|AttributeTargets.Method, AllowMultiple = false)] public sealed class RequireLoadedProjectAttribute : Attribute, IActionFilter, IFilterMetadata Inheritance object Attribute RequireLoadedProjectAttribute Implements IActionFilter IFilterMetadata Inherited Members Attribute.Equals(object) Attribute.GetCustomAttribute(Assembly, Type) Attribute.GetCustomAttribute(Assembly, Type, bool) Attribute.GetCustomAttribute(MemberInfo, Type) Attribute.GetCustomAttribute(MemberInfo, Type, bool) Attribute.GetCustomAttribute(Module, Type) Attribute.GetCustomAttribute(Module, Type, bool) Attribute.GetCustomAttribute(ParameterInfo, Type) Attribute.GetCustomAttribute(ParameterInfo, Type, bool) Attribute.GetCustomAttributes(Assembly) Attribute.GetCustomAttributes(Assembly, bool) Attribute.GetCustomAttributes(Assembly, Type) Attribute.GetCustomAttributes(Assembly, Type, bool) Attribute.GetCustomAttributes(MemberInfo) Attribute.GetCustomAttributes(MemberInfo, bool) Attribute.GetCustomAttributes(MemberInfo, Type) Attribute.GetCustomAttributes(MemberInfo, Type, bool) Attribute.GetCustomAttributes(Module) Attribute.GetCustomAttributes(Module, bool) Attribute.GetCustomAttributes(Module, Type) Attribute.GetCustomAttributes(Module, Type, bool) Attribute.GetCustomAttributes(ParameterInfo) Attribute.GetCustomAttributes(ParameterInfo, bool) Attribute.GetCustomAttributes(ParameterInfo, Type) Attribute.GetCustomAttributes(ParameterInfo, Type, bool) Attribute.GetHashCode() Attribute.IsDefaultAttribute() Attribute.IsDefined(Assembly, Type) Attribute.IsDefined(Assembly, Type, bool) Attribute.IsDefined(MemberInfo, Type) Attribute.IsDefined(MemberInfo, Type, bool) Attribute.IsDefined(Module, Type) Attribute.IsDefined(Module, Type, bool) Attribute.IsDefined(ParameterInfo, Type) Attribute.IsDefined(ParameterInfo, Type, bool) Attribute.Match(object) Attribute.TypeId object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods OnActionExecuted(ActionExecutedContext) Called after the action executes, before the action result. public void OnActionExecuted(ActionExecutedContext context) Parameters context ActionExecutedContext The ActionExecutedContext. OnActionExecuting(ActionExecutingContext) Called before the action executes, after model binding is complete. public void OnActionExecuting(ActionExecutingContext context) Parameters context ActionExecutingContext The ActionExecutingContext."
  },
  "api/Hi.MachiningProcs.SessionShell.html": {
    "href": "api/Hi.MachiningProcs.SessionShell.html",
    "title": "Class SessionShell | HiAPI-C# 2025",
    "summary": "Class SessionShell Namespace Hi.MachiningProcs Assembly HiNc.dll End-user-facing facade for a machining session: aggregates session lifecycle, NC playback, optimization, geometry I/O, and scripting infrastructure into a single delegation surface. Used as the C# script globals object and as the concrete target of ISessionCommand implementations. public class SessionShell : ISessionShell Inheritance object SessionShell Implements ISessionShell Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields DefaultScriptOptions The default Roslyn ScriptOptions for session scripts — references the SessionShell-domain assemblies and imports. Used as the initial value of the project-level ScriptOptions. public static readonly ScriptOptions DefaultScriptOptions Field Value ScriptOptions Properties DefaultParaTemplateDimension Gets or sets the parameter template dimension (2D or 3D). [JsAce] public int DefaultParaTemplateDimension { get; set; } Property Value int DiffVisualRadius_mm Gets or sets the visual radius in millimeters for difference visualization. Controls the radius used for highlighting differences between workpiece states. [JsAce] public double DiffVisualRadius_mm { get; set; } Property Value double DispCacheMb Gets or sets the display cache size in megabytes. [Obsolete] public long DispCacheMb { get; set; } Property Value long DispCache_Mb Gets or sets the display cache size in megabytes. [JsAce] public long DispCache_Mb { get; set; } Property Value long EmbeddedLogMode Gets or sets the embedded log mode for NC optimization. [JsAce] public static NcOptimizationEmbeddedLogMode EmbeddedLogMode { get; set; } Property Value NcOptimizationEmbeddedLogMode EnableCollisionDetection Gets or sets whether collision detection is enabled. [JsAce(DocContentHtml = \"Enable Collision Detection.\")] public bool EnableCollisionDetection { get; set; } Property Value bool EnableIndividualStepAdjustmentLog Gets or sets whether to enable individual step adjustment logging. The setter drives both optimization pipelines: the legacy HardNc Hi.NcOpt.NcOptProc.EnableIndividualStepAdjustmentLog and the SoftNc Hi.NcOpt.StepFeedSolver.EnableStepAdjustmentLog statics are assigned together; the getter reads the legacy static (the pair only diverges when a static is assigned directly, bypassing this proxy). [JsAce] public static bool EnableIndividualStepAdjustmentLog { get; set; } Property Value bool EnableMapOnSelectionEnd Gets or sets whether to automatically map selections when they end. [JsAce] public bool EnableMapOnSelectionEnd { get; set; } Property Value bool EnableMotionDependentMachiningResolution Gets or sets whether motion-dependent machining resolution is enabled. [JsAce] public bool EnableMotionDependentMachiningResolution { get; set; } Property Value bool EnableMzLeverWeightingOnTraining Gets or sets whether Mz lever weighting is enabled on training. [Obsolete] public bool EnableMzLeverWeightingOnTraining { get; set; } Property Value bool EnableNativeMillingPhysics Gets or sets whether the physics runs on the native (core.dll) kernels. Default is true, and in shipping builds the native kernel is the only physics implementation — setting this to false throws unless the non-shipping managed reference assembly is registered (dev/test hosts only). [JsAce(DocContentHtml = \"Run the physics on the native kernels (the only implementation in shipping builds).\")] public bool EnableNativeMillingPhysics { get; set; } Property Value bool EnablePauseOnCollision Gets or sets whether to pause execution when a collision is detected. This property only has an effect if collision detection is enabled. [Obsolete] public bool EnablePauseOnCollision { get; set; } Property Value bool EnablePauseOnFailure Gets or sets whether to pause on failure during execution. [JsAce(DocContentHtml = \"Enable Pause On Failure.\")] public bool EnablePauseOnFailure { get; set; } Property Value bool EnablePhysics Gets or sets whether milling force evaluation is enabled. [JsAce(DocContentHtml = \"Enable milling force evaluation.\")] public bool EnablePhysics { get; set; } Property Value bool EnableSampleNormalization [Obsolete] public bool EnableSampleNormalization { get; set; } Property Value bool Remarks The input normalization deminish the quantity effect. The R-value decreases from 99% to 70% in an observed moment-training case. Don't apply this option. EnableSoftNcRunner Switches between SoftNcRunner and the legacy HardNcRunner. Default true; set false to fall back to the legacy runner (e.g. for NC optimization, which still reads NcLines). Will be removed when HardNcRunner is fully replaced. [JsAce(DocContentHtml = \"Enable SoftNcRunner (default) instead of legacy HardNcRunner.\")] public bool EnableSoftNcRunner { get; set; } Property Value bool EnableWearEffect Gets or sets whether tool wear effects are enabled in simulation. [JsAce] public bool EnableWearEffect { get; set; } Property Value bool FeedPerCycle Gets a new feed per cycle machining motion resolution instance. [JsAce] public FeedPerCycleMachiningMotionResolution FeedPerCycle { get; } Property Value FeedPerCycleMachiningMotionResolution FeedPerTooth Gets a new feed per tooth machining motion resolution instance. [JsAce] public FeedPerToothMachiningMotionResolution FeedPerTooth { get; } Property Value FeedPerToothMachiningMotionResolution Fixture Gets or sets the fixture. [JsAce] public Fixture Fixture { get; set; } Property Value Fixture Global [JsAce(\"Global[$1key]\")] public Dictionary<object, object> Global { get; } Property Value Dictionary<object, object> InitSpindleTemperature_C Gets or sets the initial spindle temperature in degrees Celsius. [JsAce(DocContentHtml = \"Spindle Temperature on initialization.\")] public double InitSpindleTemperature_C { get; set; } Property Value double JsAceCompletionProfileJsonArray Internal used. public static JsonArray JsAceCompletionProfileJsonArray { get; } Property Value JsonArray MachiningMotionResolution Gets or sets the machining motion resolution. [JsAce] public IMachiningMotionResolution MachiningMotionResolution { get; set; } Property Value IMachiningMotionResolution MachiningResolution Gets or sets the machining resolution in millimeters. [JsAce] [Obsolete(\"Use MachiningResolution_mm instead.\")] public double MachiningResolution { get; set; } Property Value double MachiningResolution_mm Gets or sets the machining resolution in millimeters. [JsAce] public double MachiningResolution_mm { get; set; } Property Value double MachiningSession public MachiningSession MachiningSession { get; } Property Value MachiningSession MapTask Task tracking the status of mapping operations. public Task MapTask { get; set; } Property Value Task MappingAnchorDateTime Project-scoped anchor that converts an absolute-time mapping window / sensor stream into a relative timecode. Delegates to MappingAnchorDateTime; auto-set from the first controller instant on PlayCsvFile(string), or set here. [JsAce] public DateTime? MappingAnchorDateTime { get; set; } Property Value DateTime? MillingCycleDivisionNum Gets or sets the number of angular divisions per spindle revolution for milling force calculation. The default (36) is intended for normal simulation — a finer division does not improve force playback and only slows it down. Only TrainMillingPara(SampleFlag, string, double, ICuttingPara) benefits from a finer division (e.g. 180): set it in the training script before the simulation run the training consumes. The value is process-wide (backed by RotationDivisionNum): it is not saved into the project and survives ResetRuntime() and project switches, so set it back (or restart the instance) after training to keep normal simulation fast. [JsAce] public static int MillingCycleDivisionNum { get; set; } Property Value int MillingForceCycleDivisionNum Gets or sets the number of divisions per cycle for milling force calculation. This property should be set before milling force evaluation if TrainMillingPara(SampleFlag, string, double, ICuttingPara) is intended to be used. [JsAce(DocContentHtml = \"Obsoleted. Use MillingCycleDivisionNum instead.\")] [Obsolete(\"Use MillingCycleDivisionNum instead.\")] public static int MillingForceCycleDivisionNum { get; set; } Property Value int NcOptOption Gets or sets the NC optimization options. [JsAce] public NcOptOption NcOptOption { get; set; } Property Value NcOptOption OptEnableDepthCompensation Enables or disables depth compensation during optimization. [JsAce] public bool OptEnableDepthCompensation { get; set; } Property Value bool OptEnableFeedrate Gets or sets whether to enable feed rate optimization in NC optimization. [JsAce] public bool OptEnableFeedrate { get; set; } Property Value bool OptEnableForwardCompensation Enables or disables forward compensation during optimization. [JsAce] public bool OptEnableForwardCompensation { get; set; } Property Value bool OptEnableInterpolation Enables or disables reinterpolation for optimization. [JsAce] public bool OptEnableInterpolation { get; set; } Property Value bool OptEnableSideCompensation Enables or disables side compensation during optimization. [JsAce] public bool OptEnableSideCompensation { get; set; } Property Value bool OptExtendedPostDistance_mm Gets or sets the extended post-distance in millimeters for NC optimization. This is the distance after the current segment that will be considered for optimization. [JsAce] public double OptExtendedPostDistance_mm { get; set; } Property Value double OptExtendedPreDistance_mm Gets or sets the extended pre-distance in millimeters for NC optimization. This is the distance before the current segment that will be considered for optimization. [JsAce] public double OptExtendedPreDistance_mm { get; set; } Property Value double OptFeedrateAssignmentRatio Gets or sets the feedrate assignment ratio for optimization. If the feedrate change exceeds this ratio, the feedrate in the NC line will be updated. [JsAce] public double OptFeedrateAssignmentRatio { get; set; } Property Value double OptMaxAcceleration_mmds2 Maximum acceleration in mm/s² during optimization. Only takes effect on reinterpolated section. [JsAce(DocContentHtml = \"Only take effect on reinterpolated section.\")] public double OptMaxAcceleration_mmds2 { get; set; } Property Value double OptMaxFeedPerTooth_mm Gets or sets the maximum feed per tooth in millimeters for optimization. [JsAce] public double OptMaxFeedPerTooth_mm { get; set; } Property Value double OptMaxFeedrate_mmdmin Maximum feed rate in mm/min for cutting movements during optimization. [JsAce] public double OptMaxFeedrate_mmdmin { get; set; } Property Value double OptMaxJerk_mmds3 Maximum jerk in mm/s³ during optimization. Only takes effect on reinterpolated section. [JsAce(DocContentHtml = \"Only take effect on reinterpolated section.\")] public double OptMaxJerk_mmds3 { get; set; } Property Value double OptMinFeedPerTooth_mm Gets or sets the minimum feed per tooth in millimeters for optimization. [JsAce] public double OptMinFeedPerTooth_mm { get; set; } Property Value double OptMinFeedrate_mmdmin Minimum feed rate in mm/min for cutting movements during optimization. [JsAce] public double OptMinFeedrate_mmdmin { get; set; } Property Value double OptPreferedForce_N Preferred force in N for optimization. [JsAce] public double OptPreferedForce_N { get; set; } Property Value double OptRapidFeed_mmdmin Rapid feed rate in mm/min for non-cutting movements during optimization. [JsAce] public double OptRapidFeed_mmdmin { get; set; } Property Value double OptSpindlePowerSafetyFactor Safety factor for MAX spindle power during optimization. [JsAce] public double OptSpindlePowerSafetyFactor { get; set; } Property Value double OptSpindlePowerUtilizationFactor Utilization factor for MAX spindle power during optimization. It is the reciprocal of the spindle power safety factor. [JsAce] public double OptSpindlePowerUtilizationFactor { get; set; } Property Value double OptSpindleTorqueSafetyFactor Gets or sets the MAX spindle torque safety factor for NC optimization. [JsAce] public double OptSpindleTorqueSafetyFactor { get; set; } Property Value double OptSpindleTorqueUtilizationFactor Utilization factor for MAX spindle torque during optimization. It is the reciprocal of the spindle torque safety factor. [JsAce] public double OptSpindleTorqueUtilizationFactor { get; set; } Property Value double OptThermalYieldSafetyFactor Safety factor for spindle torque during optimization. [JsAce] public double OptThermalYieldSafetyFactor { get; set; } Property Value double OptThermalYieldUtilizationFactor Utilization factor for thermal yield during optimization. It is the reciprocal of the thermal yield safety factor. [JsAce] public double OptThermalYieldUtilizationFactor { get; set; } Property Value double OptYieldingSafetyFactor Safety factor for yielding during optimization. [JsAce] public double OptYieldingSafetyFactor { get; set; } Property Value double OptYieldingUtilizationFactor Utilization factor for yielding during optimization. It is the reciprocal of the yielding safety factor. [JsAce] public double OptYieldingUtilizationFactor { get; set; } Property Value double ScriptOptions ScriptOptions. public ScriptOptions ScriptOptions { get; set; } Property Value ScriptOptions ShellProgress Session-level routine / lifecycle message sink on the IMessage channel (cache reset, file progress, session start/done). Owned by MachiningSession (truly session-scoped); exposed here for scripts and the session facade. [JsAce] public ShellProgress ShellProgress { get; } Property Value ShellProgress StepCount Gets the total number of milling steps. [JsAce] public int StepCount { get; } Property Value int StepDiagnosticProgress Step-anchored message sink on the IMessage channel (see StepDiagnosticProgress). [JsAce] public StepDiagnosticProgress StepDiagnosticProgress { get; } Property Value StepDiagnosticProgress Workpiece Gets or sets the workpiece. [JsAce] public Workpiece Workpiece { get; set; } Property Value Workpiece Methods AddTimeDataByFile(string, string, double, double) Adds time-based data from a file to the time mapping dictionary with specified time bounds in seconds. [JsAce(\"AddTimeDataByFile($1key, $2relFile, $3beginTime, $4endTime)\")] public bool AddTimeDataByFile(string key, string relFile, double beginTime, double endTime) Parameters key string Key to identify the data relFile string Relative path to the data file beginTime double Beginning time in seconds endTime double Ending time in seconds Returns bool True if the data was successfully added, false otherwise AddTimeDataByFile(string, string, string, string) Adds time-based data from a file to the time mapping dictionary with specified time bounds. [JsAce(\"AddTimeDataByFile($1key, $2relFile, $3beginTime, $4endTime)\")] public bool AddTimeDataByFile(string key, string relFile, string beginTimeText, string endTimeText) Parameters key string Key to identify the data relFile string Relative path to the data file beginTimeText string Beginning time as text (seconds or TimeSpan format) endTimeText string Ending time as text (seconds or TimeSpan format) Returns bool True if the data was successfully added, false otherwise AdjustedFeedPerCycle(double, double) Gets a new feed per cycle machining motion resolution instance with adjusted scale and minimum linear resolution. [JsAce(\"AdjustedFeedPerCycle($1scale,$2minLinearResolution_mm)\")] public FeedPerCycleMachiningMotionResolution AdjustedFeedPerCycle(double scale, double minLinearResolution_mm = 0) Parameters scale double The scale factor for the resolution. minLinearResolution_mm double The minimum linear resolution in millimeters. Default is 0. Returns FeedPerCycleMachiningMotionResolution A new FeedPerCycleMachiningMotionResolution instance with the specified parameters. AlignWorkpieceProgramZeroToIso(string) Places workpiece + fixture so that ProgramZeroAnchor coincides with the world position the spindle reaches when the machine coordinate equals isoCoordId's entry (G54/G55/...). The buckle anchors must already be set per the general rule (typically by the project XML): FixtureBuckle at the bottom center of the workpiece geom, WorkpieceBuckle at the top center of the fixture geom, ProgramZeroAnchor at the workpiece-geom top center (or any chosen tip). Only GeomToTableTransformer is mutated. Delegates topology math to AlignWorkpieceProgramZeroToIso(IMachiningEquipment, Vec3d). [JsAce] public void AlignWorkpieceProgramZeroToIso(string isoCoordId) Parameters isoCoordId string ID into the IsoCoordinateTable, e.g. “G54”. AppendMessagesToFile(string, params string[]) Appends messages to a file, optionally filtered by tags. [JsAce(\"AppendMessagesToFile(\\\"dstRelFile\\\",flags)\")] public void AppendMessagesToFile(string dstRelFile, params string[] flags) Parameters dstRelFile string Destination relative file path flags string[] Optional flags to filter messages by tags BeginPreserve() Begin Preserve section in optimzation process. [JsAce(\"BeginPreserve()\")] public void BeginPreserve() BeginSelection(string, AnchorMode, IStepShift) Begin mark on current line. milling step() has not triggered yet. public void BeginSelection(string key, AnchorMode anchorMode = AnchorMode.LineBegin, IStepShift shift = null) Parameters key string Identifier key for the selection anchorMode AnchorMode Mode for anchoring the beginning of selection shift IStepShift Step shift to apply BeginSession() Begins a new machining session. Not for end user. public void BeginSession() ClearDefectDisplayee() Clears the defect displayee from the workpiece. [JsAce] public void ClearDefectDisplayee() ClearTimeMappingData() Clears all time mapping data. [JsAce] public void ClearTimeMappingData() ConvertClToNcFiles(string) Converts the CLSF play of the current session into Fanuc NC files (writeback synthesis): the MSYS frame becomes a G68.2 tilted working plane, tool posture becomes G43.4 RTCP with rotary words, motions become G00/G01/G02/G03. Play the CL file on an XYZABC machine chain first, then convert. [JsAce(Snippet = \"ConvertClToNcFiles(\\\"Output/[NcName].nc\\\")\", DocContentHtml = \"Convert the played CLSF into Fanuc NC files by substitute template keyword \\\"[NcName]\\\"\")] public void ConvertClToNcFiles(string relNcFileTemplate = \"Output/[NcName].nc\") Parameters relNcFileTemplate string Output path template; [NcName] is replaced by the source file name. Diff(double) Performs a difference analysis on the workpiece geometry to detect variations. [JsAce(\"Diff($1detectionRadius_mm)\")] public void Diff(double detectionRadius_mm) Parameters detectionRadius_mm double Radius for detecting differences EndPreserve() End Preserve section in optimzation process. [JsAce(\"EndPreserve()\")] public void EndPreserve() EndSelection(string, AnchorMode, IStepShift) End mark on current line for selection. public void EndSelection(string key, AnchorMode anchorMode = AnchorMode.LineEnd, IStepShift shift = null) Parameters key string Identifier key for the selection anchorMode AnchorMode Mode for anchoring the end of selection shift IStepShift Step shift to apply EndSession() Ends the current machining session. Not for end user. public void EndSession() ErrorMessage(string) Displays an error message in the message host. [JsAce(\"ErrorMessage($1message)\")] public void ErrorMessage(string message) Parameters message string The error message to display ExportMeshedGeomToObj(string, double) Exports the current meshed geometry to a Wavefront OBJ file with per-vertex RGB. [JsAce(\"ExportMeshedGeomToObj($1\\\"dstFile\\\",$2resolution_mm)\")] public void ExportMeshedGeomToObj(string relFile, double resolution_mm = 0) Parameters relFile string Relative path to the output OBJ file resolution_mm double Resolution in millimeters (0 for default) ExportMeshedGeomToPly(string, double) Exports the current meshed geometry to a binary PLY file with per-vertex RGB. [JsAce(\"ExportMeshedGeomToPly($1\\\"dstFile\\\",$2resolution_mm)\")] public void ExportMeshedGeomToPly(string relFile, double resolution_mm = 0) Parameters relFile string Relative path to the output PLY file resolution_mm double Resolution in millimeters (0 for default) ExportMeshedGeomToStl(string, double) Exports the current meshed geometry to an STL file. [JsAce(\"ExportMeshedGeomToStl($1\\\"dstFile\\\",$2resolution_mm)\")] public void ExportMeshedGeomToStl(string relFile, double resolution_mm = 0) Parameters relFile string Relative path to the output STL file resolution_mm double Resolution in millimeters (0 for default) ExportRuntimeGeomToObj(string, double) Legacy script alias of ExportMeshedGeomToObj(string, double); kept so old player scripts keep working. [Obsolete(\"Legacy alias; use ExportMeshedGeomToObj instead.\")] public void ExportRuntimeGeomToObj(string relFile, double resolution_mm = 0) Parameters relFile string resolution_mm double ExportRuntimeGeomToPly(string, double) Legacy script alias of ExportMeshedGeomToPly(string, double); kept so old player scripts keep working. [Obsolete(\"Legacy alias; use ExportMeshedGeomToPly instead.\")] public void ExportRuntimeGeomToPly(string relFile, double resolution_mm = 0) Parameters relFile string resolution_mm double ExportRuntimeGeomToStl(string, double) Legacy script alias of ExportMeshedGeomToStl(string, double); kept so old player scripts keep working. [Obsolete(\"Legacy alias; use ExportMeshedGeomToStl instead.\")] public void ExportRuntimeGeomToStl(string relFile, double resolution_mm = 0) Parameters relFile string resolution_mm double FixedPace(double, double) Creates a fixed machining motion resolution with specified parameters. [JsAce(\"FixedPace($1linearResolution_mm, $2rotaryResolution_deg)\")] public FixedMachiningMotionResolution FixedPace(double linearResolution_mm, double rotaryResolution_deg) Parameters linearResolution_mm double Linear resolution in millimeters rotaryResolution_deg double Rotary resolution in degrees Returns FixedMachiningMotionResolution A new fixed machining motion resolution instance GetMillingStep(int) Retrieves a milling step at the specified index. [JsAce(Snippet = \"GetMillingStep($1\\\"stepIndex\\\")\")] public MachiningStep GetMillingStep(int stepIndex) Parameters stepIndex int Index of the milling step to retrieve Returns MachiningStep The milling step at the specified index GetStickMachiningToolObservationHeight_mm(int) Gets the observation height in millimeters for the specified stick machining tool. [JsAce(\"GetStickMachiningToolObservationHeight_mm($1toolId)\")] public double GetStickMachiningToolObservationHeight_mm(int toolId) Parameters toolId int The ID of the tool Returns double The observation height in millimeters GetUniformFlutingShiftAngle_deg(int) Gets the shift angle in degrees for the uniform fluting of the specified tool, that is, for a cutter whose flutes all share one baseline flute contour. [JsAce(\"GetUniformFlutingShiftAngle_deg($1toolId)\")] public double GetUniformFlutingShiftAngle_deg(int toolId) Parameters toolId int The ID of the tool Returns double The shift angle in degrees LineSelection(string, AnchorMode, IStepShift, AnchorMode, IStepShift) Create a line selection from begin to end mark. public void LineSelection(string key, AnchorMode beginAnchorMode = AnchorMode.LineBegin, IStepShift beginShift = null, AnchorMode endAnchorMode = AnchorMode.LineEnd, IStepShift endShift = null) Parameters key string Identifier key for the selection beginAnchorMode AnchorMode Mode for anchoring the beginning of selection beginShift IStepShift Step shift to apply at beginning endAnchorMode AnchorMode Mode for anchoring the end of selection endShift IStepShift Step shift to apply at end LoadCuttingParaByFile(string) Loads cutting parameters from a file. [JsAce(\"LoadCuttingParaByFile($1\\\"relFile\\\")\")] public void LoadCuttingParaByFile(string relFile) Parameters relFile string File path relative to BaseDirectory. Map(string, IFileTimeSection, CycleSamplingMode?) Maps selection data to time section. public Task Map(string key, IFileTimeSection fileTimeSection = null, StepTimeShotUtil.CycleSamplingMode? cycleSamplingMode = CycleSamplingMode.SpindleCycle) Parameters key string Identifier key for the selection fileTimeSection IFileTimeSection File time section, or null to use the one associated with the key cycleSamplingMode StepTimeShotUtil.CycleSamplingMode? Cycle sampling mode Returns Task Task representing the asynchronous mapping operation MapByActualTime(string, CycleSamplingMode) Maps machining steps by actual time from a time shot file. [Obsolete] public void MapByActualTime(string timeShotRelFile, StepTimeShotUtil.CycleSamplingMode cycleSamplingMode = CycleSamplingMode.SpindleCycle) Parameters timeShotRelFile string Relative path to the time shot file. cycleSamplingMode StepTimeShotUtil.CycleSamplingMode The cycle sampling mode. MapSeriesByCsvFile(string, CycleSamplingMode) Maps machining steps by actual time from a time shot csv file. [JsAce(\"MapSeriesByCsvFile($1timeShotRelFile)\")] public void MapSeriesByCsvFile(string timeShotRelFile, StepTimeShotUtil.CycleSamplingMode cycleSamplingMode = CycleSamplingMode.SpindleCycle) Parameters timeShotRelFile string Relative path to the time shot file. cycleSamplingMode StepTimeShotUtil.CycleSamplingMode The cycle sampling mode. Remarks cycleSamplingMode sets how much sensor data each step is paired with. The window is anchored at the step's end time and runs forward for one cycle period, so a step is always regressed against samples its neighbours produced. While the cut is steady that costs nothing: a neighbour cutting the same arc at the same chip load produces, at a given rotation angle, the force this step would have produced, so the borrowed rows are extra samples rather than extra error. The pairing turns into a systematic bias only where the cutter-workpiece engagement changes across the window — cutter entry, pass exit, corners, depth changes. Restricting training to the steady part of the cut is therefore the largest single accuracy lever, and once the transient is out the window choice stops mattering: on the D8 2-flute Al6061-T6 case the two modes differ by 2.2 percentage points over the whole path (Fc error at feed-per-tooth 0.2: −9.3 % for SpindleCycle versus −7.1 % for FluteCycle) but by 0.06 over the steady part alone, where both reach −3.3 % / −3.2 % at R 98.5 %. Keep the default and its larger sample count; on a single-flute cutter the two modes coincide anyway. Gaps in the data (an acquisition dropout, or rows carved out to keep the steady section only) are handled: a step whose window contains no measured row is excluded from the mapping, and one Map-ShotGap--StepsSkipped warning carries the count. A window-edge row is only interpolated when its bracketing rows span at most two spindle revolutions — farther rows sit across a gap and no edge row is fabricated from them. MapSingleByCsvFile(string) Reads a CSV file and performs time-based interpolation to map data to milling steps. It is one (step) - one (embedded-data) mapping. [JsAce(Snippet = \"MapSingleByCsvFile($1\\\"csvFile\\\")\")] public void MapSingleByCsvFile(string csvFile) Parameters csvFile string Path to the CSV file relative to the base directory Message(string) Displays a message in the message host. [JsAce(\"Message($1message)\")] public void Message(string message) Parameters message string The message to display OptCallPreferFuncIndexDictionary() Gets the dictionary of preferred function index for NC optimization. [JsAce(\"OptCallPreferFuncIndexDictionary()\")] public Dictionary<Func<MillingPhysicsBrief, double>, double> OptCallPreferFuncIndexDictionary() Returns Dictionary<Func<MillingPhysicsBrief, double>, double> Dictionary mapping functions to their preference indexes. OptimizeToFiles(string) Optimizes NC files and saves results using the specified file template. Routing rule: when EnableSoftNcRunner is on and the session holds played SoftNc SyntaxPieceLayers (non-empty), the SoftNc pipeline (OptimizeNcFiles(string, string, ICuttingPara, IProgress<IMessage>, CancellationToken, Func<int, MillingStepLuggage>, Action) / Hi.NcOpt.SoftNcOptProc) is used; otherwise the legacy HardNc OptimizeToFiles(ICuttingPara, MachiningSession, LinkedList<HardNcLine>, HardNcEnv, MachiningToolHouse, ClStrip, string, IProgress<IMessage>, CancellationToken, string) path runs unchanged. Both paths first clear every cutter's MillingCutterOptLimit cache. [JsAce(Snippet = \"OptimizeToFiles(\\\"Output/Opt-[NcName]\\\")\", DocContentHtml = \"Optimize To Files by substitude template keywoard \\\"[NcName]\\\"\")] public void OptimizeToFiles(string relFileTemplate = \"Output/Opt-[NcName]\") Parameters relFileTemplate string Template for output file path, can include [NcName] placeholder Pace() A pausable mark for the playing process. The function enables Pause() to take effect. [JsAce(\"Pace();\")] public void Pace() Remarks Waits for the player to signal the next pace. Pause() Pause Player [JsAce(DocContentHtml = \"Pause Player\")] public void Pause() PlayAct(IAct, ISentenceCarrier, CancellationToken?) Plays an act with pacing control. [JsAce] public void PlayAct(IAct act, ISentenceCarrier sourceCommand = null, CancellationToken? cancellationToken = null) Parameters act IAct The act to play. sourceCommand ISentenceCarrier The source command. cancellationToken CancellationToken? Cancellation token. PlayBrandNcFile(string) Plays a famous-brand NC code file with the specified relative path (no kind dispatch — always the brand runner). [JsAce(\"PlayBrandNcFile($1\\\"ncFile\\\");\")] public void PlayBrandNcFile(string relNcFilePath) Parameters relNcFilePath string Relative path to the NC file PlayClFile(string) Plays an NX-CL (CLSF) file with the specified relative path. [JsAce(\"PlayClFile($1\\\"clFile\\\");\")] public void PlayClFile(string relFilePath) Parameters relFilePath string Relative path to the CLSF file PlayClTeleport(double, double, double, double, double, double) Plays a CL (cutter location) teleport operation. [JsAce] public void PlayClTeleport(double x, double y, double z, double i, double j, double k) Parameters x double X coordinate. y double Y coordinate. z double Z coordinate. i double I vector component. j double J vector component. k double K vector component. PlayCsvFile(string) Plays an Csv file with the specified relative path. [JsAce(\"PlayCsvFile($1\\\"csvFile\\\");\")] public void PlayCsvFile(string relFilePath) Parameters relFilePath string Relative path to the CSV file PlayNc(string, string) Plays NC code directly from a string, executing each action and pacing between them. [JsAce(Snippet = \"PlayNc($1\\\"ncCommand\\\",$2\\\"\\\"(Direct Command)\\\"\\\");\", DocContentHtml = \"Play NC. second parameter is the file name alternative shows in the log.\")] public void PlayNc(string ncText, string fileNameAlternative = \"--\") Parameters ncText string NC code as a string fileNameAlternative string Alternative name to display in logs PlayNcFile(string, NcKind) Plays an NC program file with the specified relative path, the runner picked by kind (Auto = by file extension: .cl/.cls/.clsf play as CL, .csv as CSV, anything else as brand NC — so existing scripts keep their behavior). [JsAce(\"PlayNcFile($1\\\"ncFile\\\");\")] public void PlayNcFile(string relNcFilePath, NcKind kind = NcKind.Auto) Parameters relNcFilePath string Relative path to the NC program file kind NcKind Which runner plays the file; Auto detects by extension. PlayToolingTeleport(int) Plays a tooling teleport operation. [JsAce] public void PlayToolingTeleport(int toolId) Parameters toolId int The tool ID to teleport. PowerReset() Performs a controller power reset: every IPowerResettable dependency in the active NcDependencyList clears its volatile subset (e.g. Fanuc common volatile macro variables #100-#499). Persistent state is left intact. [JsAce(\"PowerReset();\")] public void PowerReset() Preserve() Preserve one line NC code in optimzation process. [JsAce(\"Preserve()\")] public void Preserve() ProgressMessage(string) Displays a progress message in the message host. [JsAce(\"ProgressMessage($1message)\")] public void ProgressMessage(string message) Parameters message string The progress message to display ReTrainMillingPara(SampleFlag, string, double) Re-trains milling parameters using the specified sample flag. [JsAce(\"ReTrainMillingPara(Fx|Fy|Fz, $1dstFile)\")] public void ReTrainMillingPara(SampleFlag sampleFlag, string dstRelFile, double outlierRatio = 0.1) Parameters sampleFlag SampleFlag Sample flag indicating which components to train dstRelFile string Destination relative file path outlierRatio double Outlier ratio for data filtering ReadCsvByTimeInterpolation(string) Reads a CSV file and performs time-based interpolation to map data to milling steps. It is one (step) - one (embedded-data) mapping. [Obsolete] public void ReadCsvByTimeInterpolation(string csvFile) Parameters csvFile string Path to the CSV file relative to the base directory ReadMeshedGeom(string) Reads meshed geometry from a file. [JsAce(\"ReadMeshedGeom($1\\\"srcFile\\\")\")] public void ReadMeshedGeom(string relFile) Parameters relFile string Relative path to the input file ReadRuntimeGeom(string) Legacy script alias of ReadMeshedGeom(string); kept so old player scripts keep working. [Obsolete(\"Legacy alias; use ReadMeshedGeom instead.\")] public void ReadRuntimeGeom(string relFile) Parameters relFile string RegisterStepVariable(string, string, string, string, Func<MachiningStep, object>) Registers a step variable for tracking during execution. [JsAce(Snippet = \"RegisterStepVariable(\\\"$1key\\\",\\\"$2name\\\",\\\"$3unit\\\",\\\"$4formatString\\\",\\\"$5variableFunc\\\")\", DocContentHtml = \"<p>Register Step Variable.</p> <p>\\\"unit\\\" is nullable</p> <p>\\\"formatString\\\" is nullable</p>\")] public void RegisterStepVariable(string key, string name, string unit, string formatString, Func<MachiningStep, object> variableFunc = null) Parameters key string Unique key to identify the variable name string Human-readable name of the variable unit string Physical unit of the variable (can be null) formatString string Format string for displaying the variable (can be null) variableFunc Func<MachiningStep, object> Function to compute the variable value from a milling step (can be null) RegisterWriteSyntaxPieces(string) Registers a text writer so each executed SyntaxPiece is appended to relOutputFile under the machining project base directory for debugging. [JsAce(Snippet = \"RegisterWriteSyntaxPieces($1\\\"Cache/syntax-pieces-output.txt\\\")\")] public void RegisterWriteSyntaxPieces(string relOutputFile) Parameters relOutputFile string Relative path for the output log file. RegisterWriteSyntaxPiecesWithActs(string) Registers a writer that outputs each SyntaxPiece once, followed by its associated IAct entries (one-to-many). [JsAce(Snippet = \"RegisterWriteSyntaxPiecesWithActs($1\\\"Cache/syntax-pieces-acts-output.txt\\\")\")] public void RegisterWriteSyntaxPiecesWithActs(string relOutputFile) Parameters relOutputFile string Output file path relative to BaseDirectory. RemoveFlyPiece() Removes any disconnected or “flying” pieces from the workpiece geometry. [JsAce] public void RemoveFlyPiece() Reset() Reset Player [JsAce(DocContentHtml = \"Reset Player\")] public void Reset() ResetRuntime() Clears internal buffers. [JsAce] public void ResetRuntime() RunBrandNcFile(string) Runs a famous-brand NC code file with the specified relative path (no kind dispatch — always the brand runner). Not for end user with no programing skill. [JsAce(\"RunBrandNcFile($1\\\"ncFile\\\");\")] public IEnumerable<Action> RunBrandNcFile(string relNcFilePath) Parameters relNcFilePath string Relative path to the NC file Returns IEnumerable<Action> Enumerable sequence of actions to be executed RunNc(string, string) Runs NC code directly from a string. Not for end user with no programing skill. [JsAce(Snippet = \"RunNc($1\\\"ncCommand\\\",$2\\\"\\\"(Direct Command)\\\"\\\");\", DocContentHtml = \"Run NC. second parameter is the file name alternative shows in the log.\")] public IEnumerable<Action> RunNc(string ncText, string fileNameAlternative = \"--\") Parameters ncText string NC code as a string fileNameAlternative string Alternative name to display in logs Returns IEnumerable<Action> Enumerable sequence of actions to be executed RunNcFile(string, NcKind) Runs an NC program file with the specified relative path, the runner picked by kind (Auto = by file extension: .cl/.cls/.clsf run as CL, .csv as CSV, anything else as brand NC — so existing scripts keep their behavior). Not for end user with no programing skill. [JsAce(\"RunNcFile($1\\\"ncFile\\\");\")] public IEnumerable<Action> RunNcFile(string relNcFilePath, NcKind kind = NcKind.Auto) Parameters relNcFilePath string Relative path to the NC program file kind NcKind Which runner runs the file; Auto detects by extension. Returns IEnumerable<Action> Enumerable sequence of actions to be executed ScaledFeedPerCycle(double) Gets a new feed per cycle machining motion resolution instance with the specified scale. [JsAce(\"ScaledFeedPerCycle($1scale)\")] public FeedPerCycleMachiningMotionResolution ScaledFeedPerCycle(double scale) Parameters scale double The scale factor for the resolution. Returns FeedPerCycleMachiningMotionResolution A new FeedPerCycleMachiningMotionResolution instance with the specified scale. ScanMeshedGeomInfDefect() Scans the meshed geometry for defects. After scanning, the scanned defects will render in the workpiece. [JsAce] public bool? ScanMeshedGeomInfDefect() Returns bool? True if defects are found, false otherwise, or null if the operation cannot be performed. ScanRuntimeGeomInfDefect() Legacy script alias of ScanMeshedGeomInfDefect(); kept so old player scripts keep working. [Obsolete(\"Legacy alias; use ScanMeshedGeomInfDefect instead.\")] public bool? ScanRuntimeGeomInfDefect() Returns bool? SetAllSnapshotSyntaxEnabled(bool) Sets IsEnabled on every SnapshotSyntax reachable from the active SoftNcRunner's NcSyntaxList (top-level slots and inside BundleSyntax). No-op when SoftNcRunner is not the active runner. [JsAce(DocContentHtml = \"Enable or disable every SnapshotSyntax in the active SoftNcRunner pipeline at once.\")] public void SetAllSnapshotSyntaxEnabled(bool isEnabled) Parameters isEnabled bool SetNcResolutionFeedPerCycle() Sets NC resolution to feed per cycle mode. public void SetNcResolutionFeedPerCycle() SetNcResolutionFeedPerTooth() Sets NC resolution to feed per tooth mode. public void SetNcResolutionFeedPerTooth() SetNcResolutionFixed(double, double) Sets NC resolution to fixed mode with specified resolution values. public void SetNcResolutionFixed(double linearResolution_mm, double rotaryResolution_deg) Parameters linearResolution_mm double Linear resolution in millimeters. rotaryResolution_deg double Rotary resolution in degrees. SetStickMachiningToolObservationHeight_mm(int, double) Sets the observation height in millimeters for the specified stick machining tool. [JsAce(\"SetStickMachiningToolObservationHeight_mm($1toolId,$2height_mm)\")] public void SetStickMachiningToolObservationHeight_mm(int toolId, double height) Parameters toolId int The ID of the tool height double The observation height in millimeters to set SetUniformFlutingShiftAngle_deg(int, double) Sets the shift angle in degrees for the uniform fluting of the specified tool, that is, for a cutter whose flutes all share one baseline flute contour. [JsAce(\"SetUniformFlutingShiftAngle_deg($1toolId,$2angle_deg)\")] public void SetUniformFlutingShiftAngle_deg(int toolId, double angle_deg) Parameters toolId int The ID of the tool angle_deg double The shift angle in degrees to set ShiftDistance_mm(double) Creates a distance shift object representing the specified distance in millimeters. public DistanceShift ShiftDistance_mm(double distanceShift_mm) Parameters distanceShift_mm double Distance shift in millimeters Returns DistanceShift Distance shift object ShiftTime_s(double) Creates a time shift object representing the specified time in seconds. public TimeShift ShiftTime_s(double seconds) Parameters seconds double Time in seconds Returns TimeShift Time shift object TrainMillingPara(SampleFlag, string, double, ICuttingPara) Trains milling parameters using the specified sample flag. [JsAce(\"TrainMillingPara(Fx|Fy|Fz, $1dstFile)\")] public void TrainMillingPara(SampleFlag sampleFlag, string dstRelFile, double outlierRatio = 0.1, ICuttingPara paraTemplate = null) Parameters sampleFlag SampleFlag Sample flag indicating which components to train dstRelFile string Destination relative file path outlierRatio double Outlier ratio for data filtering paraTemplate ICuttingPara Optional parameter template for cutting operations. WarningMessage(string) Displays a warning message in the message host. [JsAce(\"WarningMessage($1message)\")] public void WarningMessage(string message) Parameters message string The warning message to display WriteMeshedGeom(string) Writes the current meshed geometry to a file. [JsAce(\"WriteMeshedGeom($1\\\"dstFile\\\")\")] public void WriteMeshedGeom(string relFile) Parameters relFile string Relative path to the output file WriteRuntimeGeom(string) Legacy script alias of WriteMeshedGeom(string); kept so old player scripts keep working. [Obsolete(\"Legacy alias; use WriteMeshedGeom instead.\")] public void WriteRuntimeGeom(string relFile) Parameters relFile string WriteShotFiles(double, string) Writes time-series data to shot files with the specified resolution period (alternative parameter order). public void WriteShotFiles(double resolutionPeroid_ms, string relFileTemplate) Parameters resolutionPeroid_ms double Resolution period in milliseconds relFileTemplate string Template for output file path, can include [NcName] placeholder WriteShotFiles(string, double) Writes time-series (shot) data to files at the given sampling period. [JsAce(Snippet = \"WriteShotFiles(\\\"Output/[NcName].shot.csv\\\",resolutionPeroid_ms)\", DocContentHtml = \"Write time series data by resolutionPeroid_ms\")] public void WriteShotFiles(string relFileTemplate = \"Output/[NcName].shot.csv\", double resolutionPeroid_ms = 1) Parameters relFileTemplate string Template for output file path, can include [NcName] placeholder resolutionPeroid_ms double Sampling period in milliseconds Remarks Each row is interpolated from the per-division force waveform, so the information carried per spindle revolution is min(MillingCycleDivisionNum, 60000 / (rpm * resolutionPeroid_ms)). When the written file is fed back into TrainMillingPara(SampleFlag, string, double, ICuttingPara), this period — not MillingCycleDivisionNum and not the machining resolution — sets the accuracy ceiling: sampling coarser than the division period throws away waveform detail that a finer angular grid cannot recover. Choose it at or below 60000 / (rpm * MillingCycleDivisionNum) ms, and when the result is compared against a physical measurement, match the real DAQ rate so both sides carry the same information density. Fine periods produce large files (a 6-cut program: 13 MB at 1 ms, 128 MB at 0.1 ms). WriteStepFiles(string) Writes step-series data to files with the specified file template. [JsAce(Snippet = \"WriteStepFiles(\\\"Output/[NcName].step.csv\\\")\", DocContentHtml = \"Write step series data.\")] public void WriteStepFiles(string relFileTemplate = \"Output/[NcName].step.csv\") Parameters relFileTemplate string Template for output file path, can include [NcName] placeholder Events MachiningStepBuilt Session-scoped event triggered when a machining step is built. Lifetime is bound to MachiningSession: created by BeginSession(), released by EndSession(). For app-lifetime event, use MachiningStepBuilt instead. [Obsolete(\"Use SessionStepBuilt instead.\")] public event MachiningActRunner.MachiningStepBuiltDelegate MachiningStepBuilt Event Type MachiningActRunner.MachiningStepBuiltDelegate MachiningStepSelected Session-scoped event triggered when a machining step is selected. Lifetime is bound to MachiningSession: created by BeginSession(), released by EndSession(). [Obsolete(\"Use SessionStepSelected instead.\")] public event Action<MachiningStep> MachiningStepSelected Event Type Action<MachiningStep> SessionSourcedActEntry Session-scoped event triggered for each SourcedActEntry produced during NC/CSV execution. Lifetime is bound to MachiningSession: created by BeginSession(), released by EndSession(). [JsAce(Snippet = \"SessionSourcedActEntry+=($1entry)=>{$2Command};\", DocContentHtml = \"Session-scoped event triggered for each SourcedActEntry. entry.SentenceSource is the source sentence; entry.Act is the associated act (may be null).\")] public event Action<SourcedActEntry> SessionSourcedActEntry Event Type Action<SourcedActEntry> SessionStepBuilt Session-scoped event triggered when a machining step is built. Lifetime is bound to MachiningSession: created by BeginSession(), released by EndSession(). For app-lifetime event, use MachiningStepBuilt instead. [JsAce(Snippet = \"SessionStepBuilt+=($1preStep,$2curStep)=>{$3Command};\", DocContentHtml = \"Session-scoped step built event. preStep is the Previous Milling Step; curStep is the Current Milling Step. preStep is null if no previous step existed.\")] public event MachiningActRunner.MachiningStepBuiltDelegate SessionStepBuilt Event Type MachiningActRunner.MachiningStepBuiltDelegate SessionStepSelected Session-scoped event triggered when a machining step is selected. Lifetime is bound to MachiningSession: created by BeginSession(), released by EndSession(). [JsAce(Snippet = \"SessionStepSelected+=($1millingStep)=>{$2Command};\")] public event Action<MachiningStep> SessionStepSelected Event Type Action<MachiningStep> SessionSyntaxPieceRan Session-scoped event triggered when a syntax piece has been executed. Lifetime is bound to MachiningSession: created by BeginSession(), released by EndSession(). [JsAce(Snippet = \"SessionSyntaxPieceRan+=($1syntaxPiece)=>{$2Command};\", DocContentHtml = \"Session-scoped event triggered after each SyntaxPiece is executed. syntaxPiece may be null if the source command is not a SyntaxPiece.\")] public event Action<SyntaxPiece> SessionSyntaxPieceRan Event Type Action<SyntaxPiece> SyntaxPieceRan Session-scoped event triggered when a syntax piece has been executed. Lifetime is bound to MachiningSession: created by BeginSession(), released by EndSession(). [Obsolete(\"Use SessionSyntaxPieceRan instead.\")] public event Action<SyntaxPiece> SyntaxPieceRan Event Type Action<SyntaxPiece>"
  },
  "api/Hi.MachiningProcs.SessionShellController.html": {
    "href": "api/Hi.MachiningProcs.SessionShellController.html",
    "title": "Class SessionShellController | HiAPI-C# 2025",
    "summary": "Class SessionShellController Namespace Hi.MachiningProcs Assembly HiNc.dll HTTP controller exposing SessionShell over the web API. Each action delegates to the underlying SessionShell instance owned by Hi.MachiningProcs.SessionShellController.LocalProjectService. [ApiController] [Route(\"api/[controller]/[action]\")] [ProducesResponseType(typeof(ApiActionResult), 409)] public class SessionShellController : ControllerBase Inheritance object ControllerBase SessionShellController Inherited Members ControllerBase.StatusCode(int) ControllerBase.StatusCode(int, object) ControllerBase.Content(string) ControllerBase.Content(string, string) ControllerBase.Content(string, string, Encoding) ControllerBase.Content(string, MediaTypeHeaderValue) ControllerBase.NoContent() ControllerBase.Ok() ControllerBase.Ok(object) ControllerBase.Redirect(string) ControllerBase.RedirectPermanent(string) ControllerBase.RedirectPreserveMethod(string) ControllerBase.RedirectPermanentPreserveMethod(string) ControllerBase.LocalRedirect(string) ControllerBase.LocalRedirectPermanent(string) ControllerBase.LocalRedirectPreserveMethod(string) ControllerBase.LocalRedirectPermanentPreserveMethod(string) ControllerBase.RedirectToAction() ControllerBase.RedirectToAction(string) ControllerBase.RedirectToAction(string, object) ControllerBase.RedirectToAction(string, string) ControllerBase.RedirectToAction(string, string, object) ControllerBase.RedirectToAction(string, string, string) ControllerBase.RedirectToAction(string, string, object, string) ControllerBase.RedirectToActionPreserveMethod(string, string, object, string) ControllerBase.RedirectToActionPermanent(string) ControllerBase.RedirectToActionPermanent(string, object) ControllerBase.RedirectToActionPermanent(string, string) ControllerBase.RedirectToActionPermanent(string, string, string) ControllerBase.RedirectToActionPermanent(string, string, object) ControllerBase.RedirectToActionPermanent(string, string, object, string) ControllerBase.RedirectToActionPermanentPreserveMethod(string, string, object, string) ControllerBase.RedirectToRoute(string) ControllerBase.RedirectToRoute(object) ControllerBase.RedirectToRoute(string, object) ControllerBase.RedirectToRoute(string, string) ControllerBase.RedirectToRoute(string, object, string) ControllerBase.RedirectToRoutePreserveMethod(string, object, string) ControllerBase.RedirectToRoutePermanent(string) ControllerBase.RedirectToRoutePermanent(object) ControllerBase.RedirectToRoutePermanent(string, object) ControllerBase.RedirectToRoutePermanent(string, string) ControllerBase.RedirectToRoutePermanent(string, object, string) ControllerBase.RedirectToRoutePermanentPreserveMethod(string, object, string) ControllerBase.RedirectToPage(string) ControllerBase.RedirectToPage(string, object) ControllerBase.RedirectToPage(string, string) ControllerBase.RedirectToPage(string, string, object) ControllerBase.RedirectToPage(string, string, string) ControllerBase.RedirectToPage(string, string, object, string) ControllerBase.RedirectToPagePermanent(string) ControllerBase.RedirectToPagePermanent(string, object) ControllerBase.RedirectToPagePermanent(string, string) ControllerBase.RedirectToPagePermanent(string, string, string) ControllerBase.RedirectToPagePermanent(string, string, object, string) ControllerBase.RedirectToPagePreserveMethod(string, string, object, string) ControllerBase.RedirectToPagePermanentPreserveMethod(string, string, object, string) ControllerBase.File(byte[], string) ControllerBase.File(byte[], string, bool) ControllerBase.File(byte[], string, string) ControllerBase.File(byte[], string, string, bool) ControllerBase.File(byte[], string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.File(byte[], string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.File(byte[], string, string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.File(byte[], string, string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.File(Stream, string) ControllerBase.File(Stream, string, bool) ControllerBase.File(Stream, string, string) ControllerBase.File(Stream, string, string, bool) ControllerBase.File(Stream, string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.File(Stream, string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.File(Stream, string, string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.File(Stream, string, string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.File(string, string) ControllerBase.File(string, string, bool) ControllerBase.File(string, string, string) ControllerBase.File(string, string, string, bool) ControllerBase.File(string, string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.File(string, string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.File(string, string, string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.File(string, string, string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.PhysicalFile(string, string) ControllerBase.PhysicalFile(string, string, bool) ControllerBase.PhysicalFile(string, string, string) ControllerBase.PhysicalFile(string, string, string, bool) ControllerBase.PhysicalFile(string, string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.PhysicalFile(string, string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.PhysicalFile(string, string, string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.PhysicalFile(string, string, string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.Unauthorized() ControllerBase.Unauthorized(object) ControllerBase.NotFound() ControllerBase.NotFound(object) ControllerBase.BadRequest() ControllerBase.BadRequest(object) ControllerBase.BadRequest(ModelStateDictionary) ControllerBase.UnprocessableEntity() ControllerBase.UnprocessableEntity(object) ControllerBase.UnprocessableEntity(ModelStateDictionary) ControllerBase.Conflict() ControllerBase.Conflict(object) ControllerBase.Conflict(ModelStateDictionary) ControllerBase.Problem(string, string, int?, string, string) ControllerBase.Problem(string, string, int?, string, string, IDictionary<string, object>) ControllerBase.ValidationProblem(ValidationProblemDetails) ControllerBase.ValidationProblem(ModelStateDictionary) ControllerBase.ValidationProblem() ControllerBase.ValidationProblem(string, string, int?, string, string, ModelStateDictionary) ControllerBase.ValidationProblem(string, string, int?, string, string, ModelStateDictionary, IDictionary<string, object>) ControllerBase.Created() ControllerBase.Created(string, object) ControllerBase.Created(Uri, object) ControllerBase.CreatedAtAction(string, object) ControllerBase.CreatedAtAction(string, object, object) ControllerBase.CreatedAtAction(string, string, object, object) ControllerBase.CreatedAtRoute(string, object) ControllerBase.CreatedAtRoute(object, object) ControllerBase.CreatedAtRoute(string, object, object) ControllerBase.Accepted() ControllerBase.Accepted(object) ControllerBase.Accepted(Uri) ControllerBase.Accepted(string) ControllerBase.Accepted(string, object) ControllerBase.Accepted(Uri, object) ControllerBase.AcceptedAtAction(string) ControllerBase.AcceptedAtAction(string, string) ControllerBase.AcceptedAtAction(string, object) ControllerBase.AcceptedAtAction(string, string, object) ControllerBase.AcceptedAtAction(string, object, object) ControllerBase.AcceptedAtAction(string, string, object, object) ControllerBase.AcceptedAtRoute(object) ControllerBase.AcceptedAtRoute(string) ControllerBase.AcceptedAtRoute(string, object) ControllerBase.AcceptedAtRoute(object, object) ControllerBase.AcceptedAtRoute(string, object, object) ControllerBase.Challenge() ControllerBase.Challenge(params string[]) ControllerBase.Challenge(AuthenticationProperties) ControllerBase.Challenge(AuthenticationProperties, params string[]) ControllerBase.Forbid() ControllerBase.Forbid(params string[]) ControllerBase.Forbid(AuthenticationProperties) ControllerBase.Forbid(AuthenticationProperties, params string[]) ControllerBase.SignIn(ClaimsPrincipal) ControllerBase.SignIn(ClaimsPrincipal, string) ControllerBase.SignIn(ClaimsPrincipal, AuthenticationProperties) ControllerBase.SignIn(ClaimsPrincipal, AuthenticationProperties, string) ControllerBase.SignOut() ControllerBase.SignOut(AuthenticationProperties) ControllerBase.SignOut(params string[]) ControllerBase.SignOut(AuthenticationProperties, params string[]) ControllerBase.TryUpdateModelAsync<TModel>(TModel) ControllerBase.TryUpdateModelAsync<TModel>(TModel, string) ControllerBase.TryUpdateModelAsync<TModel>(TModel, string, IValueProvider) ControllerBase.TryUpdateModelAsync<TModel>(TModel, string, params Expression<Func<TModel, object>>[]) ControllerBase.TryUpdateModelAsync<TModel>(TModel, string, Func<ModelMetadata, bool>) ControllerBase.TryUpdateModelAsync<TModel>(TModel, string, IValueProvider, params Expression<Func<TModel, object>>[]) ControllerBase.TryUpdateModelAsync<TModel>(TModel, string, IValueProvider, Func<ModelMetadata, bool>) ControllerBase.TryUpdateModelAsync(object, Type, string) ControllerBase.TryUpdateModelAsync(object, Type, string, IValueProvider, Func<ModelMetadata, bool>) ControllerBase.TryValidateModel(object) ControllerBase.TryValidateModel(object, string) ControllerBase.HttpContext ControllerBase.Request ControllerBase.Response ControllerBase.RouteData ControllerBase.ModelState ControllerBase.ControllerContext ControllerBase.MetadataProvider ControllerBase.ModelBinderFactory ControllerBase.Url ControllerBase.ObjectValidator ControllerBase.ProblemDetailsFactory ControllerBase.User ControllerBase.Empty object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SessionShellController(LocalProjectService) Initializes a new instance. public SessionShellController(LocalProjectService projectService) Parameters projectService LocalProjectService Properties DefaultParaTemplateDimension DefaultParaTemplateDimension [JsAce] public int DefaultParaTemplateDimension { get; set; } Property Value int DiffVisualRadius_mm Gets or sets the visual radius in millimeters for difference visualization. Controls the radius used for highlighting differences between workpiece states. [JsAce] public double DiffVisualRadius_mm { get; set; } Property Value double DispCacheMb Gets or sets the display cache size in megabytes. [Obsolete] public long DispCacheMb { get; set; } Property Value long DispCache_Mb Gets or sets the display cache size in megabytes. [JsAce] public long DispCache_Mb { get; set; } Property Value long EnableAutoMapOnSelectionEnd Gets or sets whether to automatically map selections when they end. [JsAce] public bool EnableAutoMapOnSelectionEnd { get; set; } Property Value bool EnableCollisionDetection Gets or sets whether collision detection is enabled. [JsAce(DocContentHtml = \"Enable Collision Detection.\")] public bool EnableCollisionDetection { get; set; } Property Value bool EnablePauseOnFailure EnablePauseOnFailure [JsAce(DocContentHtml = \"Enable Pause On Failure.\")] public bool EnablePauseOnFailure { get; set; } Property Value bool EnablePhysics Gets or sets whether milling force evaluation is enabled. [JsAce(DocContentHtml = \"Enable milling force evaluation.\")] public bool EnablePhysics { get; set; } Property Value bool EnableWearEffect Gets or sets whether tool wear effects are enabled in simulation. [JsAce] public bool EnableWearEffect { get; set; } Property Value bool FeedPerCycle Gets a new feed per cycle machining motion resolution instance. [JsAce] public FeedPerCycleMachiningMotionResolution FeedPerCycle { get; } Property Value FeedPerCycleMachiningMotionResolution FeedPerTooth Gets a new feed per tooth machining motion resolution instance. [JsAce] public FeedPerToothMachiningMotionResolution FeedPerTooth { get; } Property Value FeedPerToothMachiningMotionResolution Global [JsAce(\"Global[$1key]\")] public Dictionary<object, object> Global { get; } Property Value Dictionary<object, object> InitSpindleTemperature_C Gets or sets the initial spindle temperature in degrees Celsius. [JsAce(DocContentHtml = \"Spindle Temperature on initialization.\")] public double InitSpindleTemperature_C { get; set; } Property Value double JsAceCompletionProfileJsonArray Internal used. public static JsonArray JsAceCompletionProfileJsonArray { get; } Property Value JsonArray MachiningMotionResolution Gets or sets the machining motion resolution. [JsAce] public IMachiningMotionResolution MachiningMotionResolution { get; set; } Property Value IMachiningMotionResolution MachiningResolution Gets or sets the machining resolution in millimeters. For legacy compatable. [JsAce] [Obsolete] public double MachiningResolution { get; set; } Property Value double MachiningResolution_mm Gets or sets the machining resolution in millimeters. [JsAce] public double MachiningResolution_mm { get; set; } Property Value double MachiningSession public MachiningSession MachiningSession { get; } Property Value MachiningSession MapTask Task tracking the status of mapping operations. public Task MapTask { get; set; } Property Value Task MillingCycleDivisionNum Gets or sets the number of divisions per cycle for milling force calculation. This property should be set before milling force evaluation if TrainMillingPara(SampleFlag, string, double) is intended to be used. [JsAce] public static int MillingCycleDivisionNum { get; set; } Property Value int MillingForceCycleDivisionNum Gets or sets the number of divisions per cycle for milling force calculation. This property should be set before milling force evaluation if TrainMillingPara(SampleFlag, string, double) is intended to be used. [JsAce] [Obsolete] public static int MillingForceCycleDivisionNum { get; set; } Property Value int NcOptOption NcOptOption [JsAce] public NcOptOption NcOptOption { get; set; } Property Value NcOptOption OptEnableDepthCompensation Enables or disables depth compensation during optimization. [JsAce] public bool OptEnableDepthCompensation { get; set; } Property Value bool OptEnableFeedrate Gets or sets whether to enable feed rate optimization in NC optimization. [JsAce] public bool OptEnableFeedrate { get; set; } Property Value bool OptEnableForwardCompensation Enables or disables forward compensation during optimization. [JsAce] public bool OptEnableForwardCompensation { get; set; } Property Value bool OptEnableInterpolation Enables or disables reinterpolation for optimization. [JsAce] public bool OptEnableInterpolation { get; set; } Property Value bool OptEnableSideCompensation Enables or disables side compensation during optimization. [JsAce] public bool OptEnableSideCompensation { get; set; } Property Value bool OptExtendedPostDistance_mm Gets or sets the extended post-distance in millimeters for NC optimization. This is the distance after the current segment that will be considered for optimization. [JsAce] public double OptExtendedPostDistance_mm { get; set; } Property Value double OptExtendedPreDistance_mm Gets or sets the extended pre-distance in millimeters for NC optimization. This is the distance before the current segment that will be considered for optimization. [JsAce] public double OptExtendedPreDistance_mm { get; set; } Property Value double OptFeedrateAssignmentRatio Gets or sets the feedrate assignment ratio for optimization. If the feedrate change exceeds this ratio, the feedrate in the NC line will be updated. [JsAce] public double OptFeedrateAssignmentRatio { get; set; } Property Value double OptMaxAcceleration_mmds2 Maximum acceleration in mm/s² during optimization. Only takes effect on reinterpolated section. [JsAce(DocContentHtml = \"Only take effect on reinterpolated section.\")] public double OptMaxAcceleration_mmds2 { get; set; } Property Value double OptMaxFeedPerTooth_mm Gets or sets the maximum feed per tooth in millimeters for optimization. [JsAce] public double OptMaxFeedPerTooth_mm { get; set; } Property Value double OptMaxFeedrate_mmdmin Maximum feed rate in mm/min for cutting movements during optimization. [JsAce] public double OptMaxFeedrate_mmdmin { get; set; } Property Value double OptMaxJerk_mmds3 Maximum jerk in mm/s³ during optimization. Only takes effect on reinterpolated section. [JsAce(DocContentHtml = \"Only take effect on reinterpolated section.\")] public double OptMaxJerk_mmds3 { get; set; } Property Value double OptMinFeedPerTooth_mm Gets or sets the minimum feed per tooth in millimeters for optimization. [JsAce] public double OptMinFeedPerTooth_mm { get; set; } Property Value double OptMinFeedrate_mmdmin Minimum feed rate in mm/min for cutting movements during optimization. [JsAce] public double OptMinFeedrate_mmdmin { get; set; } Property Value double OptPreferedForce_N Preferred force in N for optimization. [JsAce] public double OptPreferedForce_N { get; set; } Property Value double OptRapidFeed_mmdmin Rapid feed rate in mm/min for non-cutting movements during optimization. [JsAce] public double OptRapidFeed_mmdmin { get; set; } Property Value double OptSpindlePowerSafetyFactor Safety factor for spindle power during optimization. [JsAce] public double OptSpindlePowerSafetyFactor { get; set; } Property Value double OptSpindlePowerUtilizationFactor Utilization factor for spindle power during optimization. It is the reciprocal of the spindle power safety factor. [JsAce] public double OptSpindlePowerUtilizationFactor { get; set; } Property Value double OptSpindleTorqueSafetyFactor Safety factor for spindle torque during optimization. [JsAce] public double OptSpindleTorqueSafetyFactor { get; set; } Property Value double OptSpindleTorqueUtilizationFactor Utilization factor for spindle torque during optimization. It is the reciprocal of the spindle torque safety factor. [JsAce] public double OptSpindleTorqueUtilizationFactor { get; set; } Property Value double OptThermalYieldSafetyFactor Safety factor for thermal yield during optimization. [JsAce] public double OptThermalYieldSafetyFactor { get; set; } Property Value double OptThermalYieldUtilizationFactor Utilization factor for thermal yield during optimization. It is the reciprocal of the thermal yield safety factor. [JsAce] public double OptThermalYieldUtilizationFactor { get; set; } Property Value double OptYieldingSafetyFactor Safety factor for yielding during optimization. [JsAce] public double OptYieldingSafetyFactor { get; set; } Property Value double OptYieldingUtilizationFactor Utilization factor for yielding during optimization. It is the reciprocal of the yielding safety factor. [JsAce] public double OptYieldingUtilizationFactor { get; set; } Property Value double ScriptOptions public ScriptOptions ScriptOptions { get; set; } Property Value ScriptOptions SessionShell Gets the underlying SessionShell instance. public SessionShell SessionShell { get; } Property Value SessionShell StepCount Gets the total number of milling steps. [JsAce] public int StepCount { get; } Property Value int Methods AddTimeDataByFile(string, string, double, double) Adds time-based data from a file to the time mapping dictionary with specified time bounds in seconds. [JsAce(\"AddTimeDataByFile($1key, $2relFile, $3beginTime, $4endTime)\")] [NonAction] public bool AddTimeDataByFile(string key, string relFile, double beginTime, double endTime) Parameters key string Key to identify the data relFile string Relative path to the data file beginTime double Beginning time in seconds endTime double Ending time in seconds Returns bool True if the data was successfully added, false otherwise AddTimeDataByFile(string, string, string, string) Adds time-based data from a file to the time mapping dictionary with specified time bounds. [JsAce(\"AddTimeDataByFile($1key, $2relFile, $3beginTime, $4endTime)\")] [HttpPost] public bool AddTimeDataByFile(string key, string relFile, string beginTimeText, string endTimeText) Parameters key string Key to identify the data relFile string Relative path to the data file beginTimeText string Beginning time as text (seconds or TimeSpan format) endTimeText string Ending time as text (seconds or TimeSpan format) Returns bool True if the data was successfully added, false otherwise AppendMessagesToFile(string, params string[]) Appends messages to a file, optionally filtered by tags. [JsAce(\"AppendMessagesToFile(\\\"dstRelFile\\\",flags)\")] [HttpPost] public void AppendMessagesToFile(string dstRelFile, params string[] flags) Parameters dstRelFile string Destination relative file path flags string[] Optional flags to filter messages by tags BeginPreserve() Begin Preserve section in optimzation process. [JsAce(\"BeginPreserve()\")] [HttpPost] public void BeginPreserve() BeginSelection(string, AnchorMode, IStepShift) Begin mark on current line. milling step() has not triggered yet. [NonAction] public void BeginSelection(string key, AnchorMode anchorMode = AnchorMode.LineBegin, IStepShift shift = null) Parameters key string Identifier key for the selection anchorMode AnchorMode Mode for anchoring the beginning of selection shift IStepShift Step shift to apply BeginSession() BeginSession(). Callable without an active session (it is how a session is started) but still requires a loaded project; routes straight to Hi.MachiningProcs.SessionShellController.LocalProjectService so it does not touch the null session-scoped facade. [HttpPost] public void BeginSession() ClearTimeMappingData() Clears all time mapping data. [JsAce] [HttpPost] public void ClearTimeMappingData() ConvertClToNcFiles(string) Converts the CLSF play of the current session into Fanuc NC files (writeback synthesis — MSYS tilt becomes G68.2, tool posture becomes G43.4 RTCP with rotary words). [JsAce(Snippet = \"ConvertClToNcFiles(\\\"Output/[NcName].nc\\\")\", DocContentHtml = \"Convert the played CLSF into Fanuc NC files by substitute template keyword \\\"[NcName]\\\"\")] [HttpPost] public IReadOnlyList<string> ConvertClToNcFiles(string relNcFileTemplate = \"Output/[NcName].nc\") Parameters relNcFileTemplate string Output path template; [NcName] is replaced by the source file name. Returns IReadOnlyList<string> Diff(double) Performs a difference analysis on the workpiece geometry to detect variations. [JsAce(\"Diff($1detectionRadius_mm)\")] [HttpPost] public void Diff(double detectionRadius_mm) Parameters detectionRadius_mm double Radius for detecting differences EmbedSingleDataPerStepByCsvFile(string) Reads a CSV file and performs time-based interpolation to map data to milling steps. It is one (step) - one (embedded-data) mapping. [JsAce(Snippet = \"EmbedSingleDataPerStepByCsvFile($1\\\"csvFile\\\")\")] [HttpPost] public void EmbedSingleDataPerStepByCsvFile(string csvFile) Parameters csvFile string Path to the CSV file relative to the base directory EndPreserve() End Preserve section in optimzation process. [JsAce(\"EndPreserve()\")] [HttpPost] public void EndPreserve() EndSelection(string, AnchorMode, IStepShift) End mark on current line for selection. [NonAction] public void EndSelection(string key, AnchorMode anchorMode = AnchorMode.LineEnd, IStepShift shift = null) Parameters key string Identifier key for the selection anchorMode AnchorMode Mode for anchoring the end of selection shift IStepShift Step shift to apply EndSession() EndSession(). Callable without an active session (a no-op when none is active); routes straight to Hi.MachiningProcs.SessionShellController.LocalProjectService. [HttpPost] public void EndSession() ErrorMessage(string) Displays an error message in the message host. [JsAce(\"ErrorMessage($1message)\")] [HttpPost] public void ErrorMessage(string message) Parameters message string The error message to display ExportMeshedGeomToStl(string, double) Exports the current meshed geometry to an STL file. [JsAce(\"ExportMeshedGeomToStl($1\\\"dstFile\\\",$2resolution_mm)\")] [HttpPost] public void ExportMeshedGeomToStl(string relFile, double resolution_mm = 0) Parameters relFile string Relative path to the output STL file resolution_mm double Resolution in millimeters (0 for default) ExportRuntimeGeomToStl(string, double) Legacy script alias of ExportMeshedGeomToStl(string, double); kept so old player scripts keep working. [Obsolete(\"Legacy alias; use ExportMeshedGeomToStl instead.\")] [HttpPost] public void ExportRuntimeGeomToStl(string relFile, double resolution_mm = 0) Parameters relFile string resolution_mm double FixedPace(double, double) Creates a fixed machining motion resolution with specified parameters. [JsAce(\"FixedPace($1linearResolution_mm, $2rotaryResolution_deg)\")] [NonAction] public FixedMachiningMotionResolution FixedPace(double linearResolution_mm, double rotaryResolution_deg) Parameters linearResolution_mm double Linear resolution in millimeters rotaryResolution_deg double Rotary resolution in degrees Returns FixedMachiningMotionResolution A new fixed machining motion resolution instance GetMillingStep(int) Retrieves a milling step at the specified index. [JsAce(Snippet = \"GetMillingStep($1\\\"stepIndex\\\")\")] [NonAction] public MachiningStep GetMillingStep(int stepIndex) Parameters stepIndex int Index of the milling step to retrieve Returns MachiningStep The milling step at the specified index GetStickMachiningToolObservationHeight_mm(int) Gets the observation height in millimeters for the specified stick machining tool. [JsAce(\"GetStickMachiningToolObservationHeight_mm($1toolId)\")] [HttpGet] public double GetStickMachiningToolObservationHeight_mm(int toolId) Parameters toolId int The ID of the tool Returns double The observation height in millimeters GetUniformFlutingShiftAngle_deg(int) Gets the shift angle in degrees for the uniform fluting of the specified tool, that is, for a cutter whose flutes all share one baseline flute contour. [JsAce(\"GetUniformFlutingShiftAngle_deg($1toolId)\")] [HttpGet] public double GetUniformFlutingShiftAngle_deg(int toolId) Parameters toolId int The ID of the tool Returns double The shift angle in degrees LineSelection(string, AnchorMode, IStepShift, AnchorMode, IStepShift) Create a line selection from begin to end mark. [NonAction] public void LineSelection(string key, AnchorMode beginAnchorMode = AnchorMode.LineBegin, IStepShift beginShift = null, AnchorMode endAnchorMode = AnchorMode.LineEnd, IStepShift endShift = null) Parameters key string Identifier key for the selection beginAnchorMode AnchorMode Mode for anchoring the beginning of selection beginShift IStepShift Step shift to apply at beginning endAnchorMode AnchorMode Mode for anchoring the end of selection endShift IStepShift Step shift to apply at end Map(string, IFileTimeSection, CycleSamplingMode?) Maps selection data to time section. [HttpPost] public Task Map(string key, IFileTimeSection fileTimeSection = null, StepTimeShotUtil.CycleSamplingMode? cycleSamplingMode = null) Parameters key string Identifier key for the selection fileTimeSection IFileTimeSection File time section, or null to use the one associated with the key cycleSamplingMode StepTimeShotUtil.CycleSamplingMode? Cycle sampling mode Returns Task Task representing the asynchronous mapping operation Message(string) Displays a message in the message host. [JsAce(\"Message($1message)\")] [HttpPost] public void Message(string message) Parameters message string The message to display OptimizeToFiles(string) Optimizes NC files and saves results using the specified file template. [JsAce(Snippet = \"OptimizeToFiles(\\\"Output/Opt-[NcName]\\\")\", DocContentHtml = \"Optimize To Files by substitude template keywoard \\\"[NcName]\\\"\")] [HttpPost] public void OptimizeToFiles(string relFileTemplate = \"Output/Opt-[NcName]\") Parameters relFileTemplate string Template for output file path, can include [NcName] placeholder Pace() Controls the pace of machining operations during execution. [JsAce(\"Pace();\")] [HttpPost] public void Pace() Pause() Pause Player [JsAce(DocContentHtml = \"Pause Player\")] [HttpPost] public void Pause() PlayAct(IAct, ISentenceCarrier, CancellationToken?) PlayAct(IAct, ISentenceCarrier, CancellationToken?) [JsAce] [NonAction] public void PlayAct(IAct act, ISentenceCarrier sourceCommand = null, CancellationToken? cancellationToken = null) Parameters act IAct sourceCommand ISentenceCarrier cancellationToken CancellationToken? PlayBrandNcFile(string) Plays a famous-brand NC code file with the specified relative path (no kind dispatch — always the brand runner). [JsAce(\"PlayBrandNcFile($1\\\"ncFile\\\");\")] [HttpPost] public void PlayBrandNcFile(string relNcFilePath) Parameters relNcFilePath string Relative path to the NC file PlayClFile(string) Plays an NX-CL (CLSF) file with the specified relative path. [JsAce(\"PlayClFile($1\\\"clFile\\\");\")] [HttpPost] public void PlayClFile(string relFilePath) Parameters relFilePath string Relative path to the CLSF file PlayClTeleport(double, double, double, double, double, double) PlayClTeleport(double, double, double, double, double, double) [JsAce] [HttpPost] public void PlayClTeleport(double x, double y, double z, double i, double j, double k) Parameters x double y double z double i double j double k double PlayCsvFile(string) Plays an CSV file with the specified relative path. [JsAce(\"PlayCsvFile($1\\\"csvFile\\\");\")] [HttpPost] public void PlayCsvFile(string relFilePath) Parameters relFilePath string Relative path to the CSV file PlayNc(string, string) Plays NC code directly from a string, executing each action and pacing between them. [JsAce(Snippet = \"PlayNc($1\\\"ncCommand\\\",$2\\\"\\\"(Direct Command)\\\"\\\");\", DocContentHtml = \"Play NC. second parameter is the file name alternative shows in the log.\")] [HttpPost] public void PlayNc(string ncText, string fileNameAlternative = \"--\") Parameters ncText string NC code as a string fileNameAlternative string Alternative name to display in logs PlayNcFile(string, NcKind) Plays an NC program file with the specified relative path, the runner picked by kind (Auto = by file extension: .cl/.cls/.clsf play as CL, .csv as CSV, anything else as brand NC). [JsAce(\"PlayNcFile($1\\\"ncFile\\\");\")] [HttpPost] public void PlayNcFile(string relNcFilePath, NcKind kind = NcKind.Auto) Parameters relNcFilePath string Relative path to the NC program file kind NcKind Which runner plays the file; Auto detects by extension. PlayToolingTeleport(int) PlayToolingTeleport(int) [JsAce] [HttpPost] public void PlayToolingTeleport(int toolId) Parameters toolId int Preserve() Preserve one line NC code in optimzation process. [JsAce(\"Preserve()\")] [HttpPost] public void Preserve() ProgressMessage(string) Displays a progress message in the message host. [JsAce(\"ProgressMessage($1message)\")] [HttpPost] public void ProgressMessage(string message) Parameters message string The progress message to display ReTrainMillingPara(SampleFlag, string, double) Re-trains milling parameters using the specified sample flag. [JsAce(\"ReTrainMillingPara(Fx|Fy|Fz, $1dstFile)\")] [HttpPost] public void ReTrainMillingPara(SampleFlag sampleFlag, string dstRelFile, double outlierRatio = 2) Parameters sampleFlag SampleFlag Sample flag indicating which components to train dstRelFile string Destination relative file path outlierRatio double Outlier ratio for data filtering ReadMeshedGeom(string) Reads meshed geometry from a file. [JsAce(\"ReadMeshedGeom($1\\\"srcFile\\\")\")] [HttpPost] public void ReadMeshedGeom(string relFile) Parameters relFile string Relative path to the input file ReadRuntimeGeom(string) Legacy script alias of ReadMeshedGeom(string); kept so old player scripts keep working. [Obsolete(\"Legacy alias; use ReadMeshedGeom instead.\")] [HttpPost] public void ReadRuntimeGeom(string relFile) Parameters relFile string RegisterStepVariable(string, string, string, string, Func<MachiningStep, object>) Registers a step variable for tracking during execution. [JsAce(Snippet = \"RegisterStepVariable(\\\"$1key\\\",\\\"$2name\\\",\\\"$3unit\\\",\\\"$4formatString\\\",\\\"$5variableFunc\\\")\", DocContentHtml = \"<p>Register Step Variable.</p> <p>\\\"unit\\\" is nullable</p> <p>\\\"formatString\\\" is nullable</p>\")] [NonAction] public void RegisterStepVariable(string key, string name, string unit, string formatString, Func<MachiningStep, object> variableFunc = null) Parameters key string Unique key to identify the variable name string Human-readable name of the variable unit string Physical unit of the variable (can be null) formatString string Format string for displaying the variable (can be null) variableFunc Func<MachiningStep, object> Function to compute the variable value from a milling step (can be null) RemoveFlyPiece() Removes any disconnected or “flying” pieces from the workpiece geometry. [JsAce] [HttpPost] public void RemoveFlyPiece() Reset() Reset Player [JsAce(DocContentHtml = \"Reset Player\")] [HttpPost] public void Reset() ResetRuntime() Clears internal buffers. [JsAce] [HttpPost] public void ResetRuntime() RunBrandNcFile(string) Runs a famous-brand NC code file with the specified relative path (no kind dispatch — always the brand runner). [JsAce(\"RunBrandNcFile($1\\\"ncFile\\\");\")] [NonAction] public IEnumerable<Action> RunBrandNcFile(string relNcFilePath) Parameters relNcFilePath string Relative path to the NC file Returns IEnumerable<Action> Enumerable sequence of actions to be executed RunNc(string, string) Runs NC code directly from a string. [JsAce(Snippet = \"RunNc($1\\\"ncCommand\\\",$2\\\"\\\"(Direct Command)\\\"\\\");\", DocContentHtml = \"Run NC. second parameter is the file name alternative shows in the log.\")] [NonAction] public IEnumerable<Action> RunNc(string ncText, string fileNameAlternative = \"--\") Parameters ncText string NC code as a string fileNameAlternative string Alternative name to display in logs Returns IEnumerable<Action> Enumerable sequence of actions to be executed RunNcFile(string, NcKind) Runs an NC program file with the specified relative path, the runner picked by kind (Auto = by file extension). [JsAce(\"RunNcFile($1\\\"ncFile\\\");\")] [NonAction] public IEnumerable<Action> RunNcFile(string relNcFilePath, NcKind kind = NcKind.Auto) Parameters relNcFilePath string Relative path to the NC program file kind NcKind Which runner runs the file; Auto detects by extension. Returns IEnumerable<Action> Enumerable sequence of actions to be executed SetNcResolutionFeedPerCycle() Sets NC resolution to feed per cycle mode. [HttpPost] public void SetNcResolutionFeedPerCycle() SetNcResolutionFeedPerTooth() Sets NC resolution to feed per tooth mode. [HttpPost] public void SetNcResolutionFeedPerTooth() SetNcResolutionFixed(double, double) Sets NC resolution to fixed mode with specified resolution values. [HttpPost] public void SetNcResolutionFixed(double linearResolution_mm, double rotaryResolution_deg) Parameters linearResolution_mm double Linear resolution in millimeters. rotaryResolution_deg double Rotary resolution in degrees. SetStickMachiningToolObservationHeight_mm(int, double) Sets the observation height in millimeters for the specified stick machining tool. [JsAce(\"SetStickMachiningToolObservationHeight_mm($1toolId,$2height_mm)\")] [HttpPost] public void SetStickMachiningToolObservationHeight_mm(int toolId, double height) Parameters toolId int The ID of the tool height double The observation height in millimeters to set SetUniformFlutingShiftAngle_deg(int, double) Sets the shift angle in degrees for the uniform fluting of the specified tool, that is, for a cutter whose flutes all share one baseline flute contour. [JsAce(\"SetUniformFlutingShiftAngle_deg($1toolId,$2angle_deg)\")] [HttpPost] public void SetUniformFlutingShiftAngle_deg(int toolId, double angle_deg) Parameters toolId int The ID of the tool angle_deg double The shift angle in degrees to set ShiftDistance_mm(double) Creates a distance shift object representing the specified distance in millimeters. [NonAction] public DistanceShift ShiftDistance_mm(double distanceShift_mm) Parameters distanceShift_mm double Distance shift in millimeters Returns DistanceShift Distance shift object ShiftTime_s(double) Creates a time shift object representing the specified time in seconds. [NonAction] public TimeShift ShiftTime_s(double seconds) Parameters seconds double Time in seconds Returns TimeShift Time shift object TrainMillingPara(SampleFlag, string, double) Trains milling parameters using the specified sample flag. [JsAce(\"TrainMillingPara(Fx|Fy|Fz, $1dstFile)\")] [HttpPost] public void TrainMillingPara(SampleFlag sampleFlag, string dstRelFile, double outlierRatio = 2) Parameters sampleFlag SampleFlag Sample flag indicating which components to train dstRelFile string Destination relative file path outlierRatio double Outlier ratio for data filtering WarningMessage(string) Displays a warning message in the message host. [JsAce(\"WarningMessage($1message)\")] [HttpPost] public void WarningMessage(string message) Parameters message string The warning message to display WriteMeshedGeom(string) Writes the current meshed geometry to a file. [JsAce(\"WriteMeshedGeom($1\\\"dstFile\\\")\")] [HttpPost] public void WriteMeshedGeom(string relFile) Parameters relFile string Relative path to the output file WriteRuntimeGeom(string) Legacy script alias of WriteMeshedGeom(string); kept so old player scripts keep working. [Obsolete(\"Legacy alias; use WriteMeshedGeom instead.\")] [HttpPost] public void WriteRuntimeGeom(string relFile) Parameters relFile string WriteShotFiles(double, string) Writes time-series data to shot files with the specified resolution period (alternative parameter order). [NonAction] public void WriteShotFiles(double resolutionPeroid_ms, string relFileTemplate) Parameters resolutionPeroid_ms double Resolution period in milliseconds relFileTemplate string Template for output file path, can include [NcName] placeholder WriteShotFiles(string, double) Writes time-series data to shot files with the specified resolution period. [JsAce(Snippet = \"WriteShotFiles(\\\"Output/[NcName].shot.csv\\\",resolutionPeroid_ms)\", DocContentHtml = \"Write time series data by resolutionPeroid_ms\")] [HttpPost] public void WriteShotFiles(string relFileTemplate = \"Output/[NcName].shot.csv\", double resolutionPeroid_ms = 1) Parameters relFileTemplate string Template for output file path, can include [NcName] placeholder resolutionPeroid_ms double Resolution period in milliseconds WriteStepFiles(string) Writes step-series data to files with the specified file template. [JsAce(Snippet = \"WriteStepFiles(\\\"Output/[NcName].step.csv\\\")\", DocContentHtml = \"Write step series data.\")] [HttpPost] public void WriteStepFiles(string relFileTemplate = \"Output/[NcName].step.csv\") Parameters relFileTemplate string Template for output file path, can include [NcName] placeholder"
  },
  "api/Hi.MachiningProcs.SetupController.html": {
    "href": "api/Hi.MachiningProcs.SetupController.html",
    "title": "Class SetupController | HiAPI-C# 2025",
    "summary": "Class SetupController Namespace Hi.MachiningProcs Assembly HiNc.dll Controller for setup operations of machining projects. [ApiController] [Route(\"api/[controller]/[action]\")] public class SetupController : ControllerBase Inheritance object ControllerBase SetupController Inherited Members ControllerBase.StatusCode(int) ControllerBase.StatusCode(int, object) ControllerBase.Content(string) ControllerBase.Content(string, string) ControllerBase.Content(string, string, Encoding) ControllerBase.Content(string, MediaTypeHeaderValue) ControllerBase.NoContent() ControllerBase.Ok() ControllerBase.Ok(object) ControllerBase.Redirect(string) ControllerBase.RedirectPermanent(string) ControllerBase.RedirectPreserveMethod(string) ControllerBase.RedirectPermanentPreserveMethod(string) ControllerBase.LocalRedirect(string) ControllerBase.LocalRedirectPermanent(string) ControllerBase.LocalRedirectPreserveMethod(string) ControllerBase.LocalRedirectPermanentPreserveMethod(string) ControllerBase.RedirectToAction() ControllerBase.RedirectToAction(string) ControllerBase.RedirectToAction(string, object) ControllerBase.RedirectToAction(string, string) ControllerBase.RedirectToAction(string, string, object) ControllerBase.RedirectToAction(string, string, string) ControllerBase.RedirectToAction(string, string, object, string) ControllerBase.RedirectToActionPreserveMethod(string, string, object, string) ControllerBase.RedirectToActionPermanent(string) ControllerBase.RedirectToActionPermanent(string, object) ControllerBase.RedirectToActionPermanent(string, string) ControllerBase.RedirectToActionPermanent(string, string, string) ControllerBase.RedirectToActionPermanent(string, string, object) ControllerBase.RedirectToActionPermanent(string, string, object, string) ControllerBase.RedirectToActionPermanentPreserveMethod(string, string, object, string) ControllerBase.RedirectToRoute(string) ControllerBase.RedirectToRoute(object) ControllerBase.RedirectToRoute(string, object) ControllerBase.RedirectToRoute(string, string) ControllerBase.RedirectToRoute(string, object, string) ControllerBase.RedirectToRoutePreserveMethod(string, object, string) ControllerBase.RedirectToRoutePermanent(string) ControllerBase.RedirectToRoutePermanent(object) ControllerBase.RedirectToRoutePermanent(string, object) ControllerBase.RedirectToRoutePermanent(string, string) ControllerBase.RedirectToRoutePermanent(string, object, string) ControllerBase.RedirectToRoutePermanentPreserveMethod(string, object, string) ControllerBase.RedirectToPage(string) ControllerBase.RedirectToPage(string, object) ControllerBase.RedirectToPage(string, string) ControllerBase.RedirectToPage(string, string, object) ControllerBase.RedirectToPage(string, string, string) ControllerBase.RedirectToPage(string, string, object, string) ControllerBase.RedirectToPagePermanent(string) ControllerBase.RedirectToPagePermanent(string, object) ControllerBase.RedirectToPagePermanent(string, string) ControllerBase.RedirectToPagePermanent(string, string, string) ControllerBase.RedirectToPagePermanent(string, string, object, string) ControllerBase.RedirectToPagePreserveMethod(string, string, object, string) ControllerBase.RedirectToPagePermanentPreserveMethod(string, string, object, string) ControllerBase.File(byte[], string) ControllerBase.File(byte[], string, bool) ControllerBase.File(byte[], string, string) ControllerBase.File(byte[], string, string, bool) ControllerBase.File(byte[], string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.File(byte[], string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.File(byte[], string, string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.File(byte[], string, string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.File(Stream, string) ControllerBase.File(Stream, string, bool) ControllerBase.File(Stream, string, string) ControllerBase.File(Stream, string, string, bool) ControllerBase.File(Stream, string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.File(Stream, string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.File(Stream, string, string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.File(Stream, string, string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.File(string, string) ControllerBase.File(string, string, bool) ControllerBase.File(string, string, string) ControllerBase.File(string, string, string, bool) ControllerBase.File(string, string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.File(string, string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.File(string, string, string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.File(string, string, string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.PhysicalFile(string, string) ControllerBase.PhysicalFile(string, string, bool) ControllerBase.PhysicalFile(string, string, string) ControllerBase.PhysicalFile(string, string, string, bool) ControllerBase.PhysicalFile(string, string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.PhysicalFile(string, string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.PhysicalFile(string, string, string, DateTimeOffset?, EntityTagHeaderValue) ControllerBase.PhysicalFile(string, string, string, DateTimeOffset?, EntityTagHeaderValue, bool) ControllerBase.Unauthorized() ControllerBase.Unauthorized(object) ControllerBase.NotFound() ControllerBase.NotFound(object) ControllerBase.BadRequest() ControllerBase.BadRequest(object) ControllerBase.BadRequest(ModelStateDictionary) ControllerBase.UnprocessableEntity() ControllerBase.UnprocessableEntity(object) ControllerBase.UnprocessableEntity(ModelStateDictionary) ControllerBase.Conflict() ControllerBase.Conflict(object) ControllerBase.Conflict(ModelStateDictionary) ControllerBase.Problem(string, string, int?, string, string) ControllerBase.Problem(string, string, int?, string, string, IDictionary<string, object>) ControllerBase.ValidationProblem(ValidationProblemDetails) ControllerBase.ValidationProblem(ModelStateDictionary) ControllerBase.ValidationProblem() ControllerBase.ValidationProblem(string, string, int?, string, string, ModelStateDictionary) ControllerBase.ValidationProblem(string, string, int?, string, string, ModelStateDictionary, IDictionary<string, object>) ControllerBase.Created() ControllerBase.Created(string, object) ControllerBase.Created(Uri, object) ControllerBase.CreatedAtAction(string, object) ControllerBase.CreatedAtAction(string, object, object) ControllerBase.CreatedAtAction(string, string, object, object) ControllerBase.CreatedAtRoute(string, object) ControllerBase.CreatedAtRoute(object, object) ControllerBase.CreatedAtRoute(string, object, object) ControllerBase.Accepted() ControllerBase.Accepted(object) ControllerBase.Accepted(Uri) ControllerBase.Accepted(string) ControllerBase.Accepted(string, object) ControllerBase.Accepted(Uri, object) ControllerBase.AcceptedAtAction(string) ControllerBase.AcceptedAtAction(string, string) ControllerBase.AcceptedAtAction(string, object) ControllerBase.AcceptedAtAction(string, string, object) ControllerBase.AcceptedAtAction(string, object, object) ControllerBase.AcceptedAtAction(string, string, object, object) ControllerBase.AcceptedAtRoute(object) ControllerBase.AcceptedAtRoute(string) ControllerBase.AcceptedAtRoute(string, object) ControllerBase.AcceptedAtRoute(object, object) ControllerBase.AcceptedAtRoute(string, object, object) ControllerBase.Challenge() ControllerBase.Challenge(params string[]) ControllerBase.Challenge(AuthenticationProperties) ControllerBase.Challenge(AuthenticationProperties, params string[]) ControllerBase.Forbid() ControllerBase.Forbid(params string[]) ControllerBase.Forbid(AuthenticationProperties) ControllerBase.Forbid(AuthenticationProperties, params string[]) ControllerBase.SignIn(ClaimsPrincipal) ControllerBase.SignIn(ClaimsPrincipal, string) ControllerBase.SignIn(ClaimsPrincipal, AuthenticationProperties) ControllerBase.SignIn(ClaimsPrincipal, AuthenticationProperties, string) ControllerBase.SignOut() ControllerBase.SignOut(AuthenticationProperties) ControllerBase.SignOut(params string[]) ControllerBase.SignOut(AuthenticationProperties, params string[]) ControllerBase.TryUpdateModelAsync<TModel>(TModel) ControllerBase.TryUpdateModelAsync<TModel>(TModel, string) ControllerBase.TryUpdateModelAsync<TModel>(TModel, string, IValueProvider) ControllerBase.TryUpdateModelAsync<TModel>(TModel, string, params Expression<Func<TModel, object>>[]) ControllerBase.TryUpdateModelAsync<TModel>(TModel, string, Func<ModelMetadata, bool>) ControllerBase.TryUpdateModelAsync<TModel>(TModel, string, IValueProvider, params Expression<Func<TModel, object>>[]) ControllerBase.TryUpdateModelAsync<TModel>(TModel, string, IValueProvider, Func<ModelMetadata, bool>) ControllerBase.TryUpdateModelAsync(object, Type, string) ControllerBase.TryUpdateModelAsync(object, Type, string, IValueProvider, Func<ModelMetadata, bool>) ControllerBase.TryValidateModel(object) ControllerBase.TryValidateModel(object, string) ControllerBase.HttpContext ControllerBase.Request ControllerBase.Response ControllerBase.RouteData ControllerBase.ModelState ControllerBase.ControllerContext ControllerBase.MetadataProvider ControllerBase.ModelBinderFactory ControllerBase.Url ControllerBase.ObjectValidator ControllerBase.ProblemDetailsFactory ControllerBase.User ControllerBase.Empty object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SetupController(LocalProjectService, ILogger<SetupController>) Initializes a new instance. public SetupController(LocalProjectService projectService, ILogger<SetupController> logger) Parameters projectService LocalProjectService logger ILogger<SetupController> Properties InitResolution_mm InitResolution_mm. public double InitResolution_mm { get; set; } Property Value double Methods ApplyClMillingDevice() Applies a CL milling device to the machining equipment. [HttpPost] public void ApplyClMillingDevice() LoadFixture(string) Loads a fixture from the specified XML file path. [HttpPost] public void LoadFixture(string fixtureXmlFilePath) Parameters fixtureXmlFilePath string The XML file path of the fixture to load. LoadProject(string) Loads a machining project from the specified file path. [HttpPost] public void LoadProject(string filePath) Parameters filePath string The file path to load the project from. SaveProject() Saves the current machining project. [HttpPost] public void SaveProject()"
  },
  "api/Hi.MachiningProcs.ShellProgress.html": {
    "href": "api/Hi.MachiningProcs.ShellProgress.html",
    "title": "Class ShellProgress | HiAPI-C# 2025",
    "summary": "Class ShellProgress Namespace Hi.MachiningProcs Assembly HiMech.dll Append-only, thread-safe sink for session-level routine / lifecycle messages on the IMessage channel — one of the partitioned message homes. This is partitioned by message kind, orthogonal to the other sinks: plain SimpleMessage notices that belong to the session as a whole (cache reset, file load / save progress, session start/done) live here; messages tied to a particular machining step live in StepDiagnosticProgress; NC-pipeline diagnostics live in NcDiagnosticProgress. Append-only: session-routine messages are emitted sequentially, so report order already is execution order — there is no per-step anchor and no stable-index bookkeeping. public class ShellProgress : IProgress<IMessage> Inheritance object ShellProgress Implements IProgress<IMessage> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) StepDiagnosticAnchorUtil.AnchoredToStep(IProgress<StepDiagnostic>, int, ISentenceCarrier) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Messages All reported messages, in append (report) order. Thread-safe for concurrent appends. public SynList<IMessage> Messages { get; } Property Value SynList<IMessage> Methods Clear() Removes all messages (e.g. on session reset). public void Clear() Report(IMessage) Reports a progress update. public void Report(IMessage value) Parameters value IMessage The value of the updated progress. Events Cleared Raised after Clear() empties the collection. public event Action Cleared Event Type Action MessageAdded Raised after a message has been appended. Carries the index it landed at in Messages and the appended message, so a consumer can place it and reach nearby items by indexing into Messages. public event Action<int, IMessage> MessageAdded Event Type Action<int, IMessage>"
  },
  "api/Hi.MachiningProcs.SpindleSpeedCache.html": {
    "href": "api/Hi.MachiningProcs.SpindleSpeedCache.html",
    "title": "Class SpindleSpeedCache | HiAPI-C# 2025",
    "summary": "Class SpindleSpeedCache Namespace Hi.MachiningProcs Assembly HiMech.dll Represents cached spindle speed information. public class SpindleSpeedCache Inheritance object SpindleSpeedCache Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SpindleSpeedCache(SpindleSpeedCache) Initializes a new instance by copying from another instance. public SpindleSpeedCache(SpindleSpeedCache src) Parameters src SpindleSpeedCache The source instance to copy from. SpindleSpeedCache(double, double, double, double, double, double, double, double) Initializes a new instance. public SpindleSpeedCache(double spindleSpeed_cycleDs, double infInsistentRatioSpindleTorqueBoundary_Nm, double infInsistentRatioSpindlePowerBoundary_W, double minInsistentRatioSpindleTorqueBoundary_Nm, double minInsistentRatioSpindlePowerBoundary_W, double heatCapacity_JdK, double convectionPara_WdK, double dryRunPower_W) Parameters spindleSpeed_cycleDs double The spindle speed in cycles per second. infInsistentRatioSpindleTorqueBoundary_Nm double The infinite insistent ratio spindle torque boundary in Newton-meters. infInsistentRatioSpindlePowerBoundary_W double The infinite insistent ratio spindle power boundary in watts. minInsistentRatioSpindleTorqueBoundary_Nm double The minimum insistent ratio spindle torque boundary in Newton-meters. minInsistentRatioSpindlePowerBoundary_W double The minimum insistent ratio spindle power boundary in watts. heatCapacity_JdK double The heat capacity in joules per Kelvin. convectionPara_WdK double The convection parameter in watts per Kelvin. dryRunPower_W double The dry run power in watts. Properties ConvectionPara_WdK Gets or sets the convection parameter in watts per Kelvin. public double ConvectionPara_WdK { get; set; } Property Value double DryRunPower_W Gets or sets the dry run power in watts. public double DryRunPower_W { get; set; } Property Value double HeatCapacity_JdK Gets or sets the heat capacity in joules per Kelvin. public double HeatCapacity_JdK { get; set; } Property Value double InfInsistentRatioSpindlePowerBoundary_W Gets or sets the infinite insistent ratio spindle power boundary in watts. public double InfInsistentRatioSpindlePowerBoundary_W { get; set; } Property Value double InfInsistentRatioSpindleTorqueBoundary_Nm Gets or sets the infinite insistent ratio spindle torque boundary in Newton-meters. public double InfInsistentRatioSpindleTorqueBoundary_Nm { get; set; } Property Value double MinInsistentRatioSpindlePowerBoundary_W Gets or sets the minimum insistent ratio spindle power boundary in watts. public double MinInsistentRatioSpindlePowerBoundary_W { get; set; } Property Value double MinInsistentRatioSpindleTorqueBoundary_Nm Gets or sets the minimum insistent ratio spindle torque boundary in Newton-meters. public double MinInsistentRatioSpindleTorqueBoundary_Nm { get; set; } Property Value double SpindleSpeed_cycleDs Gets or sets the spindle speed in cycles per second. public double SpindleSpeed_cycleDs { get; set; } Property Value double Methods Create(SpindleCapability, MachineMotionStep, SpindleSpeedCache, Action<string>) Creates a SpindleSpeedCache from spindle capability and machine motion step. Returns preSpindleSpeedCache if the spindle speed is unchanged or the capability data is incomplete. public static SpindleSpeedCache Create(SpindleCapability spindleCapability, MachineMotionStep machineMotionStep, SpindleSpeedCache preSpindleSpeedCache, Action<string> onWarning) Parameters spindleCapability SpindleCapability machineMotionStep MachineMotionStep preSpindleSpeedCache SpindleSpeedCache onWarning Action<string> Returns SpindleSpeedCache"
  },
  "api/Hi.MachiningProcs.StepDiagnostic.html": {
    "href": "api/Hi.MachiningProcs.StepDiagnostic.html",
    "title": "Class StepDiagnostic | HiAPI-C# 2025",
    "summary": "Class StepDiagnostic Namespace Hi.MachiningProcs Assembly HiMech.dll An IMessage produced while constructing a MachiningStep, anchored to the step's execution-order StepIndex and (when available) its NC-source SentenceCarrier. Decorator over an inner Message — the five IMessage members delegate to it — so a plain SimpleMessage emitted during step processing can be upgraded to a step-anchored diagnostic without the producer needing to know the step context. public class StepDiagnostic : IMessage, IMotionStepIndex Inheritance object StepDiagnostic Implements IMessage IMotionStepIndex Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors StepDiagnostic(int, ISentenceCarrier, IMessage) Initializes a new instance of the StepDiagnostic class. public StepDiagnostic(int stepIndex, ISentenceCarrier sentenceCarrier, IMessage message) Parameters stepIndex int Execution-order index of the step. sentenceCarrier ISentenceCarrier NC-source carrier for the step; may be null. message IMessage The wrapped inner message. Properties Message The wrapped message supplying severity / category / id / notification / detail. public IMessage Message { get; } Property Value IMessage SentenceCarrier NC-source carrier for the step; null when the source is not an ISentenceCarrier (e.g. the legacy hard / CSV runners, which the soft runner is expected to supersede). public ISentenceCarrier SentenceCarrier { get; } Property Value ISentenceCarrier StepIndex Execution-order index of the step this diagnostic belongs to. public int StepIndex { get; } Property Value int Methods GetArgs() Gets the values interpolated into GetFormat(); null when GetFormat() is null, possibly empty for a hole-less template. Default interface method so external implementers are unaffected. public object[] GetArgs() Returns object[] The interpolation arguments, or null when untemplated. GetCategory() Gets the classification — see Category. public Category GetCategory() Returns Category The category of this message. GetDetail() Gets the optional detail payload or exception; null when not applicable. public object GetDetail() Returns object The detail object, or null. GetFormat() Gets the composite-format template behind GetNotification() — a {0}-style .NET format string — when this message was produced from an interpolated template; null when the notification has no structured template. Together with GetArgs() this lets a consumer re-render the message in another language without losing the interpolated live values, while GetNotification() stays the invariant English rendering. Default interface method so external implementers are unaffected. public string GetFormat() Returns string The composite format string, or null when untemplated. GetId() Gets the structured id used for filtering / suppression; may be null. public string GetId() Returns string The message id, or null when not applicable. GetNotification() Gets the end-user friendly notification text. public string GetNotification() Returns string The notification text. GetSeverity() Gets the importance level — see Severity. public Severity GetSeverity() Returns Severity The severity of this message. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.MachiningProcs.StepDiagnosticAnchorUtil.html": {
    "href": "api/Hi.MachiningProcs.StepDiagnosticAnchorUtil.html",
    "title": "Class StepDiagnosticAnchorUtil | HiAPI-C# 2025",
    "summary": "Class StepDiagnosticAnchorUtil Namespace Hi.MachiningProcs Assembly HiMech.dll Bridges a step-anchored IProgress<T> sink (e.g. StepDiagnosticProgress) back to the generic IProgress<T> surface, so out-of-step-pipeline producers can keep using the id-first MessageUtil shorthands (ValidationError, ConfigurationWarning, …) and still land a StepDiagnostic on the sink. public static class StepDiagnosticAnchorUtil Inheritance object StepDiagnosticAnchorUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods AnchoredToStep(IProgress<StepDiagnostic>, int, ISentenceCarrier) Wraps sink in an IProgress<T> that upgrades every reported message to a StepDiagnostic anchored to stepIndex / carrier (an already-anchored StepDiagnostic passes through unchanged). Returns null when sink is null, so the null-safe MessageUtil shorthands remain a no-op. public static IProgress<IMessage> AnchoredToStep(this IProgress<StepDiagnostic> sink, int stepIndex, ISentenceCarrier carrier = null) Parameters sink IProgress<StepDiagnostic> The step-anchored destination; null yields a null adapter. stepIndex int Motion-step index to anchor plain messages to (typically ShellThreadStepIndex). carrier ISentenceCarrier Optional NC-source carrier for the step; may be null. Returns IProgress<IMessage>"
  },
  "api/Hi.MachiningProcs.StepDiagnosticProgress.html": {
    "href": "api/Hi.MachiningProcs.StepDiagnosticProgress.html",
    "title": "Class StepDiagnosticProgress | HiAPI-C# 2025",
    "summary": "Class StepDiagnosticProgress Namespace Hi.MachiningProcs Assembly HiMech.dll Append-only, thread-safe sink for step-anchored diagnostics on the IMessage channel. This sink stores only StepDiagnostic: every message is anchored to a motion step. Per-step batches arrive via FlushTo(IProgress<StepDiagnostic>); out-of-pipeline emits (e.g. stroke-limit / tooling diagnostics) anchor themselves with AnchoredToStep(IProgress<StepDiagnostic>, int, ISentenceCarrier) before reporting. Data that already has another owner is not duplicated here — NC diagnostics live in NcDiagnosticProgress, plain session-level notices live in ShellProgress, cutter positions live in the CL strip. Because every StepDiagnostic carries its own StepIndex anchor, ordering is recovered downstream by sorting on that anchor. Producers therefore only ever Report(StepDiagnostic) (append) — even from parallel step-processing tasks — and never insert at a computed position. public class StepDiagnosticProgress : IProgress<StepDiagnostic> Inheritance object StepDiagnosticProgress Implements IProgress<StepDiagnostic> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) StepDiagnosticAnchorUtil.AnchoredToStep(IProgress<StepDiagnostic>, int, ISentenceCarrier) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Messages All reported diagnostics, in append (report) order. The collection is thread-safe for concurrent appends from parallel step-processing tasks. public SynList<StepDiagnostic> Messages { get; } Property Value SynList<StepDiagnostic> Methods Clear() Removes all messages (e.g. on session reset). public void Clear() Report(StepDiagnostic) Reports a progress update. public void Report(StepDiagnostic value) Parameters value StepDiagnostic The value of the updated progress. Events Cleared Raised after Clear() empties the collection. public event Action Cleared Event Type Action MessageAdded Raised after a diagnostic has been appended. Carries the index it landed at in Messages and the appended diagnostic, so a consumer can place it and reach nearby items by indexing into Messages. The index is captured atomically with the append, so it stays correct under concurrent step-task reports. public event Action<int, StepDiagnostic> MessageAdded Event Type Action<int, StepDiagnostic>"
  },
  "api/Hi.MachiningProcs.StepScopedProgress.html": {
    "href": "api/Hi.MachiningProcs.StepScopedProgress.html",
    "title": "Class StepScopedProgress | HiAPI-C# 2025",
    "summary": "Class StepScopedProgress Namespace Hi.MachiningProcs Assembly HiMech.dll A per-step IProgress<T> of IMessage that accumulates the messages emitted while one step is built, upgrading any plain message to a StepDiagnostic anchored to this step's StepIndex / SentenceCarrier. An already step-anchored StepDiagnostic is kept unchanged. (NC diagnostics are not seen here — they live in their own NcDiagnosticProgress, not on this channel.) It does not forward to a downstream sink as messages arrive; instead it collects them into MessageList and is drained once via FlushTo(IProgress<StepDiagnostic>) at the step's sequential post-physics stage. Because that stage runs strictly in step order, the per-step batches land in execution order with no position-scanning insert. No locking: a single step's construction is a data-dependency chain (substraction → physics → post-physics), so only one task writes MessageList at a time; parallelism across steps writes to different scopes. Each parallel step task therefore holds its own instance — never a shared mutable \"current step\" on StepDiagnosticProgress, which would race. public class StepScopedProgress : IProgress<IMessage>, IProgressMessage, IMessage, IMotionStepIndex Inheritance object StepScopedProgress Implements IProgress<IMessage> IProgressMessage IMessage IMotionStepIndex Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) StepDiagnosticAnchorUtil.AnchoredToStep(IProgress<StepDiagnostic>, int, ISentenceCarrier) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors StepScopedProgress(int, ISentenceCarrier) Initializes a new instance of the StepScopedProgress class. public StepScopedProgress(int stepIndex, ISentenceCarrier sentenceCarrier) Parameters stepIndex int Execution-order index of the step. sentenceCarrier ISentenceCarrier NC-source carrier for the step; may be null. Properties MessageList Messages accumulated for this step, in emission order — already upgraded to StepDiagnostic by Report(IMessage). Written by the step's pipelined (one-at-a-time) construction tasks, then drained once via FlushTo(IProgress<StepDiagnostic>). public List<StepDiagnostic> MessageList { get; } Property Value List<StepDiagnostic> SentenceCarrier NC-source carrier for the step; may be null. public ISentenceCarrier SentenceCarrier { get; } Property Value ISentenceCarrier StepIndex Execution-order index of the step this scope anchors to. public int StepIndex { get; } Property Value int Methods FlushTo(IProgress<StepDiagnostic>) Drains the accumulated MessageList into sink in order. Call once, at the step's sequential post-physics stage, so the session sink receives whole per-step batches already in execution order. public void FlushTo(IProgress<StepDiagnostic> sink) Parameters sink IProgress<StepDiagnostic> The downstream sink (typically the session StepDiagnosticProgress); no-op if null. Report(IMessage) Reports a progress update. public void Report(IMessage value) Parameters value IMessage The value of the updated progress."
  },
  "api/Hi.MachiningProcs.html": {
    "href": "api/Hi.MachiningProcs.html",
    "title": "Namespace Hi.MachiningProcs | HiAPI-C# 2025",
    "summary": "Namespace Hi.MachiningProcs Classes AllowNoActiveSessionAttribute Marks a session-scoped controller action as callable without an active session, exempting it from RequireActiveSessionAttribute. Use on the session lifecycle entry points (BeginSession / EndSession), which by definition run when no session exists yet. AllowNoLoadedProjectAttribute Marks a project-level controller action as callable without a loaded project, exempting it from RequireLoadedProjectAttribute. Use on the endpoints that create or load a project (which by definition run when no project is open yet). ApiActionResult The shared outcome envelope for a web-API action: whether it succeeded and the messages it reported, in order. Returned by the project-level surface (LocalProjectServiceController) and, on the no-active-session boundary, by the session-scoped surface (SessionShellController via RequireActiveSessionAttribute). A REST / AI caller therefore reads the progress / success / error notifications inline in the HTTP response instead of only out-of-band via the SignalR sinks, and can branch on Success without parsing severities. LocalProjectService Root(Local) project service. Apply absolute file path. LocalProjectServiceController HTTP controller exposing the project-level (session-independent) operations of Hi.MachiningProcs.LocalProjectServiceController.LocalProjectService — the lean API-user surface, parallel to SessionShellController (which mirrors the session-scoped SessionShell). A controller mirrors exactly one body; project-level settings belong here, not bolted onto the session controller. MachiningActRunner Represents a runner for machining actions that manages milling steps, tool paths, and collision detection. MachiningActRunnerConfig Represents the configuration for a milling act runner. Provides settings for physics simulation, evaluation, and temperature control. MachiningParallelProc Represents a parallel processing system for milling operations that manages various tasks such as sweeping, subtraction, force calculation, and physics simulation. MachiningParallelProc.StepTaskBundle Represents a bundle of tasks related to a milling step. MachiningParallelProc.SubstractionResult Represents the result of a subtraction operation. MachiningProject Represents a milling project that manages the execution, simulation, and analysis of NC programs. MachiningSession Represents a machining session that manages the execution and optimization of machining operations. Provides functionality for controlling the machining process, handling optimization options, and managing session state. Implements IDisposable to clean up SessionWriters on session end. MessageDto One reported IMessage, flattened for JSON transport. MillingUtil Provides utility methods for milling calculations and operations. NcKindUtil NcKind helpers. NcRunnerSessionState NC pipeline state held on a MachiningSession and shared across multiple RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) calls within that session. The per-layer SyntaxPieceLayers are extended via AppendSource(IEnumerable<T>) for each subsequent file so that Previous/Next connectivity (and thus ModalCarrySyntax deep-clone) crosses file boundaries. ProjectFileBusyException Thrown when a project-file operation (New / Load / Save / SaveAs / Reload) is requested while another one is already in progress. The newcomer is cancelled rather than queued; controllers surface this as HTTP 409 Conflict. ProxyProjectService Delegate (User-based) Project Service. Apply relative file path from AdminDirectory. RequireActiveSessionAttribute Action filter for the session-scoped web-API surface: before a guarded action runs, verifies a machining session is active (SessionShell is non-null). When none is active it short-circuits with HTTP 409 and an NoActiveSession() envelope, so a REST / AI caller gets a helpful “call BeginSession() first” notice instead of a null-reference 500. Apply at the controller level; exempt the session lifecycle entry points (BeginSession / EndSession) with AllowNoActiveSessionAttribute. RequireLoadedProjectAttribute Action filter for the project-level web-API surface: before a guarded action runs, verifies a project is loaded (MachiningProject is non-null). When none is loaded it short-circuits with HTTP 409 and an NoProjectLoaded() envelope, so a REST / AI caller gets a helpful “create or load a project first” notice instead of a null-reference 500 (the project-level members — MachiningActRunner.Config, workpiece, runners — are null until a project is open). Apply at the controller level; exempt the endpoints that create or load a project with AllowNoLoadedProjectAttribute. SessionShell End-user-facing facade for a machining session: aggregates session lifecycle, NC playback, optimization, geometry I/O, and scripting infrastructure into a single delegation surface. Used as the C# script globals object and as the concrete target of ISessionCommand implementations. SessionShellController HTTP controller exposing SessionShell over the web API. Each action delegates to the underlying SessionShell instance owned by Hi.MachiningProcs.SessionShellController.LocalProjectService. SetupController Controller for setup operations of machining projects. ShellProgress Append-only, thread-safe sink for session-level routine / lifecycle messages on the IMessage channel — one of the partitioned message homes. This is partitioned by message kind, orthogonal to the other sinks: plain SimpleMessage notices that belong to the session as a whole (cache reset, file load / save progress, session start/done) live here; messages tied to a particular machining step live in StepDiagnosticProgress; NC-pipeline diagnostics live in NcDiagnosticProgress. Append-only: session-routine messages are emitted sequentially, so report order already is execution order — there is no per-step anchor and no stable-index bookkeeping. SpindleSpeedCache Represents cached spindle speed information. StepDiagnostic An IMessage produced while constructing a MachiningStep, anchored to the step's execution-order StepIndex and (when available) its NC-source SentenceCarrier. Decorator over an inner Message — the five IMessage members delegate to it — so a plain SimpleMessage emitted during step processing can be upgraded to a step-anchored diagnostic without the producer needing to know the step context. StepDiagnosticAnchorUtil Bridges a step-anchored IProgress<T> sink (e.g. StepDiagnosticProgress) back to the generic IProgress<T> surface, so out-of-step-pipeline producers can keep using the id-first MessageUtil shorthands (ValidationError, ConfigurationWarning, …) and still land a StepDiagnostic on the sink. StepDiagnosticProgress Append-only, thread-safe sink for step-anchored diagnostics on the IMessage channel. This sink stores only StepDiagnostic: every message is anchored to a motion step. Per-step batches arrive via FlushTo(IProgress<StepDiagnostic>); out-of-pipeline emits (e.g. stroke-limit / tooling diagnostics) anchor themselves with AnchoredToStep(IProgress<StepDiagnostic>, int, ISentenceCarrier) before reporting. Data that already has another owner is not duplicated here — NC diagnostics live in NcDiagnosticProgress, plain session-level notices live in ShellProgress, cutter positions live in the CL strip. Because every StepDiagnostic carries its own StepIndex anchor, ordering is recovered downstream by sorting on that anchor. Producers therefore only ever Report(StepDiagnostic) (append) — even from parallel step-processing tasks — and never insert at a computed position. StepScopedProgress A per-step IProgress<T> of IMessage that accumulates the messages emitted while one step is built, upgrading any plain message to a StepDiagnostic anchored to this step's StepIndex / SentenceCarrier. An already step-anchored StepDiagnostic is kept unchanged. (NC diagnostics are not seen here — they live in their own NcDiagnosticProgress, not on this channel.) It does not forward to a downstream sink as messages arrive; instead it collects them into MessageList and is drained once via FlushTo(IProgress<StepDiagnostic>) at the step's sequential post-physics stage. Because that stage runs strictly in step order, the per-step batches land in execution order with no position-scanning insert. No locking: a single step's construction is a data-dependency chain (substraction → physics → post-physics), so only one task writes MessageList at a time; parallelism across steps writes to different scopes. Each parallel step task therefore holds its own instance — never a shared mutable \"current step\" on StepDiagnosticProgress, which would race. Interfaces IMachiningProjectGetter Interface for objects that can provide a MachiningProject instance. IProjectService Interface for services that manage machining projects. Enums NcKind Kind of an NC program file — selects which of the session's runners plays it (ActiveNcRunner / ClRunner / CsvRunner). RenderingFlag Flags that control which elements are rendered in the visualization. Delegates ConfigStepFunc Delegate for configuring a milling step with additional arguments. LocalProjectService.MachiningProjectChangedDelegate Delegate for machining project changed events. MachiningActRunner.MachiningStepBuiltDelegate Delegate for configuring a step with previous and current step information."
  },
  "api/Hi.MachiningSteps.IFlagText.html": {
    "href": "api/Hi.MachiningSteps.IFlagText.html",
    "title": "Interface IFlagText | HiAPI-C# 2025",
    "summary": "Interface IFlagText Namespace Hi.MachiningSteps Assembly HiMech.dll temperary design for showing flag text. public interface IFlagText Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties FlagsText Gets the text representation of command flags. [Present(\"NC Flag\", \"NC Flag\", PhysicsUnit.None, \"G\")] string FlagsText { get; } Property Value string"
  },
  "api/Hi.MachiningSteps.IMachiningService.html": {
    "href": "api/Hi.MachiningSteps.IMachiningService.html",
    "title": "Interface IMachiningService | HiAPI-C# 2025",
    "summary": "Interface IMachiningService Namespace Hi.MachiningSteps Assembly HiMech.dll Represents a host interface for milling steps that provides access to milling equipment and related resources. public interface IMachiningService : IGetMachiningEquipment Inherited Members IGetMachiningEquipment.GetMachiningEquipment() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties ActiveNcRunner Gets the active NC control runner. INcRunner ActiveNcRunner { get; } Property Value INcRunner BaseDirectory Gets the project base directory (relative-path root). string BaseDirectory { get; } Property Value string ClRunner Gets the NX-CL (CLSF) control runner. INcRunner ClRunner { get; } Property Value INcRunner ClStrip Gets the cutter location strip containing the machining steps. ClStrip ClStrip { get; } Property Value ClStrip CsvRunner Gets the CSV runner. INcRunner CsvRunner { get; } Property Value INcRunner DictionaryColorGuide Gets the color guide for dictionary-based coloring. DictionaryColorGuide DictionaryColorGuide { get; } Property Value DictionaryColorGuide EnablePauseOnFailure Gets whether playback pauses on a failure. bool EnablePauseOnFailure { get; } Property Value bool IsCollisionDetectionEnabled Gets whether collision detection is currently enabled. bool IsCollisionDetectionEnabled { get; } Property Value bool MachiningActRunner Gets the act runner that expands and processes acts. MachiningActRunner MachiningActRunner { get; } Property Value MachiningActRunner MachiningEquipment Gets the milling equipment used for machining operations. MachiningEquipment MachiningEquipment { get; } Property Value MachiningEquipment MachiningSession Gets the current machining session. MachiningSession MachiningSession { get; } Property Value MachiningSession MachiningToolHouse Gets the tool house containing milling tools. MachiningToolHouse MachiningToolHouse { get; } Property Value MachiningToolHouse MillingStepLuggageReader Gets the parallel bulk reader for milling step luggage data. ParallelBulkReader<MillingStepLuggage> MillingStepLuggageReader { get; } Property Value ParallelBulkReader<MillingStepLuggage> NcDiagnosticProgress Gets the NC-pipeline diagnostic sink on the IMessage channel. NcDiagnosticProgress NcDiagnosticProgress { get; } Property Value NcDiagnosticProgress NcManipulationDiagnosticProgress Gets the NC-manipulation diagnostic sink — the second diagnostic home, for operations that rework an already-played NC/CL program (writeback conversion, NC optimization) as opposed to the play-time pipeline diagnostics in NcDiagnosticProgress. Keeping the two scenarios in separate homes lets a play reset clear run diagnostics without discarding manipulation results, and vice versa; each manipulation run clears this home at its start so it always holds the latest run. NcDiagnosticProgress NcManipulationDiagnosticProgress { get; } Property Value NcDiagnosticProgress PacePlayer Gets the pace player controlling execution pace. PacePlayer PacePlayer { get; } Property Value PacePlayer StepDiagnosticProgress Gets the step-aligned IMessage-channel sink. StepDiagnosticProgress StepDiagnosticProgress { get; } Property Value StepDiagnosticProgress TimeMapping Gets the time mapping for synchronization. TimeMapping TimeMapping { get; } Property Value TimeMapping Methods BeginNcRunner() Initialises the meshed geometry for an NC run (idempotent). void BeginNcRunner() CheckStrokeLimitOnStep() Checks the stroke limit at the current step; true if within limits. bool CheckStrokeLimitOnStep() Returns bool EnsureExecutionEquipment() Ensures the runtime MachiningEquipment reflects the authored setup face — re-materialising it when setup edits are pending (equipment split: follow = rebuild at session boundaries). Default: no-op, for hosts without a setup face (e.g. test stubs). void EnsureExecutionEquipment() GetSessionShell() Returns the session shell that exposes the runtime surface of the active machining session. ISessionShell GetSessionShell() Returns ISessionShell RefreshDrawing() Refreshes the visual display. void RefreshDrawing() UpdateIdealMillingToolOffsetTableByToolHouse() Refreshes the ideal milling-tool offset table from the tool house. void UpdateIdealMillingToolOffsetTableByToolHouse()"
  },
  "api/Hi.MachiningSteps.IMotionStepIndex.html": {
    "href": "api/Hi.MachiningSteps.IMotionStepIndex.html",
    "title": "Interface IMotionStepIndex | HiAPI-C# 2025",
    "summary": "Interface IMotionStepIndex Namespace Hi.MachiningSteps Assembly HiMech.dll Abstraction for an object that carries a StepIndex — the 0-based ordinal of a machining motion step in execution order. Used as a cross-object alignment key so a step (MachiningStep), its cutter-location position (ClStripPos), and the messages anchored to it (StepDiagnostic, StepScopedProgress) can be matched by the same ordinal without depending on a concrete type. Distinct from ISentenceIndexed: that ordinal counts NC source blocks, whereas this one counts produced motion steps — a single source block (e.g. a canned cycle) can fan out into several steps. public interface IMotionStepIndex Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties StepIndex 0-based ordinal of the motion step in execution order. int StepIndex { get; } Property Value int"
  },
  "api/Hi.MachiningSteps.IStepPropertyAccessHost.html": {
    "href": "api/Hi.MachiningSteps.IStepPropertyAccessHost.html",
    "title": "Interface IStepPropertyAccessHost | HiAPI-C# 2025",
    "summary": "Interface IStepPropertyAccessHost Namespace Hi.MachiningSteps Assembly HiMech.dll Narrow host contract for accessing the step-variable registry and registering new step variables. Exposed as a dedicated surface so pipelines that only need step-variable wiring (e.g. CsvRowSyntax) do not have to depend on the broader IMachiningService. public interface IStepPropertyAccessHost Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties StepPropertyAccessDictionary Dictionary of step-property accessors keyed by property name. Used by CSV title-row processing to decide whether a column already maps to a reserved step property; new columns are registered via RegisterStepVariable(string, string, string, string, Func<MachiningStep, object>). ConcurrentDictionary<string, PropertyAccess<MachiningStep>> StepPropertyAccessDictionary { get; } Property Value ConcurrentDictionary<string, PropertyAccess<MachiningStep>> Methods RegisterStepVariable(string, string, string, string, Func<MachiningStep, object>) Registers a step variable so downstream components (strip charts, CSV exports, scripting) can read it from MachiningStep. Idempotent on key. void RegisterStepVariable(string key, string name, string unit, string formatString, Func<MachiningStep, object> variableFunc = null) Parameters key string Unique key. name string Human-readable name; may equal key. unit string Physical unit name (PhysicsUnit); nullable. formatString string Display format string; nullable. variableFunc Func<MachiningStep, object> Optional value extractor; nullable when the value comes from the step's flex dictionary."
  },
  "api/Hi.MachiningSteps.MachineMotionStep.html": {
    "href": "api/Hi.MachiningSteps.MachineMotionStep.html",
    "title": "Class MachineMotionStep | HiAPI-C# 2025",
    "summary": "Class MachineMotionStep Namespace Hi.MachiningSteps Assembly HiMech.dll MachiningStep has spindle information. Note that the spindle information is only for milling behavior. public class MachineMotionStep : IGetFeedrate, IGetSpindleSpeed Inheritance object MachineMotionStep Implements IGetFeedrate IGetSpindleSpeed Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MachineMotionStep(MachineMotionStep) Initializes a new instance of the MachineMotionStep class by copying from another instance. public MachineMotionStep(MachineMotionStep src) Parameters src MachineMotionStep The source machining step to copy from. MachineMotionStep(TimeSpan, TimeSpan, double, double[], double, double, SpindleDirection, CoolantMode, int, Mat4d, Mat4d, SeqPair<Mat4d>) Initializes a new instance of the MachineMotionStep class with specified parameters. public MachineMotionStep(TimeSpan stepDuration, TimeSpan accumulatedTime, double beginSpindleAngle_rad, double[] mcValues, double commandedClFeedrate_mmds, double spindleSpeed_radds, SpindleDirection spindleDirection, CoolantMode coolantMode, int toolId, Mat4d programZeroToWorkpieceGeomToMat4d, Mat4d workpieceGeomToProgramZeroMat4d, SeqPair<Mat4d> seqOnWorkpieceGeomCoordinate) Parameters stepDuration TimeSpan The duration of this step. accumulatedTime TimeSpan The accumulated time up to this step. beginSpindleAngle_rad double The initial spindle angle in radians. mcValues double[] The machine coordinate values. commandedClFeedrate_mmds double The controller's commanded CL feedrate in millimeters per second. spindleSpeed_radds double The spindle speed in radians per second. spindleDirection SpindleDirection The direction of spindle rotation. coolantMode CoolantMode The coolant delivery mode active for this step. toolId int The ID of the tool being used. programZeroToWorkpieceGeomToMat4d Mat4d The transformation matrix from program zero to workpiece geometry. workpieceGeomToProgramZeroMat4d Mat4d The transformation matrix from workpiece geometry to program zero. seqOnWorkpieceGeomCoordinate SeqPair<Mat4d> The sequence of transformations on workpiece geometry coordinate. Properties ActualTipFeedrate_mmds The equipped tool's real tip feedrate over this step in millimeters per second: the tip's displacement relative to the workpiece from the previous step's pose to this one, over StepDuration. This is the feedrate the cut experiences. It equals CommandedClFeedrate_mmds whenever the tip translates with the controller's CL point (XYZ moves, CL files, RTCP with the tool-length offset of the equipped tool) and differs when the two decouple: under RTCP with an offset that does not describe the equipped tool the tip sweeps with the posture change while the CL point may stand still. Initialised to the commanded value; the step builder assigns the measured one (MeasureActualTipFeedrate_mmds(Vec3d, Vec3d, TimeSpan, bool, double)) and keeps the commanded value where no tip speed is defined. Physics reads this value: GetFeedPerTooth_mm(IMachiningTool), FeedPerCycle_mm, the force step and the MRR. Presented to clients as ActualTipFeedrate_mmdmin. public double ActualTipFeedrate_mmds { get; set; } Property Value double BeginSpindleAngle_deg Begin spindle rotation angle. in deg; public double BeginSpindleAngle_deg { get; set; } Property Value double BeginSpindleAngle_rad Begin spindle rotation angle. in rad; public double BeginSpindleAngle_rad { get; set; } Property Value double BeginTimecode The work time at the begin of the step. public TimeSpan BeginTimecode { get; } Property Value TimeSpan CdnTransformProgramToToolRunning Gets the transformation matrix from program to tool running coordinate. public Mat4d CdnTransformProgramToToolRunning { get; } Property Value Mat4d CdnTransformProgramToWorkpieceGeom Gets the transformation matrix from program zero to workpiece geometry. public Mat4d CdnTransformProgramToWorkpieceGeom { get; } Property Value Mat4d CdnTransformToolRunningToProgram Gets the transformation matrix from tool running to program coordinate. public Mat4d CdnTransformToolRunningToProgram { get; } Property Value Mat4d CdnTransformToolRunningToWorkpieceGeom Tool running coordinate to workpiece geom coordinate. public Mat4d CdnTransformToolRunningToWorkpieceGeom { get; } Property Value Mat4d CdnTransformWorkpieceGeomToProgram Gets the transformation matrix from workpiece geometry to program zero. public Mat4d CdnTransformWorkpieceGeomToProgram { get; } Property Value Mat4d CdnTransformWorkpieceGeomToToolRunning Gets the transformation matrix from workpiece geometry to tool running coordinate. public Mat4d CdnTransformWorkpieceGeomToToolRunning { get; } Property Value Mat4d CommandedClFeedrate_mmds The controller's commanded feedrate of the CL point in millimeters per second (CommandedClFeedrate_mmds at the time of the step): the F word after G94/G95/G93 conversion, or for a rapid the CL path over the act duration. It is not the equipped tool's real tip feedrate: under RTCP with a tool-length offset that does not match the equipped tool the tip sweeps while the CL point may stand still; the tip's own feedrate is ActualTipFeedrate_mmds. Presented to clients as Feedrate_mmdmin. public double CommandedClFeedrate_mmds { get; set; } Property Value double CoolantMode Gets or sets the coolant delivery mode active for this step. Read by BuildCuttingTemperatureAndWear(SeqPhysicsBrief, MachineMotionStep, MachineMotionStep, double, SpindleCapability, IMachiningTool, Workpiece, int, Substraction, LayerMillingEngagement, MillingPhysicsBrief, CoolantHeatCondition, CoolantMode, bool, MillingToolPhysicsPack, Action<string>) to pick the effective convection coefficient on the temperature FEM. public CoolantMode CoolantMode { get; set; } Property Value CoolantMode CyclePeriod Gets the cycle period as a TimeSpan. public TimeSpan CyclePeriod { get; } Property Value TimeSpan CyclePeriod_s Gets the cycle period in seconds. public double CyclePeriod_s { get; } Property Value double EndSpindleAngle_deg Gets the end spindle angle in degrees. public double EndSpindleAngle_deg { get; } Property Value double EndSpindleAngle_rad Gets the end spindle angle in radians. public double EndSpindleAngle_rad { get; } Property Value double EndTimecode The work time at the end of the step. The value is BeginTimecode + StepDuration. public TimeSpan EndTimecode { get; set; } Property Value TimeSpan FeedPerCycle_mm The feed per spindle cycle in millimeters, from the real tip feedrate (ActualTipFeedrate_mmds): the advance the cut experiences per revolution. public double FeedPerCycle_mm { get; } Property Value double GeomCl Gets the current position in workpiece geometry coordinate. public DVec3d GeomCl { get; } Property Value DVec3d McValues Machine coordinate values. public double[] McValues { get; set; } Property Value double[] MoveOnProgramCoordinate_mm Gets the movement vector in program coordinate in millimeters. public Vec3d MoveOnProgramCoordinate_mm { get; } Property Value Vec3d MoveOnWorkpieceGeomCoordinate_mm Gets the movement vector in workpiece geometry coordinate in millimeters. public Vec3d MoveOnWorkpieceGeomCoordinate_mm { get; } Property Value Vec3d MovingDirectionOnWorkpieceGeomCoordinate Gets the movement direction vector in workpiece geometry coordinate. public Vec3d MovingDirectionOnWorkpieceGeomCoordinate { get; } Property Value Vec3d MovingLength_mm Gets the length of movement in millimeters. public double MovingLength_mm { get; } Property Value double PassedSpindleAngle_deg For milling behavior only. public double PassedSpindleAngle_deg { get; } Property Value double PassedSpindleAngle_rad For milling behavior only. public double PassedSpindleAngle_rad { get; } Property Value double ProgramCl Gets the current position in program coordinate. public DVec3d ProgramCl { get; } Property Value DVec3d ProgramToWorkpieceGeomMat4d Gets or sets the transformation matrix from program zero to workpiece geometry. public Mat4d ProgramToWorkpieceGeomMat4d { get; set; } Property Value Mat4d SeqOnToolRunningCoordinate Gets the sequence of transformations on tool running coordinate. public SeqPair<Mat4d> SeqOnToolRunningCoordinate { get; } Property Value SeqPair<Mat4d> SeqOnWorkpieceGeomCoordinate Gets or sets the sequence of transformations on workpiece geometry coordinate. public SeqPair<Mat4d> SeqOnWorkpieceGeomCoordinate { get; set; } Property Value SeqPair<Mat4d> SpindleDirection Gets or sets the direction of spindle rotation. public SpindleDirection SpindleDirection { get; set; } Property Value SpindleDirection SpindleSpeed_cycleds Gets the spindle speed in cycles per second. public double SpindleSpeed_cycleds { get; } Property Value double SpindleSpeed_radds For milling behavior only. public double SpindleSpeed_radds { get; set; } Property Value double SpindleSpeed_rpm Gets the spindle speed in revolutions per minute. public double SpindleSpeed_rpm { get; } Property Value double StepDuration Gets or sets the duration of this step. public TimeSpan StepDuration { get; set; } Property Value TimeSpan ToolId Gets or sets the ID of the tool being used. public int ToolId { get; set; } Property Value int WorkpieceGeomToProgramMat4d Gets or sets the transformation matrix from workpiece geometry to program zero. public Mat4d WorkpieceGeomToProgramMat4d { get; set; } Property Value Mat4d Methods GetFeedPerTooth_mm(IMachiningTool) The feed per tooth in millimeters, from the real tip feedrate (ActualTipFeedrate_mmds): the chip load the cut experiences, which the force step and the tooth sequence are built on. public double GetFeedPerTooth_mm(IMachiningTool millingTool) Parameters millingTool IMachiningTool The milling tool. Returns double The feed per tooth in millimeters. GetFeedrate_mmds() Gets the program feedrate in millimeters per second. public double GetFeedrate_mmds() Returns double Feedrate in mm/s GetMachiningTool(MachiningToolHouse) Gets the machining tool from the tool house. public IMachiningTool GetMachiningTool(MachiningToolHouse toolHouse) Parameters toolHouse MachiningToolHouse The machining tool house. Returns IMachiningTool The machining tool. GetProgramSideCuspHeight_mm(IMachiningTool, MillingToolPhysicsPack) Gets the program side cusp height in millimeters. public double GetProgramSideCuspHeight_mm(IMachiningTool millingTool, MillingToolPhysicsPack physicsPack = null) Parameters millingTool IMachiningTool The milling tool. physicsPack MillingToolPhysicsPack The frozen per-session physics pack of millingTool; null computes the diameter on use. Returns double The program side cusp height in millimeters. GetSideCuspList_mm(IMachiningTool, MillingToolPhysicsPack) Gets the list of side cusp heights in millimeters. public List<double> GetSideCuspList_mm(IMachiningTool millingTool, MillingToolPhysicsPack physicsPack = null) Parameters millingTool IMachiningTool The milling tool. physicsPack MillingToolPhysicsPack The frozen per-session physics pack of millingTool; null computes the diameter on use. Returns List<double> The list of side cusp heights in millimeters. GetSideCuspPhaseInterval_rad(IMachiningTool, MillingToolPhysicsPack) Gets the side cusp phase interval in radians. public double GetSideCuspPhaseInterval_rad(IMachiningTool millingTool, MillingToolPhysicsPack physicsPack = null) Parameters millingTool IMachiningTool The milling tool. physicsPack MillingToolPhysicsPack The frozen per-session physics pack of millingTool; null computes the diameter on use. Returns double The side cusp phase interval in radians. GetSpindleDirection() Gets the spindle rotation direction. public SpindleDirection GetSpindleDirection() Returns SpindleDirection The spindle direction (clockwise, counterclockwise, or stopped) GetSpindleSpeed_cycleds() Gets the spindle speed in cycles per second. public double GetSpindleSpeed_cycleds() Returns double The spindle speed in cycles per second. GetSpindleSpeed_radds() Gets the spindle speed in radians per second. public double GetSpindleSpeed_radds() Returns double Spindle speed in rad/s GetToothArcDuration_s(IMachiningTool) Gets the duration of a single tooth arc in seconds. public double GetToothArcDuration_s(IMachiningTool millingTool) Parameters millingTool IMachiningTool The milling tool. Returns double The duration of a single tooth arc in seconds. GetToothSeqOnToolRunningCoordinate(IMachiningTool) Gets the sequence of transformations for a single tooth on tool running coordinate. public SeqPair<Mat4d> GetToothSeqOnToolRunningCoordinate(IMachiningTool millingTool) Parameters millingTool IMachiningTool The milling tool. Returns SeqPair<Mat4d> The sequence of transformations for a single tooth. MeasureActualTipFeedrate_mmds(Vec3d, Vec3d, TimeSpan, bool, double) Measures a step's real tip feedrate: the distance from the tip point the machine stood at before this step to the one it reaches, on the workpiece-geometry coordinate, over the step duration. Falls back to commandedClFeedrate_mmds where a tip speed is not defined: no previous point (the first step after a reset), a non-positive duration (a CSV row without timing), or a tool change between the two points (the tip jumped with the tool, it did not travel). The previous point is the pose the step pipeline saw last, step or no step (PreTipPose): the sweep valve skips a collinear return over a segment it already covered, and it spans a motion pair's pre two steps back on a straight run, so neither the last built step nor cur - pre measures one step's travel. public static double MeasureActualTipFeedrate_mmds(Vec3d preTipPoint, Vec3d curTipPoint, TimeSpan stepDuration, bool sameTool, double commandedClFeedrate_mmds) Parameters preTipPoint Vec3d The tip point before this step, or null. curTipPoint Vec3d The tip point this step reaches. stepDuration TimeSpan This step's duration. sameTool bool Whether the tool at preTipPoint is the tool of this step. commandedClFeedrate_mmds double The commanded CL feedrate, returned where no tip speed is defined. Returns double The tip feedrate in millimeters per second. ToString() Returns a string representation of this machining step. public override string ToString() Returns string A string representation of this machining step. WithFeedrate(double) A copy of this step at another feedrate: both CommandedClFeedrate_mmds and ActualTipFeedrate_mmds are feedrate_mmds. For a solver asking what the cut would experience at a candidate feed (the trial step of the NC optimization's feed solve). public MachineMotionStep WithFeedrate(double feedrate_mmds) Parameters feedrate_mmds double The candidate feedrate in millimeters per second. Returns MachineMotionStep The copy."
  },
  "api/Hi.MachiningSteps.MachiningStep.CollidedKeyPair.html": {
    "href": "api/Hi.MachiningSteps.MachiningStep.CollidedKeyPair.html",
    "title": "Class MachiningStep.CollidedKeyPair | HiAPI-C# 2025",
    "summary": "Class MachiningStep.CollidedKeyPair Namespace Hi.MachiningSteps Assembly HiMech.dll A pair of collided keys that indicates two entities are in collision. public record MachiningStep.CollidedKeyPair : IEquatable<MachiningStep.CollidedKeyPair> Inheritance object MachiningStep.CollidedKeyPair Implements IEquatable<MachiningStep.CollidedKeyPair> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CollidedKeyPair(string, string) A pair of collided keys that indicates two entities are in collision. public CollidedKeyPair(string KeyA, string KeyB) Parameters KeyA string KeyB string Properties KeyA public string KeyA { get; init; } Property Value string KeyB public string KeyB { get; init; } Property Value string"
  },
  "api/Hi.MachiningSteps.MachiningStep.html": {
    "href": "api/Hi.MachiningSteps.MachiningStep.html",
    "title": "Class MachiningStep | HiAPI-C# 2025",
    "summary": "Class MachiningStep Namespace Hi.MachiningSteps Assembly HiMech.dll Represents a machining step enriched with physics, mapping and source metadata. The duration-based step property is based on the duration from previous-step to current-step. public class MachiningStep : IGetIndexedFileLine, IFlexDictionaryHost<object>, IGetFeedrate, IGetSpindleSpeed, IGetRgbWithPriority, ISentenceCarrier, IGetSentence, ISentenceIndexed, IMotionStepIndex Inheritance object MachiningStep Implements IGetIndexedFileLine IFlexDictionaryHost<object> IGetFeedrate IGetSpindleSpeed IGetRgbWithPriority ISentenceCarrier IGetSentence ISentenceIndexed IMotionStepIndex Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) FlexDictionaryUtil.CallFlexDictionary<T>(IFlexDictionaryHost<T>) FlexDictionaryUtil.GetFlexDictionaryBytes<T>(IFlexDictionaryHost<T>, IntegerKeyDictionaryConverter<T>) FlexDictionaryUtil.WriteFlexDictionary<T>(IFlexDictionaryHost<T>, BinaryWriter, IntegerKeyDictionaryConverter<T>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MachiningStep(IMachiningService, int, ISentenceCarrier, MachineMotionStep, MillingInstance, CollidedKeyPair[]) Initializes a new instance of the MachiningStep class. public MachiningStep(IMachiningService host, int stepIndex, ISentenceCarrier sourceCommand, MachineMotionStep machineMotionStep, MillingInstance millingInstance, MachiningStep.CollidedKeyPair[] collidedKeyPairs) Parameters host IMachiningService The host of the milling step. stepIndex int The index of the step. sourceCommand ISentenceCarrier The source command. machineMotionStep MachineMotionStep The machine motion step parameters. millingInstance MillingInstance The physics result for the step. collidedKeyPairs CollidedKeyPair[] The collided key pairs detected in this step. Properties AccumulatedCraterWear_um Gets the accumulated crater wear in micrometers [Present(\"Accumulated Crater Wear\", \"A.C.Wear\", PhysicsUnit.um, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double AccumulatedCraterWear_um { get; } Property Value double AccumulatedFlankWearDepth_um Gets the accumulated flank wear depth in micrometers [Present(\"Accumulated Flank Wear Depth\", \"A.F.Wear.Depth\", PhysicsUnit.um, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double AccumulatedFlankWearDepth_um { get; } Property Value double AccumulatedFlankWearWidth_um Gets the accumulated flank wear width in micrometers [Present(\"Accumulated Flank Wear Width\", \"A.F.Wear.Width\", PhysicsUnit.um, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double AccumulatedFlankWearWidth_um { get; } Property Value double AccumulatedSpindleEnergyConsumption_kWh Gets the accumulated spindle energy consumption in kilowatt-hours [Present(\"Accumulated Spindle Energy Consumption\", null, PhysicsUnit.kWh, \"G6\")] [JsAce(ClassExt = \"MachiningStep\")] public double AccumulatedSpindleEnergyConsumption_kWh { get; } Property Value double AccumulatedTime Legacy alias for EndTimecode. The value is a TimeSpan timecode (position from run start), so the canonical member carries the Timecode suffix and owns the [Present] / [JsAce] surface; this stays only as a source-compatible delegate. [Obsolete(\"Renamed to EndTimecode.\")] public TimeSpan AccumulatedTime { get; } Property Value TimeSpan ActualDateTime Absolute controller timestamp (wall-clock DateTime) of the step, preserved alongside ActualTimecode so the calendar date survives. Resolved to a timecode against the project mapping anchor (TimeMapping.MappingAnchorDateTime). null when the source row had no actual time. View onto ActualTime. [Present(\"Actual DateTime\", \"Act.DT\", PhysicsUnit.None, \"G\")] [JsAce(ClassExt = \"MachiningStep\")] public DateTime? ActualDateTime { get; } Property Value DateTime? ActualTime Wall-clock stamp of the step end (the controller-recorded timeline), or null when the scene has no measured time source (pure NC simulation). Dense on CSV plays: original controller stamps plus machine-timeline extrapolation marked by IsInterpolated. public StepActualTime ActualTime { get; set; } Property Value StepActualTime ActualTimecode Actual accumulated worked time. End Actual Timecode. Actual Program time. View onto ActualTime. [Present(\"Actual Time\", \"Act.Time\", PhysicsUnit.None, \"G\")] [JsAce(ClassExt = \"MachiningStep\")] public TimeSpan? ActualTimecode { get; } Property Value TimeSpan? ActualTipFeedrate_mmdmin The equipped tool's real tip feedrate over the step in mm/min (ActualTipFeedrate_mmds): the tip's displacement relative to the workpiece over the step duration. Equal to Feedrate_mmdmin unless the controller's CL point and the equipped tool's tip decouple (RTCP with a tool-length offset that does not describe the equipped tool). [Present(\"Actual Tip Feedrate\", \"F-tip\", PhysicsUnit.mmdmin, \"G5\")] [JsAce(ClassExt = \"MachiningStep\")] public double ActualTipFeedrate_mmdmin { get; } Property Value double AvgAbsMomentAboutSensorVec3d_Nm Gets the average absolute moment about sensor vector in Newton-meters [Present(\"Avg Abs Moment To Tool About Sensor\", \"Avg-Abs-M-ToTool-Sensor-SR\", PhysicsUnit.Nm, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public Vec3d AvgAbsMomentAboutSensorVec3d_Nm { get; } Property Value Vec3d AvgAbsMomentXAboutSensorOnSpindleRotationCoordinate_Nm Gets the average absolute moment X about sensor on spindle rotation coordinate in Newton-meters [Present(\"Avg Abs Moment X To Tool About Sensor On Spindle Rotation Coordinate\", \"AvgAbsMx-ToTool-Sensor-SR\", PhysicsUnit.Nm, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? AvgAbsMomentXAboutSensorOnSpindleRotationCoordinate_Nm { get; } Property Value double? AvgAbsMomentXAboutToolTipOnSpindleRotationCoordinate_Nm Gets the average absolute moment X about tool tip on spindle rotation coordinate in Newton-meters [Present(\"Avg Abs Moment X To Tool About Tool Tip On Spindle Rotation Coordinate\", \"AvgAbsMx-ToTool-Tip-SR\", PhysicsUnit.Nm, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double AvgAbsMomentXAboutToolTipOnSpindleRotationCoordinate_Nm { get; } Property Value double AvgAbsTorqueByMapping_Nm Gets the average absolute torque by mapping in Newton-meters [Present(\"Avg Abs Torque By Mapping\", \"AvgAbsTorque-Map\", PhysicsUnit.Nm, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? AvgAbsTorqueByMapping_Nm { get; } Property Value double? AvgAbsTorqueErrorRatioWithMapping numerator is sim value minus mapping value; denominator is the mapping value. [Present(\"Avg Torque Error Ratio by Mapping\", \"Torque-Err-R.\", PhysicsUnit.None, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? AvgAbsTorqueErrorRatioWithMapping { get; } Property Value double? AvgAbsTorqueSignedErrorRelationWithMapping The sign is from sim value minus mapping value. the quantity is Math.Sqrt(err.Square() / Math.Abs(sim * mapping)) [JsAce(ClassExt = \"MachiningStep\")] public double? AvgAbsTorqueSignedErrorRelationWithMapping { get; } Property Value double? AvgAbsTorque_Nm AvgAbsTorqueOnSpindleRotationCoordinate [Present(\"Avg Abs Torque\", \"AvgAbsTorque\", PhysicsUnit.Nm, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? AvgAbsTorque_Nm { get; } Property Value double? AvgForceToToolOnToolRunningCoordinate_N Gets the average force to tool on tool running coordinate in N. [Present(\"AvgForceToToolOnToolRunningCoordinate\", \"AvgForce-ToTool-TR\", PhysicsUnit.N, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public Vec3d AvgForceToToolOnToolRunningCoordinate_N { get; } Property Value Vec3d AvgForceXToToolOnToolRunningCoordinate_N Gets the average force X to tool on tool running coordinate in N. [JsAce(ClassExt = \"MachiningStep\")] public double? AvgForceXToToolOnToolRunningCoordinate_N { get; } Property Value double? AvgForceYToToolOnToolRunningCoordinate_N Gets the average force Y to tool on tool running coordinate in N. [JsAce(ClassExt = \"MachiningStep\")] public double? AvgForceYToToolOnToolRunningCoordinate_N { get; } Property Value double? AvgForceZToToolOnToolRunningCoordinate_N Gets the average force Z to tool on tool running coordinate in N. [JsAce(ClassExt = \"MachiningStep\")] public double? AvgForceZToToolOnToolRunningCoordinate_N { get; } Property Value double? AvgMomentAboutSensor_Nm Gets the average moment about sensor in Newton-meters [Present(\"Avg Moment To Tool About Sensor\", \"AvgM-ToTool-Sensor-SR\", PhysicsUnit.Nm, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? AvgMomentAboutSensor_Nm { get; } Property Value double? AvgMomentAboutToolTipOnProgramCoordinate_Nm Gets the average moment about tool tip on program coordinate in Newton-meters [Present(\"Avg Moment To Tool About Tool Tip On Workpiece Program Coordinate\", \"AvgAbsM-ToTool-Tip-W\", PhysicsUnit.Nm, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public Vec3d AvgMomentAboutToolTipOnProgramCoordinate_Nm { get; } Property Value Vec3d AvgMomentAboutToolTipOnToolRunningCoordinate_Nm Gets the average moment about tool tip on tool running coordinate in Newton-meters [Present(\"Avg Moment To Tool About Tool Tip On Tool Running Coordinate\", \"AvgAbsM-ToTool-Tip-TR\", PhysicsUnit.Nm, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public Vec3d AvgMomentAboutToolTipOnToolRunningCoordinate_Nm { get; } Property Value Vec3d AvgMomentAboutToolTip_Nm Gets the average moment about tool tip in Newton-meters [Present(\"Avg Moment To Tool About ToolTip\", \"AvgM-ToTool-Tip-SR\", PhysicsUnit.Nm, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? AvgMomentAboutToolTip_Nm { get; } Property Value double? AvgMomentXyAboutObservationPoint_Nm Gets the average moment XY about observation point in Newton-meters [Present(\"Avg Moment XY To Tool About Sensor\", \"AvgM-ToTool-Sensor.XY\", PhysicsUnit.Nm, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? AvgMomentXyAboutObservationPoint_Nm { get; } Property Value double? AvgMomentXyByMapping_Nm Gets the average moment XY by mapping in Newton-meters [Present(\"Avg Moment XY By Mapping\", \"AvgM-Map.XY\", PhysicsUnit.Nm, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? AvgMomentXyByMapping_Nm { get; } Property Value double? AvgMomentXyErrorRatioWithMapping Gets the average moment XY error ratio with mapping. Numerator is sim value minus mapping value; denominator is the mapping value. [Present(\"Avg Moment XY Error Ratio by Mapping\", \"M-XY-Err-R.\", PhysicsUnit.None, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? AvgMomentXyErrorRatioWithMapping { get; } Property Value double? AvgMomentXySignedErrorRelationWithMapping The sign is from sim value minus mapping value. the quantity is Math.Sqrt(err.Square() / Math.Abs(sim * mapping)) [JsAce(ClassExt = \"MachiningStep\")] public double? AvgMomentXySignedErrorRelationWithMapping { get; } Property Value double? BeginSpindleAngle_deg Gets the beginning spindle angle in degrees. [Present(\"Beginning Spindle Angle Shift\", \"Spd. Ang. Shift\", PhysicsUnit.deg, \"F2\")] [JsAce(ClassExt = \"MachiningStep\")] public double BeginSpindleAngle_deg { get; } Property Value double ChipMass_g Gets the chip mass in grams. [JsAce(ClassExt = \"MachiningStep\")] public double? ChipMass_g { get; } Property Value double? ChipMass_mg Gets the chip mass in milligrams. [Present(\"Chip Mass\", null, PhysicsUnit.mg, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? ChipMass_mg { get; } Property Value double? ChipTemperature_C Gets the chip temperature in Celsius [Present(\"Chip Temperature\", \"Chip T.\", PhysicsUnit.C, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? ChipTemperature_C { get; } Property Value double? ChipThickness_mm Gets the chip thickness in mm. [Present(\"Chip Thickness\", null, PhysicsUnit.mm, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? ChipThickness_mm { get; } Property Value double? ChipThickness_um Gets the chip thickness in micrometers public double? ChipThickness_um { get; } Property Value double? ChipVolume_mm3 Gets the chip volume in mm³. [Present(\"Chip Volume\", null, PhysicsUnit.mm3, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? ChipVolume_mm3 { get; } Property Value double? Cl Gets the cutter location. [Present(\"Cutter Location\", \"CL\", PhysicsUnit.mm, \"F5\")] public DVec3d Cl { get; } Property Value DVec3d CollidedKeyPairs Gets or sets the collided key pairs if a collision was detected for this step. public MachiningStep.CollidedKeyPair[] CollidedKeyPairs { get; set; } Property Value CollidedKeyPair[] CollisionText A formatted text representing collided key pairs, e.g. \"(A,B);(C,D)\". Returns null when there is no collision. [Present] [JsAce(ClassExt = \"MachiningStep\")] public string CollisionText { get; } Property Value string ContinueSpindlePowerRatio Continuous spindle power ratio: input power / time-unlimited maximum power per spindle capability. [Present(\"Continue Spindle Power Ratio\", \"Cont.Spd.Pow.R.\", PhysicsUnit.None, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? ContinueSpindlePowerRatio { get; } Property Value double? ContinueSpindleTorqueRatio Gets the infinite insistent spindle torque ratio [Present(\"Continue Spindle Torque Ratio\", \"Cont.Spd.Torque-R.\", PhysicsUnit.None, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? ContinueSpindleTorqueRatio { get; } Property Value double? CutterBodyTemperature_C Gets the cutter body temperature in Celsius [Present(\"Cutter Body Temperature\", \"Ct. Body T.\", PhysicsUnit.C, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? CutterBodyTemperature_C { get; } Property Value double? CutterDermisTemperature_C Gets the cutter dermis temperature in Celsius [Present(\"Cutter Dermis Temperature\", \"Ct. Dermis T.\", PhysicsUnit.C, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? CutterDermisTemperature_C { get; } Property Value double? CuttingDepth_mm Gets the cutting depth in mm. [Present(\"Cutting Depth\", \"ap\", PhysicsUnit.mm, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double CuttingDepth_mm { get; } Property Value double CuttingForcesToToolOnToolRunningCoordinate_N Cutting forces on tool running coordinate. Unit is Newtons. The forced item is tool. public List<Vec3d> CuttingForcesToToolOnToolRunningCoordinate_N { get; } Property Value List<Vec3d> CuttingForcesToWorkpieceOnProgramCoordinate_N Get the cutting forces on program coordinate. Unit is Newtons. The forced item is workpiece. public List<Vec3d> CuttingForcesToWorkpieceOnProgramCoordinate_N { get; } Property Value List<Vec3d> CuttingSpeed_mmds Gets the cutting speed in mm/s. The speed on the cutter outer radius by the spindle rotating. [Present(\"Cutting Speed\", \"Vc\", PhysicsUnit.mmds, \"G5\")] [JsAce(ClassExt = \"MachiningStep\")] public double? CuttingSpeed_mmds { get; } Property Value double? CuttingWidth_mm Gets the cutting width in mm. [Present(\"Cutting Width\", \"ae\", PhysicsUnit.mm, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double CuttingWidth_mm { get; } Property Value double DeltaTipDeflectionOnToolRunningCoordinate_um Gets the delta tip deflection on tool running coordinate in micrometers [Present(\"Delta Tip Deflection On Tool Running Coordinate\", \"Dlt.Df.-Tip-TR\", PhysicsUnit.um, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public Vec3d DeltaTipDeflectionOnToolRunningCoordinate_um { get; } Property Value Vec3d EndTimecode Ideal accumulated worked time by simulation. Ideal Program duration. [Present(\"Time\", null, PhysicsUnit.None, \"G\")] [JsAce(ClassExt = \"MachiningStep\")] public TimeSpan EndTimecode { get; } Property Value TimeSpan FeedPerCycle_mm The feed per spindle cycle in mm, from the real tip feedrate (ActualTipFeedrate_mmdmin). [Present(\"Feed per Cycle\", \"frc\", PhysicsUnit.mm, \"G5\")] [JsAce(ClassExt = \"MachiningStep\")] public double FeedPerCycle_mm { get; } Property Value double FeedPerTooth_mm The feed per tooth in mm, from the real tip feedrate (ActualTipFeedrate_mmdmin): the chip load the cut experiences. [Present(\"Feed per Tooth\", \"frt\", PhysicsUnit.mm, \"G5\")] [JsAce(ClassExt = \"MachiningStep\")] public double FeedPerTooth_mm { get; } Property Value double Feedrate_mmdmin The controller's commanded CL feedrate in mm/min (CommandedClFeedrate_mmds): the F word after G94/G95/G93 conversion, or for a rapid the CL path over the act duration. The key keeps its historical name for the clients that read it. [Present(\"Feedrate\", \"F\", PhysicsUnit.mmdmin, \"G5\")] [JsAce(ClassExt = \"MachiningStep\")] public double Feedrate_mmdmin { get; } Property Value double Feedrate in mm/s FileNo Gets the file number. [Present] [JsAce(ClassExt = \"MachiningStep\")] public int? FileNo { get; } Property Value int? FilePath Gets the file path. [Present] [JsAce(ClassExt = \"MachiningStep\")] public string FilePath { get; } Property Value string FlagsText Gets the flags text. [Present] [JsAce(ClassExt = \"MachiningStep\")] public string FlagsText { get; } Property Value string FlexDictionary Gets or sets the flexible dictionary. public Dictionary<string, object> FlexDictionary { get; set; } Property Value Dictionary<string, object> FrictionPower_W friction power takes by workpiece per cycle. the unit is watt. [JsAce(ClassExt = \"MachiningStep\")] public double? FrictionPower_W { get; } Property Value double? Host Gets or sets the host of the milling step. public IMachiningService Host { get; set; } Property Value IMachiningService InstantCraterWear_um Gets the instant crater wear in micrometers [Present(\"Instant Crater Wear\", \"I.C.Wear\", PhysicsUnit.um, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? InstantCraterWear_um { get; } Property Value double? IsActualTimeInterpolated Whether the wall-clock stamp was extrapolated rather than read directly from a controller row. View onto ActualTime; null when the step has no wall-clock stamp at all. [Present(\"Actual Interpolated\", \"Act.Int\", PhysicsUnit.None, \"G\")] [JsAce(ClassExt = \"MachiningStep\")] public bool? IsActualTimeInterpolated { get; } Property Value bool? IsReliefFaceCollided Gets a value indicating whether the relief face is collided. [Present(\"Is Relief Face Collided\", \"Is-Rlf.C.\", PhysicsUnit.None, \"G\")] [JsAce(ClassExt = \"MachiningStep\")] public bool? IsReliefFaceCollided { get; } Property Value bool? IsTouched Gets whether the step is touched. [Present(\"Is Touched\", null, PhysicsUnit.None, \"G\")] [JsAce(ClassExt = \"MachiningStep\")] public bool IsTouched { get; } Property Value bool this[string] Gets or sets a value in the flexible dictionary by key. public object this[string key] { get; set; } Parameters key string The key to look up. Property Value object The value associated with the key, or null if not found. LineNo Gets the line number. [Present] [JsAce(ClassExt = \"MachiningStep\")] public int? LineNo { get; } Property Value int? LineText Gets the block text (may contain multiple lines for multi-line NC blocks). [Present] [JsAce(ClassExt = \"MachiningStep\")] public string LineText { get; } Property Value string MachineMotionStep Gets or sets the machining step. public MachineMotionStep MachineMotionStep { get; set; } Property Value MachineMotionStep MachiningTool Gets the machining tool used for this milling step. public IMachiningTool MachiningTool { get; } Property Value IMachiningTool MaxAbsForce_N Max absolute force at the rotation cycle. [Present(\"Max Absolute Force\", \"Max Abs F.\", PhysicsUnit.N, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? MaxAbsForce_N { get; } Property Value double? MaxBottomEdgeDeflectionOnToolRunningCoordinate_mm Gets the maximum bottom edge deflection on tool running coordinate in millimeters It only make sense in end mill. The z value of this factor is re-cut depth. [JsAce(ClassExt = \"MachiningStep\")] public Vec3d MaxBottomEdgeDeflectionOnToolRunningCoordinate_mm { get; } Property Value Vec3d MaxBottomEdgeDeflectionOnToolRunningCoordinate_um Gets the maximum bottom edge deflection on tool running coordinate in micrometers. [Present(\"Max Bottom Edge Deflection On Tool Running Coordinate\", \"Df.-Bt.Edge-TR\", PhysicsUnit.um, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public Vec3d MaxBottomEdgeDeflectionOnToolRunningCoordinate_um { get; } Property Value Vec3d MaxForceOnToolRunningCoordinate_N Gets the maximum force on tool running coordinate in N. public Vec3d MaxForceOnToolRunningCoordinate_N { get; } Property Value Vec3d MaxMomentAboutSensor_Nm Gets the maximum moment about sensor in Newton-meters [Present(\"Max Moment To Tool About Sensor\", \"MaxM-ToTool-Sensor-SR\", PhysicsUnit.Nm, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double MaxMomentAboutSensor_Nm { get; } Property Value double MaxMomentAboutToolTip_Nm Gets the maximum moment about tool tip in Newton-meters [Present(\"Max Moment To Tool About ToolTip\", \"MaxM-ToTool-Tip-SR\", PhysicsUnit.Nm, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double MaxMomentAboutToolTip_Nm { get; } Property Value double MaxSpindlePowerRatio Maximum spindle power ratio: input power / instantaneous maximum power per spindle capability. [Present(\"Max Spindle Power Ratio\", \"Max.Spd.Pow.R.\", PhysicsUnit.None, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? MaxSpindlePowerRatio { get; } Property Value double? MaxSpindleTorqueRatio Gets the maximum spindle torque ratio [Present(\"Max Spindle Torque Ratio\", \"Max.Spd.Torque-R.\", PhysicsUnit.None, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? MaxSpindleTorqueRatio { get; } Property Value double? MaxTipDeflectionOnToolRunningCoordinate_mm Gets the maximum tip deflection on tool running coordinate in millimeters [JsAce(ClassExt = \"MachiningStep\")] public Vec3d MaxTipDeflectionOnToolRunningCoordinate_mm { get; } Property Value Vec3d MaxTipDeflectionOnToolRunningCoordinate_um Gets the maximum tip deflection on tool running coordinate in micrometers [Present(\"Max Tip Deflection On Tool Running Coordinate\", \"Max.Df.-Tip-TR\", PhysicsUnit.um, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public Vec3d MaxTipDeflectionOnToolRunningCoordinate_um { get; } Property Value Vec3d MillingInstance Gets or sets the milling instance. public MillingInstance MillingInstance { get; set; } Property Value MillingInstance MillingStepLuggage Get luggage by sequencing loading performance optimization. public MillingStepLuggage MillingStepLuggage { get; } Property Value MillingStepLuggage MomentsToToolAboutObservationPointOnSpindleRotationCoordinate_Nm Get Moments About Observation Point On Spindle Rotation Coordinate. Unit is Newtons-meter. The forced item is tool. public List<Vec3d> MomentsToToolAboutObservationPointOnSpindleRotationCoordinate_Nm { get; } Property Value List<Vec3d> Remarks Not cached data. Light computation cost of the vectors transformation. MoveOnProgramCoordinate Gets the move on program coordinate. [Present(\"Move On Workpiece Program Coordinate\", \"Move-W\", PhysicsUnit.mm, \"F4\")] [JsAce(ClassExt = \"MachiningStep\")] public Vec3d MoveOnProgramCoordinate { get; } Property Value Vec3d MovingLength_mm Gets the moving length in mm. From previous-step to current-step. [Present(\"Move Length\", \"Move Len.\", PhysicsUnit.mm, \"F4\")] [JsAce(ClassExt = \"MachiningStep\")] public double MovingLength_mm { get; } Property Value double Mrr_mm3ds Gets the material removal rate in mm³/s. [Present(\"MRR\", null, PhysicsUnit.mm3ds, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double Mrr_mm3ds { get; } Property Value double ProgramSideCusp_um Gets the program side cusp in micrometers. Side cusp without deformation. The value is count by feed per tooth and the tool radius. [Present(\"Program Side Cusp\", null, PhysicsUnit.um, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double ProgramSideCusp_um { get; } Property Value double ReCutDepth_um Gets or sets the recut depth in micrometers. The recut depth cause the cutting mark by the end mill. The recut depth increased by the cutter radius increased. [Present(\"Re-Cut Depth on Bottom Edge on Tool Running Coordinate\", \"Re-Cut Depth\", PhysicsUnit.um, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double ReCutDepth_um { get; } Property Value double ReliefFaceCollidingVelocity_mmds Gets the relief face colliding speed. [Present(\"Relief Face Colliding Speed\", \"Rlf.C.Speed\", PhysicsUnit.mmds, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? ReliefFaceCollidingVelocity_mmds { get; } Property Value double? SentenceIndex Execution-order ordinal of the NC source block this step came from, delegated from SourceCommand. This is the source block's position — distinct from this step's own StepIndex, since one block can expand into several steps. Returns -1 (the “not in pipeline” sentinel) when there is no source carrier. public int SentenceIndex { get; } Property Value int SideCuspList_um Gets the list of side cusps in micrometers. [JsAce(ClassExt = \"MachiningStep\")] public List<double> SideCuspList_um { get; } Property Value List<double> SourceCommand Gets or sets the source command — the NC-source carrier that produced this step, exposing both the Sentence (via GetSentence()) and the execution-order SentenceIndex. public ISentenceCarrier SourceCommand { get; set; } Property Value ISentenceCarrier SpindleCyclePeriod_s Gets the spindle rotation cycle period in seconds. [Present(\"Spindle Cycle Period\", null, PhysicsUnit.sec, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double SpindleCyclePeriod_s { get; } Property Value double SpindleInputPower_W Input spindle power in watts: energy entering the spindle. [Present(\"Spindle Input Power\", null, PhysicsUnit.watt, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double SpindleInputPower_W { get; } Property Value double Input spindle power in Watts. SpindleOutputPower_W Spindle output power in watts (axial power taken by workpiece). Energy at the cutting end after spindle losses; causes workpiece/chip deformation and temperature rise. [Present(\"Spindle Output Power\", null, PhysicsUnit.watt, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double SpindleOutputPower_W { get; } Property Value double SpindleSpeed_rpm Gets the spindle speed in RPM. [Present(\"Spindle Speed\", \"S\", PhysicsUnit.rpm, \"G5\")] [JsAce(ClassExt = \"MachiningStep\")] public double SpindleSpeed_rpm { get; } Property Value double Spindle speed in rad/s SpindleTemperature_C Gets the spindle temperature in Celsius [Present(\"Spindle Temperature\", \"Spd.Temp.\", PhysicsUnit.C, \"G2\")] [JsAce(ClassExt = \"MachiningStep\")] public double? SpindleTemperature_C { get; } Property Value double? SpindleWorkingTemperatureRatio Gets the spindle working temperature ratio [Present(\"Spindle Working Temperature Ratio\", \"Spd.Temp.R.\", PhysicsUnit.None, \"G2\")] [JsAce(ClassExt = \"MachiningStep\")] public double? SpindleWorkingTemperatureRatio { get; } Property Value double? StepDuration Gets the step duration. [Present(\"Step Duration\", \"duration\", PhysicsUnit.sec, \"ss\\\\.ffffff\")] [JsAce(ClassExt = \"MachiningStep\")] public TimeSpan StepDuration { get; } Property Value TimeSpan StepIndex Gets the index of the step. [Key] [DatabaseGenerated(DatabaseGeneratedOption.None)] [Present(\"Step Index\", \"S.I.\", PhysicsUnit.None, \"G\")] public int StepIndex { get; } Property Value int ThermalStress_MPa Gets the thermal stress in MPa [Present(\"Thermal Stress\", \"Th. S.\", PhysicsUnit.MPa, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? ThermalStress_MPa { get; } Property Value double? ThermalYieldRatio Gets the thermal yield ratio [Present(\"Thermal Yield Ratio\", \"Th. Yield R.\", PhysicsUnit.None, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? ThermalYieldRatio { get; } Property Value double? TipDeflectionsOnToolRunningCoordinate_um Gets the tip deflections on tool running coordinate in micrometers [JsAce(ClassExt = \"MachiningStep\")] public List<Vec3d> TipDeflectionsOnToolRunningCoordinate_um { get; } Property Value List<Vec3d> ToolId Gets the tool ID. [Present(\"Tool ID\", \"T\", PhysicsUnit.None, \"G\")] [JsAce(ClassExt = \"MachiningStep\")] public int ToolId { get; } Property Value int ToothArcDuration_s Gets the tooth arc duration in seconds by the spindle rotation. The value is SpindleCyclePeriod_s div Cutter's teeth number. [Present(\"Tooth Arc Duration\", null, PhysicsUnit.sec, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double ToothArcDuration_s { get; } Property Value double ToothSeqOnToolRunningCoordinate Gets the sequence pair of transformation matrices representing tooth positions on the tool running coordinate system. public SeqPair<Mat4d> ToothSeqOnToolRunningCoordinate { get; } Property Value SeqPair<Mat4d> WorkpieceDermisTemperature_C Gets the workpiece dermis temperature in Celsius [Present(\"Workpiece Dermis Temperature\", \"W. Dermis T.\", PhysicsUnit.C, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? WorkpieceDermisTemperature_C { get; } Property Value double? WorkpiecePlasticDepth_um Gets the workpiece plastic depth in micrometers. The depth is at the location that the cutting stress is equal to the yielding stress. The cutting stress exert to the workpiece decreased on the depth increased. [Present(\"Workpiece Plastic Deformation Depth\", \"W.P.Depth\", PhysicsUnit.um, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double WorkpiecePlasticDepth_um { get; } Property Value double YieldingStressRatio Gets the yielding stress ratio [Present(\"Yielding Stress Ratio\", \"Y-Stress-R.\", PhysicsUnit.None, \"G4\")] [JsAce(ClassExt = \"MachiningStep\")] public double? YieldingStressRatio { get; } Property Value double? Methods GetCutterDermisAvgTemperature_C(double) Gets the average cutter dermis temperature in Celsius at the specified depth. [JsAce(ClassExt = \"MachiningStep\")] public double GetCutterDermisAvgTemperature_C(double depth_mm) Parameters depth_mm double The depth in millimeters Returns double Average temperature in Celsius GetCutterDermisTemperature_C(double) Gets the cutter dermis temperature in Celsius at the specified depth. [JsAce(ClassExt = \"MachiningStep\")] public double GetCutterDermisTemperature_C(double depth_mm) Parameters depth_mm double The depth in millimeters Returns double Temperature in Celsius GetFeedrate_mmds() Gets the program feedrate in millimeters per second. public double GetFeedrate_mmds() Returns double Feedrate in mm/s GetIndexedFileLine() Gets the file line associated with this object. public IndexedFileLine GetIndexedFileLine() Returns IndexedFileLine The file line object. GetMcValue(IMachiningChain, string) Gets the MC value for the specified tag in the machining chain. public double? GetMcValue(IMachiningChain chain, string tag) Parameters chain IMachiningChain The machining chain. tag string The tag to look up. Returns double? The MC value for the specified tag. GetMcValue(int) Gets the MC value at the specified index. For common machine tool, the index 0,1,2,3,4,5 is corresponding to motion component X,Y,Z,A,B,C. If the corresponding motion component not existed, return NaN. If MachineMotionStep not existed, return null. [JsAce(ClassExt = \"MachiningStep\")] public double? GetMcValue(int index) Parameters index int The index to look up. Returns double? The MC value at the specified index. GetRgbWithPriority(out Vec3d, out double) Gets the RGB color and priority for the milling step. public void GetRgbWithPriority(out Vec3d rgb, out double priority) Parameters rgb Vec3d The RGB color vector. priority double The priority value. GetSentence() Returns the source Sentence carried by this object. public Sentence GetSentence() Returns Sentence GetSpindleDirection() Gets the spindle direction for this milling step. [Present(\"Spindle Direction\", \"Spd.Dir.\", PhysicsUnit.None, \"G\")] [JsAce(ClassExt = \"MachiningStep\")] public SpindleDirection GetSpindleDirection() Returns SpindleDirection GetSpindleSpeed_cycleds() Gets the spindle speed in cycles per second. public double GetSpindleSpeed_cycleds() Returns double The spindle speed in cycles per second. GetSpindleSpeed_radds() Gets the spindle speed in radians per second. public double GetSpindleSpeed_radds() Returns double Spindle speed in rad/s UpdateNcOptOption(Action<NcOptOption>) Update NcOptOption for this step only. It should not be mixed with the StepBuilt event and NC inline optimization script since the concurent process may break the logics. public void UpdateNcOptOption(Action<NcOptOption> action) Parameters action Action<NcOptOption> the action to modify the step."
  },
  "api/Hi.MachiningSteps.MachiningStepUtil.html": {
    "href": "api/Hi.MachiningSteps.MachiningStepUtil.html",
    "title": "Class MachiningStepUtil | HiAPI-C# 2025",
    "summary": "Class MachiningStepUtil Namespace Hi.MachiningSteps Assembly HiMech.dll Utility class for milling step related constants and helper methods. public static class MachiningStepUtil Inheritance object MachiningStepUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Properties MachiningStepDbName Gets the database name for milling steps. public static string MachiningStepDbName { get; } Property Value string MillingStepLuggageCollectionName Gets the collection name for milling step luggage. public static string MillingStepLuggageCollectionName { get; } Property Value string"
  },
  "api/Hi.MachiningSteps.PresentAccess.html": {
    "href": "api/Hi.MachiningSteps.PresentAccess.html",
    "title": "Class PresentAccess | HiAPI-C# 2025",
    "summary": "Class PresentAccess Namespace Hi.MachiningSteps Assembly HiMech.dll Provides a value accessor bound with its PresentAttribute metadata. public class PresentAccess Inheritance object PresentAccess Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors PresentAccess(PresentAttribute, Func<object, object>) Initializes a new instance of the PresentAccess class. public PresentAccess(PresentAttribute present, Func<object, object> getFunc) Parameters present PresentAttribute The presentation metadata. getFunc Func<object, object> The accessor delegate that retrieves the value. Properties GetValueFunc Gets or sets the accessor delegate used to retrieve the value. public Func<object, object> GetValueFunc { get; set; } Property Value Func<object, object> Present Gets or sets the presentation metadata. public PresentAttribute Present { get; set; } Property Value PresentAttribute"
  },
  "api/Hi.MachiningSteps.PresentAttribute.html": {
    "href": "api/Hi.MachiningSteps.PresentAttribute.html",
    "title": "Class PresentAttribute | HiAPI-C# 2025",
    "summary": "Class PresentAttribute Namespace Hi.MachiningSteps Assembly HiMech.dll Attribute for presenting property information with localization support. public class PresentAttribute : Attribute Inheritance object Attribute PresentAttribute Inherited Members Attribute.Equals(object) Attribute.GetCustomAttribute(Assembly, Type) Attribute.GetCustomAttribute(Assembly, Type, bool) Attribute.GetCustomAttribute(MemberInfo, Type) Attribute.GetCustomAttribute(MemberInfo, Type, bool) Attribute.GetCustomAttribute(Module, Type) Attribute.GetCustomAttribute(Module, Type, bool) Attribute.GetCustomAttribute(ParameterInfo, Type) Attribute.GetCustomAttribute(ParameterInfo, Type, bool) Attribute.GetCustomAttributes(Assembly) Attribute.GetCustomAttributes(Assembly, bool) Attribute.GetCustomAttributes(Assembly, Type) Attribute.GetCustomAttributes(Assembly, Type, bool) Attribute.GetCustomAttributes(MemberInfo) Attribute.GetCustomAttributes(MemberInfo, bool) Attribute.GetCustomAttributes(MemberInfo, Type) Attribute.GetCustomAttributes(MemberInfo, Type, bool) Attribute.GetCustomAttributes(Module) Attribute.GetCustomAttributes(Module, bool) Attribute.GetCustomAttributes(Module, Type) Attribute.GetCustomAttributes(Module, Type, bool) Attribute.GetCustomAttributes(ParameterInfo) Attribute.GetCustomAttributes(ParameterInfo, bool) Attribute.GetCustomAttributes(ParameterInfo, Type) Attribute.GetCustomAttributes(ParameterInfo, Type, bool) Attribute.GetHashCode() Attribute.IsDefaultAttribute() Attribute.IsDefined(Assembly, Type) Attribute.IsDefined(Assembly, Type, bool) Attribute.IsDefined(MemberInfo, Type) Attribute.IsDefined(MemberInfo, Type, bool) Attribute.IsDefined(Module, Type) Attribute.IsDefined(Module, Type, bool) Attribute.IsDefined(ParameterInfo, Type) Attribute.IsDefined(ParameterInfo, Type, bool) Attribute.Match(object) Attribute.TypeId object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors PresentAttribute() Initializes a new instance of the PresentAttribute class. public PresentAttribute() PresentAttribute(PresentAttribute) Initializes a new instance of the PresentAttribute class by copying from another instance. public PresentAttribute(PresentAttribute src) Parameters src PresentAttribute The source attribute to copy from. PresentAttribute(string, string, PhysicsUnit, string) Initializes a new instance of the PresentAttribute class with specified parameters. public PresentAttribute(string name, string shortName, PhysicsUnit unit, string dataFormatString) Parameters name string The display name of the property. shortName string The short name of the property. unit PhysicsUnit The physics unit of the property. dataFormatString string The format string for displaying the property value. Properties DataFormatString Gets or sets the format string for displaying the property value. public string DataFormatString { get; set; } Property Value string Name Gets or sets the display name of the property. public string Name { get; set; } Property Value string ShortName Gets or sets the short name of the property. public string ShortName { get; set; } Property Value string TailUnitString Gets the unit string with parentheses for display purposes. public string TailUnitString { get; } Property Value string Unit Gets or sets the physics unit of the property. public PhysicsUnit Unit { get; set; } Property Value PhysicsUnit Methods GetPresentName(StringLocalizer) Gets the localized presentation name with unit string. public string GetPresentName(StringLocalizer loc) Parameters loc StringLocalizer The string localizer. Returns string The localized name with unit string. GetPresentName(IStringLocalizer) Gets the localized presentation name with unit string. public string GetPresentName(IStringLocalizer loc) Parameters loc IStringLocalizer The string localizer. Returns string The localized name with unit string."
  },
  "api/Hi.MachiningSteps.PropertyAccess-1.html": {
    "href": "api/Hi.MachiningSteps.PropertyAccess-1.html",
    "title": "Class PropertyAccess<TData> | HiAPI-C# 2025",
    "summary": "Class PropertyAccess<TData> Namespace Hi.MachiningSteps Assembly HiMech.dll Provides access to properties of a milling step with presentation information. public class PropertyAccess<TData> where TData : class Type Parameters TData Inheritance object PropertyAccess<TData> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors PropertyAccess(PresentAttribute, Func<TData, double?>) Initializes a new instance for numeric properties. public PropertyAccess(PresentAttribute presentAttribute, Func<TData, double?> getQuantityFunc) Parameters presentAttribute PresentAttribute The presentation attribute for the property. getQuantityFunc Func<TData, double?> The function to retrieve the numeric value. PropertyAccess(PresentAttribute, Func<TData, object>) Initializes a new instance for non-numeric properties. public PropertyAccess(PresentAttribute presentAttribute, Func<TData, object> getNonQuantityFunc) Parameters presentAttribute PresentAttribute The presentation attribute for the property. getNonQuantityFunc Func<TData, object> The function to retrieve the non-numeric value. Properties GetNonQuantityFunc Gets or sets the function to retrieve a non-numeric value from a milling step. public Func<TData, object> GetNonQuantityFunc { get; set; } Property Value Func<TData, object> GetQuantityFunc Gets or sets the function to retrieve a numeric value from a milling step. public Func<TData, double?> GetQuantityFunc { get; set; } Property Value Func<TData, double?> PresentAttribute Gets or sets the presentation attribute for the property. public PresentAttribute PresentAttribute { get; set; } Property Value PresentAttribute Methods GetValue(TData) Gets the value of the property for the specified milling step. public object GetValue(TData step) Parameters step TData The milling step to get the property value from. Returns object The property value, or null if neither function is set. GetValueText(object) Gets the formatted text representation of the specified value. public string GetValueText(object v) Parameters v object The value to format. Returns string The formatted text representation of the value. GetValueText(TData) Gets the formatted text representation of the property value for the specified milling step. public string GetValueText(TData step) Parameters step TData The milling step to get the property value from. Returns string The formatted text representation of the property value."
  },
  "api/Hi.MachiningSteps.StepActualTime.html": {
    "href": "api/Hi.MachiningSteps.StepActualTime.html",
    "title": "Class StepActualTime | HiAPI-C# 2025",
    "summary": "Class StepActualTime Namespace Hi.MachiningSteps Assembly HiMech.dll Wall-clock stamp of a machining step end — the controller-recorded timeline, as opposed to the simulated machine timeline (EndTimecode). Grouped into one optional sub-object so scenes that never map measured data (pure NC simulation, collision check, optimization) carry a single null reference per step. A CSV play stamps only the first step built after each row/idle boundary with the controller instant; the steps in between receive values extrapolated from the latest stamp along the machine timeline and are marked IsInterpolated. public class StepActualTime Inheritance object StepActualTime Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Instant Absolute controller instant of the step end; null when the source row carried only a relative timecode. public DateTime? Instant { get; set; } Property Value DateTime? IsInterpolated False when the values came directly from a controller row (an original stamp — a genuine timeline anchor); true when they were extrapolated from the latest stamp along the machine timeline. public bool IsInterpolated { get; set; } Property Value bool Timecode Run-relative wall-clock timecode of the step end, resolved against the project mapping anchor (TimeMapping.MappingAnchorDateTime). public TimeSpan Timecode { get; set; } Property Value TimeSpan"
  },
  "api/Hi.MachiningSteps.StepPresentCatalog.html": {
    "href": "api/Hi.MachiningSteps.StepPresentCatalog.html",
    "title": "Class StepPresentCatalog | HiAPI-C# 2025",
    "summary": "Class StepPresentCatalog Namespace Hi.MachiningSteps Assembly HiMech.dll Internal Use Only. Expands the PresentAttribute-annotated properties of MachiningStep into the stable presentation-key dictionary (vector properties fan out to .X/.Y/.Z, the cutter location to .X/.Y/.Z/.I/.J/.K). public static class StepPresentCatalog Inheritance object StepPresentCatalog Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods BuildNativeAccessDictionary() Internal Use Only. Builds the key-to-access dictionary for the native (machine-independent) MachiningStep presentation properties. public static Dictionary<string, PropertyAccess<MachiningStep>> BuildNativeAccessDictionary() Returns Dictionary<string, PropertyAccess<MachiningStep>> The dictionary mapping stable presentation keys to their property access."
  },
  "api/Hi.MachiningSteps.html": {
    "href": "api/Hi.MachiningSteps.html",
    "title": "Namespace Hi.MachiningSteps | HiAPI-C# 2025",
    "summary": "Namespace Hi.MachiningSteps Classes MachineMotionStep MachiningStep has spindle information. Note that the spindle information is only for milling behavior. MachiningStep Represents a machining step enriched with physics, mapping and source metadata. The duration-based step property is based on the duration from previous-step to current-step. MachiningStep.CollidedKeyPair A pair of collided keys that indicates two entities are in collision. MachiningStepUtil Utility class for milling step related constants and helper methods. PresentAccess Provides a value accessor bound with its PresentAttribute metadata. PresentAttribute Attribute for presenting property information with localization support. PropertyAccess<TData> Provides access to properties of a milling step with presentation information. StepActualTime Wall-clock stamp of a machining step end — the controller-recorded timeline, as opposed to the simulated machine timeline (EndTimecode). Grouped into one optional sub-object so scenes that never map measured data (pure NC simulation, collision check, optimization) carry a single null reference per step. A CSV play stamps only the first step built after each row/idle boundary with the controller instant; the steps in between receive values extrapolated from the latest stamp along the machine timeline and are marked IsInterpolated. StepPresentCatalog Internal Use Only. Expands the PresentAttribute-annotated properties of MachiningStep into the stable presentation-key dictionary (vector properties fan out to .X/.Y/.Z, the cutter location to .X/.Y/.Z/.I/.J/.K). Interfaces IFlagText temperary design for showing flag text. IMachiningService Represents a host interface for milling steps that provides access to milling equipment and related resources. IMotionStepIndex Abstraction for an object that carries a StepIndex — the 0-based ordinal of a machining motion step in execution order. Used as a cross-object alignment key so a step (MachiningStep), its cutter-location position (ClStripPos), and the messages anchored to it (StepDiagnostic, StepScopedProgress) can be matched by the same ordinal without depending on a concrete type. Distinct from ISentenceIndexed: that ordinal counts NC source blocks, whereas this one counts produced motion steps — a single source block (e.g. a canned cycle) can fan out into several steps. IStepPropertyAccessHost Narrow host contract for accessing the step-variable registry and registering new step variables. Exposed as a dedicated surface so pipelines that only need step-variable wiring (e.g. CsvRowSyntax) do not have to depend on the broader IMachiningService."
  },
  "api/Hi.Mapping.CsvNcStep.html": {
    "href": "api/Hi.Mapping.CsvNcStep.html",
    "title": "Class CsvNcStep | HiAPI-C# 2025",
    "summary": "Class CsvNcStep Namespace Hi.Mapping Assembly HiMech.dll Represents a numerical control step loaded from a CSV file, with support for interpolation and arithmetic operations. public class CsvNcStep : IGetFileLineIndex, IAdditionOperators<CsvNcStep, CsvNcStep, CsvNcStep>, IMultiplyOperators<CsvNcStep, double, CsvNcStep> Inheritance object CsvNcStep Implements IGetFileLineIndex IAdditionOperators<CsvNcStep, CsvNcStep, CsvNcStep> IMultiplyOperators<CsvNcStep, double, CsvNcStep> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CsvNcStep(FileLineIndex, TimeSpan, DVec3d, List<double>) Initializes a new instance of the CsvNcStep class with the specified parameters. public CsvNcStep(FileLineIndex fileLineIndex, TimeSpan time, DVec3d mcXyzabc, List<double> doubleFlexList) Parameters fileLineIndex FileLineIndex The file and line index information. time TimeSpan The time value for this step. mcXyzabc DVec3d The machine coordinates for this step. doubleFlexList List<double> The list of additional double values. Properties ActualDateTime Optional absolute controller instant captured at parse time; null when the row was relative. Resolved to ActualTimecode against the project mapping anchor (timecode-first when both are present). public DateTime? ActualDateTime { get; set; } Property Value DateTime? ActualTimecode Gets or sets the relative timecode for this step (position from run start). Authoritative for interpolation / arithmetic. public TimeSpan ActualTimecode { get; set; } Property Value TimeSpan DoubleFlexList Gets or sets the list of additional double values associated with this step. public List<double> DoubleFlexList { get; set; } Property Value List<double> FileLineIndex Gets or sets the file and line index information. public FileLineIndex FileLineIndex { get; set; } Property Value FileLineIndex McXyzabc Gets the machine coordinates (XYZ and ABC) for this step. public DVec3d McXyzabc { get; } Property Value DVec3d Methods GetFileLineIndex() Get FileLineIndex. public FileLineIndex GetFileLineIndex() Returns FileLineIndex FileLineIndex MapSingleByCsvFile(ClStrip, string, string, IProgress<IMessage>, Func<DateTime, TimeSpan>) Embed single data per step by CSV file. It is one (step) - one (embedded-data) mapping. Time interpolation is applied. It is time-based mapping. Builds a collection of CsvNcStep instances from a CSV file. public static void MapSingleByCsvFile(ClStrip clStrip, string baseDirectory, string relFile, IProgress<IMessage> messageProgress, Func<DateTime, TimeSpan> toTimecode = null) Parameters clStrip ClStrip The cutter location strip to populate. baseDirectory string The base directory for the file path. relFile string The relative file path to the CSV file. messageProgress IProgress<IMessage> The message host for logging. toTimecode Func<DateTime, TimeSpan> Converter from an absolute controller instant to a run-relative timecode (the project mapping anchor's converter). Used when the actual-time cell is a DateTime rather than a bare timecode; timecode-first when both are parseable. Null falls back to the legacy timecode / sim-time parse. Operators operator +(CsvNcStep, CsvNcStep) Adds two CsvNcStep instances together. public static CsvNcStep operator +(CsvNcStep left, CsvNcStep right) Parameters left CsvNcStep The first CsvNcStep instance. right CsvNcStep The second CsvNcStep instance. Returns CsvNcStep A new CsvNcStep instance with values that are the sum of the two input instances. operator *(CsvNcStep, double) Multiplies a CsvNcStep instance by a scalar value. public static CsvNcStep operator *(CsvNcStep src, double scale) Parameters src CsvNcStep The CsvNcStep instance to multiply. scale double The scalar value to multiply by. Returns CsvNcStep A new CsvNcStep instance with values scaled by the specified factor."
  },
  "api/Hi.Mapping.FileToTimeShotMapping.html": {
    "href": "api/Hi.Mapping.FileToTimeShotMapping.html",
    "title": "Class FileToTimeShotMapping | HiAPI-C# 2025",
    "summary": "Class FileToTimeShotMapping Namespace Hi.Mapping Assembly HiMech.dll Provides mapping between files and time shot data with caching capabilities. This class manages the loading and caching of time shot data from measurement files. public class FileToTimeShotMapping Inheritance object FileToTimeShotMapping Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties LineReaded Gets or sets the callback action that is invoked when a line is read from a file. This can be used to track progress during file loading operations. public Action<int> LineReaded { get; set; } Property Value Action<int> Remarks The parameter passed to the action is the current line number being read. This is useful for implementing progress indicators or logging. Methods CallTimeShotByFile(string, CancellationToken?) Gets time shot data from a file, using cache if available. If the data is not in the cache, reads the file and caches the results. public List<ITimeShot> CallTimeShotByFile(string file, CancellationToken? cancellationToken = null) Parameters file string The file path to read time shot data from. cancellationToken CancellationToken? Optional cancellation token to cancel the operation. Returns List<ITimeShot> A list of time shots from the file. The results are cached for subsequent calls. Returns null if the file cannot be read or contains invalid data. Remarks This method is thread-safe and ensures each file is only read once, even with concurrent access. The cached data is shared between all callers to improve performance. Clear() Clears the file to time shot mapping cache. This removes all cached data and frees up memory. public void Clear() Remarks Call this method when: The cached data is no longer needed You need to force a reload of data from files You need to free up memory"
  },
  "api/Hi.Mapping.IAccelerationShot.html": {
    "href": "api/Hi.Mapping.IAccelerationShot.html",
    "title": "Interface IAccelerationShot | HiAPI-C# 2025",
    "summary": "Interface IAccelerationShot Namespace Hi.Mapping Assembly HiMech.dll Interface for objects that represent acceleration measurements at a specific time point. Extends the ITimeShot interface to include acceleration data in multiple units. public interface IAccelerationShot : ITimeShot, ITimecoded Inherited Members ITimeShot.GetAdd(ITimeShot) ITimeShot.GetScaled(double) ITimecoded.Timecode Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks This interface adds acceleration measurement capabilities to time shots: Provides acceleration data in multiple units (mm/s², m/s², g) Supports automatic unit conversion between different scales Typically used for vibration analysis in machining operations Maintains consistent coordinate system conventions across unit conversions Properties Acceleration_g Gets or sets the acceleration vector in g-force units (g). This property automatically converts between mm/s² and g, where 1g = 9.81 m/s². Vec3d Acceleration_g { get; set; } Property Value Vec3d Remarks Conversion factors: From m/s² to g: divide by 9.81 From g to m/s²: multiply by 9.81 Common reference values: 1g: Earth's gravitational acceleration 0g: Free fall Acceleration_mds2 Gets or sets the acceleration vector in meters per second squared (m/s²). This property automatically converts between mm/s² and m/s². Vec3d Acceleration_mds2 { get; set; } Property Value Vec3d Remarks Conversion factors: From mm/s² to m/s²: divide by 1000 From m/s² to mm/s²: multiply by 1000 Acceleration_mmds2 Gets or sets the acceleration vector in millimeters per second squared (mm/s²). This is the base unit for acceleration storage in the system. Vec3d Acceleration_mmds2 { get; set; } Property Value Vec3d Remarks The acceleration vector components represent: X: Acceleration in the X direction (mm/s²) Y: Acceleration in the Y direction (mm/s²) Z: Acceleration in the Z direction (mm/s²)"
  },
  "api/Hi.Mapping.IForceShot.html": {
    "href": "api/Hi.Mapping.IForceShot.html",
    "title": "Interface IForceShot | HiAPI-C# 2025",
    "summary": "Interface IForceShot Namespace Hi.Mapping Assembly HiMech.dll Interface for objects that represent force measurements at a specific time point. Extends the ITimeShot interface to include force vector data. public interface IForceShot : ITimeShot, ITimecoded Inherited Members ITimeShot.GetAdd(ITimeShot) ITimeShot.GetScaled(double) ITimecoded.Timecode Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks This interface adds force measurement capabilities to time shots: Force is represented as a 3D vector in Newtons Supports operations inherited from ITimeShot Implementations should handle coordinate system conventions appropriately Typically used for recording cutting forces in machining operations Properties Force_N Gets or sets the force vector applied to the workpiece, measured in Newtons (N). Vec3d Force_N { get; set; } Property Value Vec3d Remarks The force vector components represent: X: Force in the X direction (N) Y: Force in the Y direction (N) Z: Force in the Z direction (N) Positive values typically indicate: Forces acting in the positive direction of each axis Forces applied to the workpiece (rather than the tool)"
  },
  "api/Hi.Mapping.IMomentShot.html": {
    "href": "api/Hi.Mapping.IMomentShot.html",
    "title": "Interface IMomentShot | HiAPI-C# 2025",
    "summary": "Interface IMomentShot Namespace Hi.Mapping Assembly HiMech.dll Interface for objects that represent moment (torque) measurements at a specific time point. Extends the ITimeShot interface to include moment vector data. public interface IMomentShot : ITimeShot, ITimecoded Inherited Members ITimeShot.GetAdd(ITimeShot) ITimeShot.GetScaled(double) ITimecoded.Timecode Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks This interface adds moment measurement capabilities to time shots: Moments are represented as 3D vectors in Newton-meters Supports operations inherited from ITimeShot Typically used for recording spindle or tool torques in machining operations Follows the right-hand rule convention for moment directions Properties Moment_Nm Gets or sets the moment (torque) vector, measured in Newton-meters (N⋅m). Vec3d Moment_Nm { get; set; } Property Value Vec3d Remarks The moment vector components represent: X: Moment around the X axis (N⋅m) Y: Moment around the Y axis (N⋅m) Z: Moment around the Z axis (N⋅m) Positive values indicate: Clockwise moments when looking along the positive axis direction Following the right-hand rule convention"
  },
  "api/Hi.Mapping.ITimeShot.html": {
    "href": "api/Hi.Mapping.ITimeShot.html",
    "title": "Interface ITimeShot | HiAPI-C# 2025",
    "summary": "Interface ITimeShot Namespace Hi.Mapping Assembly HiMech.dll Interface for objects that represent a snapshot of data at a specific time and support arithmetic operations. This interface provides a foundation for time-series data with vector operations. public interface ITimeShot : ITimecoded Inherited Members ITimecoded.Timecode Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks Implementations of this interface should: Store data associated with a specific time point Support addition with other time shots Support scaling by a scalar value Handle null or invalid data appropriately Methods GetAdd(ITimeShot) Adds another time shot to this one. ITimeShot GetAdd(ITimeShot shot) Parameters shot ITimeShot The time shot to add. Returns ITimeShot A new time shot representing the sum of the two shots. Remarks The addition should: Combine vector components appropriately Handle null or missing data gracefully Preserve the time value according to implementation rules GetScaled(double) Scales the values in this time shot by the specified factor. ITimeShot GetScaled(double scale) Parameters scale double The scaling factor to apply to all vector components. Returns ITimeShot A new time shot with all values scaled by the given factor. Remarks The scaling should: Apply to all vector components Handle null or missing data gracefully Scale the time value if appropriate for the implementation"
  },
  "api/Hi.Mapping.MappingUtil.html": {
    "href": "api/Hi.Mapping.MappingUtil.html",
    "title": "Class MappingUtil | HiAPI-C# 2025",
    "summary": "Class MappingUtil Namespace Hi.Mapping Assembly HiMech.dll Shared CSV column tags and physics-related column prefixes for mapping simulator or logged controller data onto MachiningStep rows. public static class MappingUtil Inheritance object MappingUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields ActualDateTimeTag Absolute controller-instant column written alongside ActualTimecodeTag (the MachiningStep.ActualDateTime member) so the calendar date survives. Pinned to a literal so renaming the member does not change the CSV header; optional companion column. public const string ActualDateTimeTag = \"ActualDateTime\" Field Value string ActualTimeTag Legacy single-column title for actual time in the CSV (a bare TimeSpan timecode or an absolute DateTime). The step-file writer now splits this into the ActualTimecodeTag + ActualDateTimeTag pair; this column is still read for pre-split files. public const string ActualTimeTag = \"ActualTime\" Field Value string ActualTimecodeTag Run-relative actual timecode column written by the step-file exporter (the MachiningStep.ActualTimecode member). Pinned to a literal so renaming the member does not change the CSV header; preferred over the legacy single ActualTimeTag column when present. public const string ActualTimecodeTag = \"ActualTimecode\" Field Value string CoolantTag Coolant tag for CSV parsing. The cell holds the coolant mode name (e.g. Flood / Mist / Off) or a boolean on/off flag. public const string CoolantTag = \"Coolant\" Field Value string CutterLocationPrefix Cutter Location Prefix Tag for CSV Parsing. public const string CutterLocationPrefix = \"CL.\" Field Value string DurationTag Duration tag for CSV parsing. public const string DurationTag = \"StepDuration\" Field Value string FeedrateTag_mmdmin Feedrate for Simulator Tag for CSV Parsing. public const string FeedrateTag_mmdmin = \"Feedrate_mmdmin\" Field Value string FileNoTag Gets or sets the column title for file number in the CSV. public const string FileNoTag = \"FileNo\" Field Value string HolderMomentPrefix CSV column prefix for holder moment / torque channels. public const string HolderMomentPrefix = \"Holder.M\" Field Value string LineBeginCsScriptTag LineBeginCsScript Tag for CSV Parsing. public const string LineBeginCsScriptTag = \"LineBeginCsScript\" Field Value string LineEndCsScriptTag LineEndCsScript Tag for CSV Parsing. public const string LineEndCsScriptTag = \"LineEndCsScript\" Field Value string LineNoTag Gets or sets the column title for line number in the CSV. public const string LineNoTag = \"LineNo\" Field Value string MachineCoordinatePrefix Machine Coordinate Prefix Tag for CSV Parsing. public const string MachineCoordinatePrefix = \"MC.\" Field Value string SimTimeTag Fallback time column when ActualTimeTag is absent or unparseable: the simulated end timecode. Pinned to a literal (decoupled from the model member name) so renaming the member does not change the CSV header; pre-rename files that used the old “AccumulatedTime” header are still read via SimTimeTagLegacy / GetSimTimeCell(IReadOnlyDictionary<string, string>). public const string SimTimeTag = \"EndTimecode\" Field Value string SimTimeTagLegacy Legacy CSV header accepted as a fallback for SimTimeTag (files written before the EndTimecode rename used the member name AccumulatedTime). public const string SimTimeTagLegacy = \"AccumulatedTime\" Field Value string SpindleDirectionTag Spindle direction Tag for CSV Parsing. public const string SpindleDirectionTag = \"Spd.Dir.\" Field Value string SpindleSpeedTag_rpm Spindle speed for Simulator Tag for CSV Parsing. public const string SpindleSpeedTag_rpm = \"SpindleSpeed_rpm\" Field Value string TimeTag Gets or sets the column title for time in the CSV. The time generally obtained by the simulated data. public const string TimeTag = \"Time\" Field Value string ToolForcePrefix CSV column prefix for tool-side force components (e.g. dynamometer). public const string ToolForcePrefix = \"Tool.F\" Field Value string ToolIdTag Tool ID Tag for CSV Parsing. public const string ToolIdTag = \"ToolId\" Field Value string WorkpieceForcePrefix CSV column prefix for workpiece-side force components. public const string WorkpieceForcePrefix = \"Workpiece.F\" Field Value string Methods GetSimTimeCell(IReadOnlyDictionary<string, string>) Returns the de-quoted simulated-time cell from row, reading SimTimeTag first and falling back to the legacy SimTimeTagLegacy header, or null when neither column is present. public static string GetSimTimeCell(IReadOnlyDictionary<string, string> row) Parameters row IReadOnlyDictionary<string, string> Returns string"
  },
  "api/Hi.Mapping.StepTimeShotUtil.CycleSamplingMode.html": {
    "href": "api/Hi.Mapping.StepTimeShotUtil.CycleSamplingMode.html",
    "title": "Enum StepTimeShotUtil.CycleSamplingMode | HiAPI-C# 2025",
    "summary": "Enum StepTimeShotUtil.CycleSamplingMode Namespace Hi.Mapping Assembly HiMech.dll Defines the cycle sampling modes for mapping time shots to machining steps. The sampling mode determines how time shots are aligned with machining cycles. public enum StepTimeShotUtil.CycleSamplingMode Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields FluteCycle = 2 Sample based on flute cutting cycle. Uses the period between successive flute cuts to map time shots. More precise for actual cutting engagement analysis. SpindleCycle = 1 Sample based on spindle rotation cycle. Uses the spindle's rotational period to map time shots."
  },
  "api/Hi.Mapping.StepTimeShotUtil.GetTimeShotByFileDelegate.html": {
    "href": "api/Hi.Mapping.StepTimeShotUtil.GetTimeShotByFileDelegate.html",
    "title": "Delegate StepTimeShotUtil.GetTimeShotByFileDelegate | HiAPI-C# 2025",
    "summary": "Delegate StepTimeShotUtil.GetTimeShotByFileDelegate Namespace Hi.Mapping Assembly HiMech.dll Delegate for retrieving time shots from a file. Implementations should handle file reading, parsing, and error handling. public delegate List<ITimeShot> StepTimeShotUtil.GetTimeShotByFileDelegate(string file) Parameters file string The absolute or relative path to the file containing time shot data. Returns List<ITimeShot> A list of parsed time shots, or null if reading fails. Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Mapping.StepTimeShotUtil.html": {
    "href": "api/Hi.Mapping.StepTimeShotUtil.html",
    "title": "Class StepTimeShotUtil | HiAPI-C# 2025",
    "summary": "Class StepTimeShotUtil Namespace Hi.Mapping Assembly HiMech.dll Utility methods for working with time-based shots (measurements) and mapping them to machining steps. public static class StepTimeShotUtil Inheritance object StepTimeShotUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetStepToShotsDictionaryByActualTime(ClStrip, CycleSamplingMode, string, GetTimeShotByFileDelegate, IDictionary<int, List<ITimeShot>>, IProgress<IMessage>, CancellationToken?) Gets a dictionary mapping step indices to time shots based on actual time. public static void GetStepToShotsDictionaryByActualTime(ClStrip clStrip, StepTimeShotUtil.CycleSamplingMode cycleSamplingMode, string timeShotRelFile, StepTimeShotUtil.GetTimeShotByFileDelegate getTimeShotByRelFileFunc, IDictionary<int, List<ITimeShot>> dstStepToShotsDictionary, IProgress<IMessage> messageProgress, CancellationToken? cancellationToken) Parameters clStrip ClStrip The cutter location strip. cycleSamplingMode StepTimeShotUtil.CycleSamplingMode The cycle sampling mode. timeShotRelFile string The relative file path for time shots. getTimeShotByRelFileFunc StepTimeShotUtil.GetTimeShotByFileDelegate The delegate function to get time shots by relative file path. dstStepToShotsDictionary IDictionary<int, List<ITimeShot>> The destination dictionary to store the mapping. messageProgress IProgress<IMessage> The session message host for logging. cancellationToken CancellationToken? The cancellation token. GetTimeShotByFile(string, Action<int>, CancellationToken?, Func<DateTime, TimeSpan>) Gets time shots from a file, reading and parsing force acceleration data. public static List<ITimeShot> GetTimeShotByFile(string file, Action<int> lineReaded, CancellationToken? cancellationToken = null, Func<DateTime, TimeSpan> toTimecode = null) Parameters file string The file path to read time shots from. lineReaded Action<int> Action to call when a line is read, providing progress feedback with the current line number. cancellationToken CancellationToken? Optional cancellation token to cancel the reading operation. toTimecode Func<DateTime, TimeSpan> Converter from an absolute sample DateTime to its timecode TimeSpan (used for step timing). Returns List<ITimeShot> A list of time shots read from the file, or null if the file cannot be read or is invalid."
  },
  "api/Hi.Mapping.TimeMapping.html": {
    "href": "api/Hi.Mapping.TimeMapping.html",
    "title": "Class TimeMapping | HiAPI-C# 2025",
    "summary": "Class TimeMapping Namespace Hi.Mapping Assembly HiMech.dll Provides mapping between machining steps and time-based measurements (shots). It is one step to many data mapping (one-many). public class TimeMapping : IMakeXmlSource, IDisposable Inheritance object TimeMapping Implements IMakeXmlSource IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors TimeMapping(Func<string>) Initializes a new instance of the TimeMapping class with the specified CL strip and tool house. public TimeMapping(Func<string> baseDirectoryGetter) Parameters baseDirectoryGetter Func<string> The function to get the base directory for file paths. TimeMapping(XElement, Func<string>) Initializes a new instance of the TimeMapping class from XML data. public TimeMapping(XElement src, Func<string> baseDirectoryGetter) Parameters src XElement The XML element containing the mapping data. baseDirectoryGetter Func<string> The function to get the base directory for resolving relative file paths. Remarks This constructor supports legacy XML formats and automatically converts them to the current format. Legacy formats include: NcMapping with MarkIdToFileTimeSection element Entries with MarkID attributes Properties BaseDirectory Gets or sets the base directory for resolving file paths. All relative file paths in the mapping are resolved against this directory. public string BaseDirectory { get; } Property Value string BaseDirectoryGetter Gets or sets the function to get the base directory for resolving file paths. public Func<string> BaseDirectoryGetter { get; set; } Property Value Func<string> KeyToRelFileTimeSectionDictionary Gets or sets the dictionary mapping keys to file time sections. Each entry maps a unique identifier to a file time section that specifies which portion of a measurement file corresponds to a particular machining operation. public Dictionary<string, IFileTimeSection> KeyToRelFileTimeSectionDictionary { get; set; } Property Value Dictionary<string, IFileTimeSection> MappingAnchorDateTime Project-scoped anchor for converting an absolute-time (FileDateTimeSection) window into a relative timecode. Set it to the earliest controller instant (the broadest recorded stream covers everything else) so every dateTime - anchor is non-negative. null until set; absolute sections cannot be resolved while it is null. public DateTime? MappingAnchorDateTime { get; set; } Property Value DateTime? RelFileToTimeShotListDictionary Gets or sets the cache of time shot lists loaded from files. This is a thread-safe dictionary that maps file paths to tasks that load and parse the files. The cache prevents multiple reads of the same file and enables concurrent access. public ConcurrentDictionary<string, Task<List<ITimeShot>>> RelFileToTimeShotListDictionary { get; set; } Property Value ConcurrentDictionary<string, Task<List<ITimeShot>>> StepToTimeShotListDictionary Gets a concurrent dictionary mapping step indices to their corresponding time shot lists. This dictionary is populated during the mapping process. public ConcurrentDictionary<int, List<ITimeShot>> StepToTimeShotListDictionary { get; } Property Value ConcurrentDictionary<int, List<ITimeShot>> XName Gets the XML element name used for serialization. public static string XName { get; } Property Value string Remarks This name is used as the root element when serializing TimeMapping instances to XML. It matches the class name to maintain consistency between code and XML representation. Methods AddTimeDataByFile(string, string, double, double) Seconds overload of AddTimeDataByFile(string, string, string, string). public bool AddTimeDataByFile(string key, string relFile, double beginTime, double endTime) Parameters key string relFile string beginTime double endTime double Returns bool AddTimeDataByFile(string, string, string, string) Adds a key → file-time-section entry to KeyToRelFileTimeSectionDictionary. Begin/end texts are parsed timecode-first: seconds or HH:mm:ss → FileTimecodeSection; a date-bearing string → FileDateTimeSection. Returns false when the key already exists. public bool AddTimeDataByFile(string key, string relFile, string beginTimeText, string endTimeText) Parameters key string relFile string beginTimeText string endTimeText string Returns bool CallTimeShotByRelFile(string, IProgress<IMessage>, CancellationToken?) Retrieves time shots from a file, using cached results if available. public List<ITimeShot> CallTimeShotByRelFile(string relFile, IProgress<IMessage> messageProgress, CancellationToken? cancellationToken = null) Parameters relFile string The relative path to the file containing time shots. messageProgress IProgress<IMessage> The message host for logging progress. cancellationToken CancellationToken? Optional token to cancel the loading operation. Returns List<ITimeShot> A list of time shots from the file. The results are cached for subsequent calls. If the file is already being loaded by another thread, waits for that operation to complete. Remarks This method is thread-safe and ensures each file is only read once, even with concurrent access. Any exceptions during file reading are captured and can be inspected through the task's exception property. Clear() Clears all mappings and data, including the key-to-file time section dictionary. public void Clear() ClearCache() Clears the cache of loaded time shot data, including file-to-time shot list and step-to-time shot list dictionaries. public void ClearCache() Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool GetShots(int) Gets the time shots associated with a specific step index. public List<ITimeShot> GetShots(int stepIndex) Parameters stepIndex int The index of the step to get shots for. Returns List<ITimeShot> A list of time shots associated with the specified step, or null if no shots are found. LoadTimeShotFiles(IProgress<IMessage>, CancellationToken?) Loads all time shot files referenced in the KeyToFileTimeSectionMapping. public void LoadTimeShotFiles(IProgress<IMessage> messageProgress, CancellationToken? cancellationToken = null) Parameters messageProgress IProgress<IMessage> The message host for logging progress. cancellationToken CancellationToken? Optional cancellation token to cancel the operation. MakeXmlSource(string, string, bool) Creates an XML representation of the time mapping data. relFile is not used in current implementation. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element containing the complete time mapping data. Remarks The XML structure includes: A root TimeMapping element An Entrys element containing Entry elements Each Entry has a Key attribute and FileTimeSection child element Map(Range<int>, IFileTimeSection, CycleSamplingMode, ClStrip, IProgress<IMessage>, CancellationToken?) Maps the specified step section to time shots using the provided file time section and cycle sampling mode. This method is thread-safe and can be called concurrently. public void Map(Range<int> stepSection, IFileTimeSection relFileTimeSection, StepTimeShotUtil.CycleSamplingMode cycleSamplingMode, ClStrip clStrip, IProgress<IMessage> messageProgress, CancellationToken? cancellationToken = null) Parameters stepSection Range<int> The range of step indices to process. relFileTimeSection IFileTimeSection The file time section containing file path and time range. cycleSamplingMode StepTimeShotUtil.CycleSamplingMode The cycle sampling mode to use. clStrip ClStrip The cutter location strip to map. messageProgress IProgress<IMessage> The message host for logging progress. cancellationToken CancellationToken? Optional cancellation token to cancel the operation. MapSeriesByActualTime(string, CycleSamplingMode, ClStrip, IProgress<IMessage>, CancellationToken?) Maps steps to time shots based on actual time. public void MapSeriesByActualTime(string timeShotRelFile, StepTimeShotUtil.CycleSamplingMode cycleSamplingMode, ClStrip clStrip, IProgress<IMessage> messageProgress, CancellationToken? cancellationToken = null) Parameters timeShotRelFile string The relative file path for time shots. cycleSamplingMode StepTimeShotUtil.CycleSamplingMode The cycle sampling mode. clStrip ClStrip The cutter location strip to map. messageProgress IProgress<IMessage> The session message host for logging. cancellationToken CancellationToken? The cancellation token. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToTimecode(DateTime) Converts an absolute controller instant to a run-relative timecode against MappingAnchorDateTime. The anchor is seeded set-once (date-only, so same-day data lines up with the controller's time-of-day) the first time any conversion is requested, unless it was already loaded from project XML or set explicitly. This is the single place the anchor set-logic lives — every DateTime → timecode site calls here rather than re-deriving instant - anchor. public TimeSpan ToTimecode(DateTime instant) Parameters instant DateTime The absolute controller instant to convert. Returns TimeSpan The instant expressed as a timecode from the anchor. WaitMapping() Waits for all mapping operations to complete. This method blocks until all concurrent mapping tasks have finished. public void WaitMapping()"
  },
  "api/Hi.Mapping.html": {
    "href": "api/Hi.Mapping.html",
    "title": "Namespace Hi.Mapping | HiAPI-C# 2025",
    "summary": "Namespace Hi.Mapping Classes CsvNcStep Represents a numerical control step loaded from a CSV file, with support for interpolation and arithmetic operations. FileToTimeShotMapping Provides mapping between files and time shot data with caching capabilities. This class manages the loading and caching of time shot data from measurement files. MappingUtil Shared CSV column tags and physics-related column prefixes for mapping simulator or logged controller data onto MachiningStep rows. StepTimeShotUtil Utility methods for working with time-based shots (measurements) and mapping them to machining steps. TimeMapping Provides mapping between machining steps and time-based measurements (shots). It is one step to many data mapping (one-many). Interfaces IAccelerationShot Interface for objects that represent acceleration measurements at a specific time point. Extends the ITimeShot interface to include acceleration data in multiple units. IForceShot Interface for objects that represent force measurements at a specific time point. Extends the ITimeShot interface to include force vector data. IMomentShot Interface for objects that represent moment (torque) measurements at a specific time point. Extends the ITimeShot interface to include moment vector data. ITimeShot Interface for objects that represent a snapshot of data at a specific time and support arithmetic operations. This interface provides a foundation for time-series data with vector operations. Enums StepTimeShotUtil.CycleSamplingMode Defines the cycle sampling modes for mapping time shots to machining steps. The sampling mode determines how time shots are aligned with machining cycles. Delegates StepTimeShotUtil.GetTimeShotByFileDelegate Delegate for retrieving time shots from a file. Implementations should handle file reading, parsing, and error handling."
  },
  "api/Hi.Mappings.FileDateTimeSection.html": {
    "href": "api/Hi.Mappings.FileDateTimeSection.html",
    "title": "Class FileDateTimeSection | HiAPI-C# 2025",
    "summary": "Class FileDateTimeSection Namespace Hi.Mappings Assembly HiGeom.dll (B) Time window expressed in absolute DateTime only. public sealed class FileDateTimeSection : IFileTimeSection, IMakeXmlSource Inheritance object FileDateTimeSection Implements IFileTimeSection IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) Extension Methods XmlUtil.MakeXmlSourceToFile(IMakeXmlSource, string, bool) XmlUtil.MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) XmlUtil.SaveToByteArrayAsync(IMakeXmlSource, string) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FileDateTimeSection() Initializes an empty instance. public FileDateTimeSection() FileDateTimeSection(FileTimecodeDateTimeSection) Projects a both-form (C) section onto its absolute form (independent copy). public FileDateTimeSection(FileTimecodeDateTimeSection c) Parameters c FileTimecodeDateTimeSection FileDateTimeSection(string, DateTime, DateTime) Initializes from a file and begin/end instants. public FileDateTimeSection(string file, DateTime beginDateTime, DateTime endDateTime) Parameters file string beginDateTime DateTime endDateTime DateTime FileDateTimeSection(XElement) Initializes from XML. public FileDateTimeSection(XElement src) Parameters src XElement Properties BeginDateTime Window start as an absolute controller instant. public DateTime BeginDateTime { get; set; } Property Value DateTime EndDateTime Window end as an absolute controller instant. public DateTime EndDateTime { get; set; } Property Value DateTime File Relative path of the referenced (sensor) file. public string File { get; set; } Property Value string XName XML element name for XFactory registration. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type with the factory. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Mappings.FileTimecodeDateTimeSection.html": {
    "href": "api/Hi.Mappings.FileTimecodeDateTimeSection.html",
    "title": "Class FileTimecodeDateTimeSection | HiAPI-C# 2025",
    "summary": "Class FileTimecodeDateTimeSection Namespace Hi.Mappings Assembly HiGeom.dll (C) Time window carrying both forms. The timecode form is authoritative for mapping (timecode-first); the absolute form is retained for the anchor and for projecting to a single-form section (new FileTimecodeSection(c) / new FileDateTimeSection(c)) when the two forms do not agree. public sealed class FileTimecodeDateTimeSection : IFileTimeSection, IMakeXmlSource Inheritance object FileTimecodeDateTimeSection Implements IFileTimeSection IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) Extension Methods XmlUtil.MakeXmlSourceToFile(IMakeXmlSource, string, bool) XmlUtil.MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) XmlUtil.SaveToByteArrayAsync(IMakeXmlSource, string) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FileTimecodeDateTimeSection() Initializes an empty instance. public FileTimecodeDateTimeSection() FileTimecodeDateTimeSection(string, TimeSpan, TimeSpan, DateTime, DateTime) Initializes from a file, a timecode range and an absolute range. public FileTimecodeDateTimeSection(string file, TimeSpan beginTimecode, TimeSpan endTimecode, DateTime beginDateTime, DateTime endDateTime) Parameters file string beginTimecode TimeSpan endTimecode TimeSpan beginDateTime DateTime endDateTime DateTime FileTimecodeDateTimeSection(XElement) Initializes from XML. public FileTimecodeDateTimeSection(XElement src) Parameters src XElement Properties BeginDateTime Window start as an absolute controller instant. public DateTime BeginDateTime { get; set; } Property Value DateTime BeginTimecode Window start as a timecode (authoritative for mapping). public TimeSpan BeginTimecode { get; set; } Property Value TimeSpan EndDateTime Window end as an absolute controller instant. public DateTime EndDateTime { get; set; } Property Value DateTime EndTimecode Window end as a timecode (authoritative for mapping). public TimeSpan EndTimecode { get; set; } Property Value TimeSpan File Relative path of the referenced (sensor) file. public string File { get; set; } Property Value string XName XML element name for XFactory registration. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type with the factory. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Mappings.FileTimecodeSection.html": {
    "href": "api/Hi.Mappings.FileTimecodeSection.html",
    "title": "Class FileTimecodeSection | HiAPI-C# 2025",
    "summary": "Class FileTimecodeSection Namespace Hi.Mappings Assembly HiGeom.dll (A) Time window expressed in relative TimeSpan timecodes only. public sealed class FileTimecodeSection : IFileTimeSection, IMakeXmlSource Inheritance object FileTimecodeSection Implements IFileTimeSection IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) Extension Methods XmlUtil.MakeXmlSourceToFile(IMakeXmlSource, string, bool) XmlUtil.MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) XmlUtil.SaveToByteArrayAsync(IMakeXmlSource, string) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FileTimecodeSection() Initializes an empty instance. public FileTimecodeSection() FileTimecodeSection(FileTimecodeDateTimeSection) Projects a both-form (C) section onto its timecode form (independent copy). public FileTimecodeSection(FileTimecodeDateTimeSection c) Parameters c FileTimecodeDateTimeSection FileTimecodeSection(string, Range<TimeSpan>) Initializes from a file and a timecode range. public FileTimecodeSection(string file, Range<TimeSpan> timeRange) Parameters file string timeRange Range<TimeSpan> FileTimecodeSection(string, TimeSpan, TimeSpan) Initializes from a file and begin/end timecodes. public FileTimecodeSection(string file, TimeSpan beginTimecode, TimeSpan endTimecode) Parameters file string beginTimecode TimeSpan endTimecode TimeSpan FileTimecodeSection(XElement) Initializes from XML; accepts new BeginTimecode and legacy BeginTime / BeginTime_s. public FileTimecodeSection(XElement src) Parameters src XElement Fields LegacyXName Legacy element name; pre-rename projects wrote <FileTimeSection> for this form. public const string LegacyXName = \"FileTimeSection\" Field Value string Properties BeginTimecode Window start as a timecode (position from run start). public TimeSpan BeginTimecode { get; set; } Property Value TimeSpan EndTimecode Window end as a timecode (position from run start). public TimeSpan EndTimecode { get; set; } Property Value TimeSpan File Relative path of the referenced (sensor) file. public string File { get; set; } Property Value string TimeRange The timecode range backing BeginTimecode / EndTimecode. public Range<TimeSpan> TimeRange { get; set; } Property Value Range<TimeSpan> XName XML element name for XFactory registration. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type (and its legacy element name) with the factory. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Mappings.IFileTimeSection.html": {
    "href": "api/Hi.Mappings.IFileTimeSection.html",
    "title": "Interface IFileTimeSection | HiAPI-C# 2025",
    "summary": "Interface IFileTimeSection Namespace Hi.Mappings Assembly HiGeom.dll A file plus the time window of it that maps onto a range of machining steps. The window is expressed in whichever form the referenced sensor file uses — a relative TimeSpan timecode, an absolute DateTime, or both. Concrete forms: FileTimecodeSection (A), FileDateTimeSection (B), FileTimecodeDateTimeSection (C). These are pure data carriers — turning an absolute DateTime form into a relative timecode is done once at the mapping boundary against the project-scoped mapping anchor, not by a method here. public interface IFileTimeSection : IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods XmlUtil.MakeXmlSourceToFile(IMakeXmlSource, string, bool) XmlUtil.MakeXmlSourceToFileRef(IMakeXmlSource, string, string, bool) XmlUtil.SaveToByteArrayAsync(IMakeXmlSource, string) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties File Relative path of the referenced (sensor) file. string File { get; set; } Property Value string"
  },
  "api/Hi.Mappings.html": {
    "href": "api/Hi.Mappings.html",
    "title": "Namespace Hi.Mappings | HiAPI-C# 2025",
    "summary": "Namespace Hi.Mappings Classes FileDateTimeSection (B) Time window expressed in absolute DateTime only. FileTimecodeDateTimeSection (C) Time window carrying both forms. The timecode form is authoritative for mapping (timecode-first); the absolute form is retained for the anchor and for projecting to a single-form section (new FileTimecodeSection(c) / new FileDateTimeSection(c)) when the two forms do not agree. FileTimecodeSection (A) Time window expressed in relative TimeSpan timecodes only. Interfaces IFileTimeSection A file plus the time window of it that maps onto a range of machining steps. The window is expressed in whichever form the referenced sensor file uses — a relative TimeSpan timecode, an absolute DateTime, or both. Concrete forms: FileTimecodeSection (A), FileDateTimeSection (B), FileTimecodeDateTimeSection (C). These are pure data carriers — turning an absolute DateTime form into a relative timecode is done once at the mapping boundary against the project-scoped mapping anchor, not by a method here."
  },
  "api/Hi.Mech.GeneralMechanism.html": {
    "href": "api/Hi.Mech.GeneralMechanism.html",
    "title": "Class GeneralMechanism | HiAPI-C# 2025",
    "summary": "Class GeneralMechanism Namespace Hi.Mech Assembly HiMech.dll General Mechanism. public class GeneralMechanism : IMakeXmlSource, ITopo, IGetAsmb, IGetAnchoredDisplayeeList, IGetAnchorToSolidDictionary, IAnchoredDisplayee, IGetAnchor, IGetTopoIndex, IDisplayee, IExpandToBox3d Inheritance object GeneralMechanism Implements IMakeXmlSource ITopo IGetAsmb IGetAnchoredDisplayeeList IGetAnchorToSolidDictionary IAnchoredDisplayee IGetAnchor IGetTopoIndex IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) TopoDisplayeeUtil.Display(ITopo, Bind) TopoDisplayeeUtil.ExpandToBox3d(ITopo, Box3d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks The XML IO is according to self-contained principle. Constructors GeneralMechanism() Initializes a new instance of the GeneralMechanism class. public GeneralMechanism() GeneralMechanism(XElement, string, IProgress<IMessage>) Initializes a new instance of the GeneralMechanism class from XML. public GeneralMechanism(XElement src, string baseDirectory, IProgress<IMessage> progress) Parameters src XElement The XML element containing the mechanism data. baseDirectory string The base directory for resolving relative file paths. progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. Properties AnchorToSolid Gets the dictionary mapping anchors to their corresponding solids. public Dictionary<Anchor, Solid> AnchorToSolid { get; } Property Value Dictionary<Anchor, Solid> Asmb Gets the assembly containing the mechanism components. public Asmb Asmb { get; } Property Value Asmb Root Gets the root anchor of the mechanism. public Anchor Root { get; } Property Value Anchor XName Name for XML IO. public static string XName { get; } Property Value string Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor GetAnchorToSolidDictionary() Gets a dictionary that maps Anchor objects to their corresponding Solid objects. public Dictionary<Anchor, Solid> GetAnchorToSolidDictionary() Returns Dictionary<Anchor, Solid> A dictionary where keys are anchors and values are their associated solids. GetAnchoredDisplayeeList() Gets a list of anchored displayable objects. public List<IAnchoredDisplayee> GetAnchoredDisplayeeList() Returns List<IAnchoredDisplayee> A list of IAnchoredDisplayee objects GetAsmb() Gets the key asmb. public Asmb GetAsmb() Returns Asmb The key asmb. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Mech.IGetAnchorToSolidDictionary.html": {
    "href": "api/Hi.Mech.IGetAnchorToSolidDictionary.html",
    "title": "Interface IGetAnchorToSolidDictionary | HiAPI-C# 2025",
    "summary": "Interface IGetAnchorToSolidDictionary Namespace Hi.Mech Assembly HiMech.dll Provides functionality to retrieve a dictionary mapping anchors to their corresponding solids. public interface IGetAnchorToSolidDictionary Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetAnchorToSolidDictionary() Gets a dictionary that maps Anchor objects to their corresponding Solid objects. Dictionary<Anchor, Solid> GetAnchorToSolidDictionary() Returns Dictionary<Anchor, Solid> A dictionary where keys are anchors and values are their associated solids. PrepareAnchorSolids() Warms SmoothTopoStl3d for every solid returned by GetAnchorToSolidDictionary() (parallel). void PrepareAnchorSolids()"
  },
  "api/Hi.Mech.IGetMachiningChain.html": {
    "href": "api/Hi.Mech.IGetMachiningChain.html",
    "title": "Interface IGetMachiningChain | HiAPI-C# 2025",
    "summary": "Interface IGetMachiningChain Namespace Hi.Mech Assembly HiMech.dll Provides functionality to retrieve a machining chain instance. public interface IGetMachiningChain Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetMachiningChain() Gets the machining chain instance. IMachiningChain GetMachiningChain() Returns IMachiningChain The machining chain instance."
  },
  "api/Hi.Mech.IMachiningChain.html": {
    "href": "api/Hi.Mech.IMachiningChain.html",
    "title": "Interface IMachiningChain | HiAPI-C# 2025",
    "summary": "Interface IMachiningChain Namespace Hi.Mech Assembly HiMech.dll Represents a machining chain with two ends, connecting a tool and a workpiece. public interface IMachiningChain : IGetAsmb, IGetAnchor, IGetTopoIndex, IMakeXmlSource, IGetAnchorToSolidDictionary Inherited Members IGetAsmb.GetAsmb() IGetAnchor.GetAnchor() IMakeXmlSource.MakeXmlSource(string, string, bool) IGetAnchorToSolidDictionary.GetAnchorToSolidDictionary() IGetAnchorToSolidDictionary.PrepareAnchorSolids() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MachiningChainUtil.GetMcCodeTransformerDictionary(IMachiningChain) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties McCodes Gets the machine coordinate code sequence for decoding the MC array. string[] McCodes { get; } Property Value string[] McTransformers Gets the machine coordinate transformers. IDynamicRegular[] McTransformers { get; } Property Value IDynamicRegular[] Methods GetTableBuckle() Gets the table buckle anchor point. IGetAnchor GetTableBuckle() Returns IGetAnchor The table buckle anchor point. GetToolBuckle() Gets the tool buckle anchor point. IGetAnchor GetToolBuckle() Returns IGetAnchor The tool buckle anchor point."
  },
  "api/Hi.Mech.IMachiningChainSource.html": {
    "href": "api/Hi.Mech.IMachiningChainSource.html",
    "title": "Interface IMachiningChainSource | HiAPI-C# 2025",
    "summary": "Interface IMachiningChainSource Namespace Hi.Mech Assembly HiMech.dll Provides XML serialization/deserialization capabilities for IMachiningChain objects. public interface IMachiningChainSource : IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetMachiningChain() Gets the machining chain instance. IMachiningChain GetMachiningChain() Returns IMachiningChain The machining chain instance."
  },
  "api/Hi.Mech.MachiningChainUtil.html": {
    "href": "api/Hi.Mech.MachiningChainUtil.html",
    "title": "Class MachiningChainUtil | HiAPI-C# 2025",
    "summary": "Class MachiningChainUtil Namespace Hi.Mech Assembly HiMech.dll Utility methods for machining chains. public static class MachiningChainUtil Inheritance object MachiningChainUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetMcCodeTransformerDictionary(IMachiningChain) Get code to IDynamicRegular dictionary. public static Dictionary<string, IDynamicRegular> GetMcCodeTransformerDictionary(this IMachiningChain chain) Parameters chain IMachiningChain Returns Dictionary<string, IDynamicRegular> code to IDynamicRegular dictionary"
  },
  "api/Hi.Mech.Topo.Anchor.html": {
    "href": "api/Hi.Mech.Topo.Anchor.html",
    "title": "Class Anchor | HiAPI-C# 2025",
    "summary": "Class Anchor Namespace Hi.Mech.Topo Assembly HiMech.dll A coordinate system using in kinematic chain. public class Anchor : IAnchoredDisplayee, IGetAnchor, IGetTopoIndex, IDisplayee, IExpandToBox3d Inheritance object Anchor Implements IAnchoredDisplayee IGetAnchor IGetTopoIndex IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Anchor() Ctor. public Anchor() Anchor(Asmb) Ctor. public Anchor(Asmb asmb) Parameters asmb Asmb add this to asmb.ChildAncs Anchor(Asmb, string) Ctor. public Anchor(Asmb asmb, string name) Parameters asmb Asmb add this to asmb.ChildAncs name string Name Properties BranchMap Gets the branch map. ‘this’ anchor locates on Fletch . public Dictionary<Anchor, Branch> BranchMap { get; } Property Value Dictionary<Anchor, Branch> The branch map. BranchMapInv Gets the branch map. ‘this’ anchor locates on Arrow . public Dictionary<Anchor, Branch> BranchMapInv { get; } Property Value Dictionary<Anchor, Branch> The branch map. Guid GUID. public Guid Guid { get; } Property Value Guid IndexXName The XML element name used for indexing anchors. public static string IndexXName { get; } Property Value string IndexXml Get XML for indexing. Only the Guid takes effect when reading. public XElement IndexXml { get; } Property Value XElement The XML contains Name and Guid. Name Name. public string Name { get; set; } Property Value string Methods Detach() Detach all related Branch. public void Detach() Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public virtual void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor GetByIndexXml(XElement, Dictionary<Guid, Anchor>) Gets an anchor from its XML index representation using a GUID-to-Anchor dictionary. public static Anchor GetByIndexXml(XElement src, Dictionary<Guid, Anchor> guidToAncDictionary) Parameters src XElement The source XML element containing the anchor index information. guidToAncDictionary Dictionary<Guid, Anchor> Dictionary mapping GUIDs to Anchor objects. Returns Anchor The anchor object corresponding to the XML index. GetClusterAnchors() Gets all the linked anchors by Branch. public HashSet<Anchor> GetClusterAnchors() Returns HashSet<Anchor> GetMat4d(IGetAnchor) Get transform matrix from this to tail. public Mat4d GetMat4d(IGetAnchor tail) Parameters tail IGetAnchor tail Returns Mat4d transform matrix GetMat4dMap() Gets the mat4d map in GetClusterAnchors() public Dictionary<Anchor, Mat4d> GetMat4dMap() Returns Dictionary<Anchor, Mat4d> GetNeighborAnchorList() Get neighbor anchors. public List<Anchor> GetNeighborAnchorList() Returns List<Anchor> neighbor anchors GetNeighborAnchorSet() Get neighbor anchors. public HashSet<Anchor> GetNeighborAnchorSet() Returns HashSet<Anchor> neighbor anchors ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Mech.Topo.AnchorFuncSource.html": {
    "href": "api/Hi.Mech.Topo.AnchorFuncSource.html",
    "title": "Class AnchorFuncSource | HiAPI-C# 2025",
    "summary": "Class AnchorFuncSource Namespace Hi.Mech.Topo Assembly HiMech.dll Provides an anchor through a function delegate. public class AnchorFuncSource : IGetAnchor, IGetTopoIndex Inheritance object AnchorFuncSource Implements IGetAnchor IGetTopoIndex Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors AnchorFuncSource() Initializes a new instance of the AnchorFuncSource class. public AnchorFuncSource() AnchorFuncSource(Func<Anchor>) Initializes a new instance of the AnchorFuncSource class with the specified anchor function. public AnchorFuncSource(Func<Anchor> anchorFunc) Parameters anchorFunc Func<Anchor> The function that returns an anchor. Properties AnchorFunc Gets or sets the function that returns an anchor. public Func<Anchor> AnchorFunc { get; set; } Property Value Func<Anchor> Methods GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor"
  },
  "api/Hi.Mech.Topo.AnchoredBoxable.html": {
    "href": "api/Hi.Mech.Topo.AnchoredBoxable.html",
    "title": "Class AnchoredBoxable | HiAPI-C# 2025",
    "summary": "Class AnchoredBoxable Namespace Hi.Mech.Topo Assembly HiMech.dll Represents an object that is both anchored to a root point and can expand to a 3D box. public class AnchoredBoxable : IGetAnchor, IGetTopoIndex, IExpandToBox3d Inheritance object AnchoredBoxable Implements IGetAnchor IGetTopoIndex IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors AnchoredBoxable() Initializes a new instance of the AnchoredBoxable class. public AnchoredBoxable() AnchoredBoxable(IGetAnchor, IExpandToBox3d) Initializes a new instance of the AnchoredBoxable class with the specified anchor and boxable object. public AnchoredBoxable(IGetAnchor anchor, IExpandToBox3d boxable) Parameters anchor IGetAnchor The object that provides the root anchor. boxable IExpandToBox3d The object that can expand to a 3D box. Properties Anchor Gets or sets the anchor point. public Anchor Anchor { get; set; } Property Value Anchor Boxable Gets or sets the boxable object that can expand to a 3D box. public IExpandToBox3d Boxable { get; set; } Property Value IExpandToBox3d Methods ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor"
  },
  "api/Hi.Mech.Topo.AnchoredDisplayee.html": {
    "href": "api/Hi.Mech.Topo.AnchoredDisplayee.html",
    "title": "Class AnchoredDisplayee | HiAPI-C# 2025",
    "summary": "Class AnchoredDisplayee Namespace Hi.Mech.Topo Assembly HiMech.dll Represents a displayable object that is anchored to a specific point in a topology. public class AnchoredDisplayee : IAnchoredDisplayee, IDisplayee, IExpandToBox3d, IGetAnchor, IGetTopoIndex Inheritance object AnchoredDisplayee Implements IAnchoredDisplayee IDisplayee IExpandToBox3d IGetAnchor IGetTopoIndex Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors AnchoredDisplayee() Initializes a new instance of the AnchoredDisplayee class. public AnchoredDisplayee() AnchoredDisplayee(IGetAnchor, IDisplayee) Initializes a new instance of the AnchoredDisplayee class with the specified anchor and displayee. public AnchoredDisplayee(IGetAnchor anchor, IDisplayee displayee) Parameters anchor IGetAnchor The object that provides the anchor. displayee IDisplayee The displayable object. Properties AnchorSource Gets or sets the source of the anchor. public IGetAnchor AnchorSource { get; set; } Property Value IGetAnchor Displayee Gets or sets the displayable object. public IDisplayee Displayee { get; set; } Property Value IDisplayee Methods Display(Bind) Displays this object using the specified binding. public void Display(Bind bind) Parameters bind Bind The binding to use for display. ExpandToBox3d(Box3d) Expands the specified box to include this object. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d The box to expand. GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor"
  },
  "api/Hi.Mech.Topo.Asmb.html": {
    "href": "api/Hi.Mech.Topo.Asmb.html",
    "title": "Class Asmb | HiAPI-C# 2025",
    "summary": "Class Asmb Namespace Hi.Mech.Topo Assembly HiMech.dll Collection of Anchor and Asmb. public class Asmb : IGetAsmb, IGetTopoIndex, IDisposable Inheritance object Asmb Implements IGetAsmb IGetTopoIndex IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Asmb() Ctor. public Asmb() Asmb(Asmb) Ctor. public Asmb(Asmb parent) Parameters parent Asmb parent Asmb(Asmb, string) Ctor. public Asmb(Asmb parent, string name) Parameters parent Asmb parent name string Name Asmb(string) Ctor. public Asmb(string name) Parameters name string Name Properties ChildAncs Gets the collection of child anchors in this assembly. public ThreadSafeSet<Anchor> ChildAncs { get; } Property Value ThreadSafeSet<Anchor> ChildAsmbs Gets the collection of child assemblies in this assembly. public ThreadSafeSet<Asmb> ChildAsmbs { get; } Property Value ThreadSafeSet<Asmb> Guid GUID. public Guid Guid { get; } Property Value Guid Name Name. public string Name { get; set; } Property Value string XName Gets the XML name for the assembly. public static string XName { get; } Property Value string Methods AllEnterReadLock() Enters read locks for all thread-safe collections in the assembly. public void AllEnterReadLock() AllExitReadLock() Exits read locks for all thread-safe collections in the assembly. public void AllExitReadLock() CallAsmb(XElement, string, Dictionary<Guid, Asmb>, Dictionary<Guid, Anchor>, Dictionary<Guid, Branch>, IProgress<IMessage>) Get asmb by the asmbXml. If the members of the target asmb do not exist on asmbs or ancs, the members will be generated; otherwise, the existed members are applied. public static Asmb CallAsmb(XElement asmbXml, string baseDirectory, Dictionary<Guid, Asmb> asmbs = null, Dictionary<Guid, Anchor> ancs = null, Dictionary<Guid, Branch> brns = null, IProgress<IMessage> progress = null) Parameters asmbXml XElement xml of asmb baseDirectory string Base directory path for resolving relative paths asmbs Dictionary<Guid, Asmb> existed asmb map ancs Dictionary<Guid, Anchor> existed anc map brns Dictionary<Guid, Branch> existed branch map progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. Returns Asmb asmb Display(Bind, Anchor, params IGetAnchor[]) Display displayees according to the GetAnchor(). The fixed anchor is root. If the element of displayees is not IDisplayee or null Anchor, the element will be ignored. public void Display(Bind bind, Anchor root, params IGetAnchor[] displayees) Parameters bind Bind bind root Anchor fixed anchor displayees IGetAnchor[] element to be rendered Display(Bind, Dictionary<Anchor, Mat4d>, params IGetAnchor[]) Display the displayees according to map. If displayees is null, do nothing. public static void Display(Bind bind, Dictionary<Anchor, Mat4d> map, params IGetAnchor[] displayees) Parameters bind Bind bind map Dictionary<Anchor, Mat4d> anchor to transformation map displayees IGetAnchor[] displayees Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToBox3d(Box3d, Anchor, params IGetAnchor[]) Expands a bounding box to include the assembly. public void ExpandToBox3d(Box3d dst, Anchor root, params IGetAnchor[] displayees) Parameters dst Box3d The bounding box to expand. root Anchor The root anchor for the calculation. displayees IGetAnchor[] The displayable objects to include in the calculation. GetAnchorByGuid(string, bool) Finds an anchor in the assembly hierarchy by its GUID. public Anchor GetAnchorByGuid(string guid, bool enableThreadSafe = true) Parameters guid string The GUID of the anchor to find. enableThreadSafe bool If true, uses thread-safe operations for accessing collections. Returns Anchor The anchor with the specified GUID, or null if not found. GetAnchorChain(Anchor, Anchor) Gets a chain of anchors from the head to the tail. public List<Anchor> GetAnchorChain(Anchor head, Anchor tail) Parameters head Anchor The starting anchor of the chain. tail Anchor The ending anchor of the chain. Returns List<Anchor> A list of anchors representing the chain, or an empty list if no chain exists. GetAnchoredDisplayeeList(Dictionary<Anchor, Solid>) Gets a list of anchored displayable objects based on the provided anchor-to-solid mapping. public List<IAnchoredDisplayee> GetAnchoredDisplayeeList(Dictionary<Anchor, Solid> anchorToSolidDictionary) Parameters anchorToSolidDictionary Dictionary<Anchor, Solid> Dictionary mapping anchors to their corresponding solids. Returns List<IAnchoredDisplayee> A list of anchored displayable objects. GetAsmb() Gets the key asmb. public Asmb GetAsmb() Returns Asmb The key asmb. GetAsmbDraw(Anchor) Gets an assembly drawing for visualization. public AsmbDraw GetAsmbDraw(Anchor root) Parameters root Anchor The root anchor for the drawing. Returns AsmbDraw An assembly drawing object. GetBox3d(Anchor, params IGetAnchor[]) Gets a bounding box for the assembly. public Box3d GetBox3d(Anchor root, params IGetAnchor[] displayees) Parameters root Anchor The root anchor for the calculation. displayees IGetAnchor[] The displayable objects to include in the calculation. Returns Box3d A 3D bounding box containing the assembly. GetBranchByGuid(string, bool) Finds a branch in the assembly hierarchy by its GUID. public Branch GetBranchByGuid(string guid, bool enableThreadSafe = true) Parameters guid string The GUID of the branch to find. enableThreadSafe bool If true, uses thread-safe operations for accessing collections. Returns Branch The branch with the specified GUID, or null if not found. GetBranchChain(IGetAnchor, IGetAnchor) Gets a chain of branches with their directions from the head anchor to the tail anchor. public List<DirectionBranchEntry> GetBranchChain(IGetAnchor head, IGetAnchor tail) Parameters head IGetAnchor The starting anchor of the chain. tail IGetAnchor The ending anchor of the chain. Returns List<DirectionBranchEntry> A list of direction-branch pairs representing the chain, or an empty list if no chain exists. GetBranchsXml(IGetAnchor, string) Gets the XML representation of all branches in the assembly starting from the specified root. public XElement GetBranchsXml(IGetAnchor root, string baseDirectory) Parameters root IGetAnchor The root anchor to start from. If null, uses the first descendant anchor. baseDirectory string The base directory for file references. Returns XElement An XML element containing all branches in the assembly. GetDescendantAnchorSet(bool) Generate an anchor set from all descendant anchors. public HashSet<Anchor> GetDescendantAnchorSet(bool enableThreadSafe = true) Parameters enableThreadSafe bool Returns HashSet<Anchor> descendant anchor set GetDescendantAnchors(bool) Gets a list of all descendant anchors in the assembly hierarchy. public List<Anchor> GetDescendantAnchors(bool enableThreadSafe = true) Parameters enableThreadSafe bool If true, uses thread-safe operations for accessing collections. Returns List<Anchor> A list of all descendant anchors. GetDescendantAsmbSet(bool) Gets a set of all descendant assemblies in the assembly hierarchy. public HashSet<Asmb> GetDescendantAsmbSet(bool enableThreadSafe = true) Parameters enableThreadSafe bool If true, uses thread-safe operations for accessing collections. Returns HashSet<Asmb> A set of all descendant assemblies. GetDescendantAsmbs(bool) Gets a list of all descendant assemblies in the assembly hierarchy. public List<Asmb> GetDescendantAsmbs(bool enableThreadSafe = true) Parameters enableThreadSafe bool If true, uses thread-safe operations for accessing collections. Returns List<Asmb> A list of all descendant assemblies. GetDescendingName(Anchor) Gets the descending name path for an anchor, combining assembly names with dashes. public string GetDescendingName(Anchor anc) Parameters anc Anchor The anchor to get the descending name for. Returns string The full descending name path, or null if the anchor is not found in the assembly hierarchy. GetDescendingName(Asmb) Gets the descending name path for a child assembly, combining assembly names with dashes. public string GetDescendingName(Asmb asmb) Parameters asmb Asmb The assembly to get the descending name for. Returns string The full descending name path, or null if the assembly is not found in the hierarchy. GetHierarchyString() Gets a string representation of the assembly hierarchy. public string GetHierarchyString() Returns string A string describing the assembly hierarchy. GetInnerBranchSet(bool) Gets a set of branches that are internal to this assembly. A branch is considered internal if both its endpoints are anchors within this assembly. public HashSet<Branch> GetInnerBranchSet(bool enableThreadSafe = true) Parameters enableThreadSafe bool If true, uses thread-safe operations for accessing collections. Returns HashSet<Branch> A set of internal branches. GetMat4d(IGetAnchor, IGetAnchor) Gets the transformation matrix between two anchors in the assembly. public Mat4d GetMat4d(IGetAnchor root, IGetAnchor tail) Parameters root IGetAnchor The source anchor for the transformation. tail IGetAnchor The target anchor for the transformation. Returns Mat4d The 4x4 transformation matrix from root to tail. GetMat4dMap(IGetAnchor) Gets a mapping of anchors to their transformation matrices relative to the root anchor. public Dictionary<Anchor, Mat4d> GetMat4dMap(IGetAnchor root) Parameters root IGetAnchor The root anchor to calculate transformations from. Returns Dictionary<Anchor, Mat4d> A dictionary mapping anchors to their transformation matrices. GetMat4dMapWithBlocks(IGetAnchor, params Anchor[]) Gets a mapping of anchors to their transformation matrices relative to the root anchor, excluding specified blocked anchors. public Dictionary<Anchor, Mat4d> GetMat4dMapWithBlocks(IGetAnchor root, params Anchor[] blockeds) Parameters root IGetAnchor The root anchor to calculate transformations from. blockeds Anchor[] Array of anchors to exclude from the calculation. Returns Dictionary<Anchor, Mat4d> A dictionary mapping anchors to their transformation matrices. ShowMat4dMap(Dictionary<Anchor, Mat4d>) Show mat map in text on console. public static void ShowMat4dMap(Dictionary<Anchor, Mat4d> map) Parameters map Dictionary<Anchor, Mat4d> ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. ToXElement(IGetAnchor, string) Converts the assembly to an XML element. public XElement ToXElement(IGetAnchor root, string baseDirectory) Parameters root IGetAnchor The root anchor for the conversion. baseDirectory string The base directory for file references. Returns XElement An XML element representing the assembly. ToXElement(string) Converts the assembly to an XML element. public XElement ToXElement(string baseDirectory) Parameters baseDirectory string The base directory for file references. Returns XElement An XML element representing the assembly."
  },
  "api/Hi.Mech.Topo.AsmbDraw.html": {
    "href": "api/Hi.Mech.Topo.AsmbDraw.html",
    "title": "Class AsmbDraw | HiAPI-C# 2025",
    "summary": "Class AsmbDraw Namespace Hi.Mech.Topo Assembly HiMech.dll Render all Anchors of the Asmb in form of CoordinateDrawing. public class AsmbDraw : IDisplayee, IExpandToBox3d Inheritance object AsmbDraw Implements IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors AsmbDraw(Asmb, Anchor) Ctor. public AsmbDraw(Asmb asmb, Anchor root) Parameters asmb Asmb asmb root Anchor fixed anchor Properties Asmb Asmb. public Asmb Asmb { get; set; } Property Value Asmb Root Fixed anchor. public Anchor Root { get; set; } Property Value Anchor Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box"
  },
  "api/Hi.Mech.Topo.Branch.html": {
    "href": "api/Hi.Mech.Topo.Branch.html",
    "title": "Class Branch | HiAPI-C# 2025",
    "summary": "Class Branch Namespace Hi.Mech.Topo Assembly HiMech.dll The linkage between two Anchor objects. public class Branch Inheritance object Branch Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Arrow Anchor from arrow side. public Anchor Arrow { get; } Property Value Anchor Fletch Anchor from fletch side. public Anchor Fletch { get; } Property Value Anchor Guid GUID. public Guid Guid { get; } Property Value Guid IsBreak Is break. public bool IsBreak { get; } Property Value bool Name Gets or sets the name of the branch. public string Name { get; set; } Property Value string Step If the Transformer is IDynamicRegular, the property is delegated from IDynamicRegular.Step; otherwise, the getter returns NAN and setter does nothing. public double Step { get; set; } Property Value double Transformer Transformer. public ITransformer Transformer { get; set; } Property Value ITransformer Methods Attach(IGetAnchor, IGetAnchor) Attempts to attach two anchors. public static Branch Attach(IGetAnchor fletch, IGetAnchor arrow) Parameters fletch IGetAnchor See Fletch arrow IGetAnchor See Arrow Returns Branch branch Attach(IGetAnchor, IGetAnchor, ITransformer) Attempts to attach two anchors with a specified transformer. public static Branch Attach(IGetAnchor fletch, IGetAnchor arrow, ITransformer transformer) Parameters fletch IGetAnchor See Fletch arrow IGetAnchor See Arrow transformer ITransformer See Transformer Returns Branch branch AttachIfAbsence(IGetAnchor, IGetAnchor) Attempts to attach two anchors if they are not already connected. If the anchors are already connected, returns null instead of throwing an exception. public static Branch AttachIfAbsence(IGetAnchor fletch, IGetAnchor arrow) Parameters fletch IGetAnchor The fletch-side anchor to attach arrow IGetAnchor The arrow-side anchor to attach Returns Branch The newly created branch if successful, null if the anchors are already connected Detach() Break the branch. public void Detach() Detach(IGetAnchor, IGetAnchor) Break the branch from Get(IGetAnchor, IGetAnchor). public static void Detach(IGetAnchor fletch, IGetAnchor arrow) Parameters fletch IGetAnchor See Fletch arrow IGetAnchor See Arrow Exceptions InvalidOperationException The exception is throwed if the Branch is not existed. DetachIfExisted(IGetAnchor, IGetAnchor) Break the branch from Get(IGetAnchor, IGetAnchor). public static bool DetachIfExisted(IGetAnchor fletch, IGetAnchor arrow) Parameters fletch IGetAnchor See Fletch arrow IGetAnchor See Arrow Returns bool true if the Branch existed and then been deteched. Get(IGetAnchor, IGetAnchor) Get existed Branch by fletchSource and arrowSource. public static Branch Get(IGetAnchor fletchSource, IGetAnchor arrowSource) Parameters fletchSource IGetAnchor fletch arrowSource IGetAnchor arrow Returns Branch The branch. If branch not exist, return null. IsExisted(IGetAnchor, IGetAnchor) Checks if a branch exists between two anchors. public static bool IsExisted(IGetAnchor fletch, IGetAnchor arrow) Parameters fletch IGetAnchor The fletch-side anchor. arrow IGetAnchor The arrow-side anchor. Returns bool True if a branch exists between the anchors, false otherwise. ToLinkString() Get brief link description. public string ToLinkString() Returns string ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. TryAttach(IGetAnchor, IGetAnchor, ITransformer) Attempts to attach two anchors with a specified transformer. If the attachment fails, returns null instead of throwing an exception. public static Branch TryAttach(IGetAnchor fletch, IGetAnchor arrow, ITransformer transformer) Parameters fletch IGetAnchor The fletch-side anchor to attach arrow IGetAnchor The arrow-side anchor to attach transformer ITransformer The transformer to use for the branch Returns Branch The newly created branch if successful, null if the attachment fails"
  },
  "api/Hi.Mech.Topo.DirectionBranchEntry.html": {
    "href": "api/Hi.Mech.Topo.DirectionBranchEntry.html",
    "title": "Class DirectionBranchEntry | HiAPI-C# 2025",
    "summary": "Class DirectionBranchEntry Namespace Hi.Mech.Topo Assembly HiMech.dll A data pack contains Branch and a boolean isForward. public class DirectionBranchEntry Inheritance object DirectionBranchEntry Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors DirectionBranchEntry(bool, Branch) Ctor. public DirectionBranchEntry(bool isForward, Branch brn) Parameters isForward bool is forward brn Branch branch Fields brn A branch. public Branch brn Field Value Branch isForward Is forward. public bool isForward Field Value bool Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Mech.Topo.DirectionBranchPackUtil.html": {
    "href": "api/Hi.Mech.Topo.DirectionBranchPackUtil.html",
    "title": "Class DirectionBranchPackUtil | HiAPI-C# 2025",
    "summary": "Class DirectionBranchPackUtil Namespace Hi.Mech.Topo Assembly HiMech.dll Utility of topology. public static class DirectionBranchPackUtil Inheritance object DirectionBranchPackUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetMat4d(IEnumerable<DirectionBranchEntry>) Get the transformation matrix. The transformation matrix is obtained by mat(n-1)*...*mat(1)*mat(0). Where the number in parentheses is the index number of the chain. public static Mat4d GetMat4d(this IEnumerable<DirectionBranchEntry> chain) Parameters chain IEnumerable<DirectionBranchEntry> chain Returns Mat4d transformation matrix"
  },
  "api/Hi.Mech.Topo.DynamicFreeform.html": {
    "href": "api/Hi.Mech.Topo.DynamicFreeform.html",
    "title": "Class DynamicFreeform | HiAPI-C# 2025",
    "summary": "Class DynamicFreeform Namespace Hi.Mech.Topo Assembly HiMech.dll Dynamic Freeform transformer. public class DynamicFreeform : IDynamicTransformer, ITransformer, IMakeXmlSource, IGetInverseTransformer, IToPresentDto Inheritance object DynamicFreeform Implements IDynamicTransformer ITransformer IMakeXmlSource IGetInverseTransformer IToPresentDto Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors DynamicFreeform(Mat4d) Ctor. public DynamicFreeform(Mat4d mat) Parameters mat Mat4d transform matrix DynamicFreeform(Mat4d, Mat4d) Ctor. public DynamicFreeform(Mat4d mat, Mat4d matInv) Parameters mat Mat4d transform matrix matInv Mat4d inversed transform matrix DynamicFreeform(XElement) Ctor. public DynamicFreeform(XElement src) Parameters src XElement XML Properties XName Static name. public static string XName { get; } Property Value string Methods Clone() Clones this instance. public ITransformer Clone() Returns ITransformer clone GetInverseTransformer() Gets the inverse transformer of this transformer. public ITransformer GetInverseTransformer() Returns ITransformer The inverse transformer. GetMat() Gets the transform matrix. public Mat4d GetMat() Returns Mat4d The transform matrix. GetMatInv() Gets the inverse transform matrix. public Mat4d GetMatInv() Returns Mat4d The inverse transform matrix. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public virtual XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetMat(Mat4d) public void SetMat(Mat4d mat) Parameters mat Mat4d SetMat(Mat4d, Mat4d) Set transform matrix. public void SetMat(Mat4d mat, Mat4d matInv) Parameters mat Mat4d transform matrix matInv Mat4d inversed transform matrix ToPresentDto() Convert to a static-freeform matrix snapshot DTO (Data Transfer Object) for JSON serialization; presented with the StaticFreeform type marker. public object ToPresentDto() Returns object DTO dictionary with Type and Matrix keys"
  },
  "api/Hi.Mech.Topo.DynamicRotation.html": {
    "href": "api/Hi.Mech.Topo.DynamicRotation.html",
    "title": "Class DynamicRotation | HiAPI-C# 2025",
    "summary": "Class DynamicRotation Namespace Hi.Mech.Topo Assembly HiMech.dll Dynamic rotate transformer. public class DynamicRotation : IDynamicRotation, IDynamicRegular, IDynamicTransformer, ITransformer, IMakeXmlSource, IGetInverseTransformer, IToPresentDto Inheritance object DynamicRotation Implements IDynamicRotation IDynamicRegular IDynamicTransformer ITransformer IMakeXmlSource IGetInverseTransformer IToPresentDto Derived NcRotation Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors DynamicRotation() Ctor. public DynamicRotation() DynamicRotation(Vec3d, double, Vec3d) Ctor. public DynamicRotation(Vec3d axis, double angle_rad = 0, Vec3d pivot = null) Parameters axis Vec3d Axis angle_rad double Angle_rad pivot Vec3d Pivot DynamicRotation(XElement) Ctor. public DynamicRotation(XElement src) Parameters src XElement XML Properties Angle_deg Rotation angle in degree. public double Angle_deg { get; set; } Property Value double Angle_rad Rotation angle in radian. public double Angle_rad { get; set; } Property Value double Axis Rotation axis. public Vec3d Axis { get; set; } Property Value Vec3d Pivot pivot public Vec3d Pivot { get; set; } Property Value Vec3d Step Gets or sets the step. public double Step { get; set; } Property Value double The step. XName Static name. public static string XName { get; } Property Value string Methods Clone() Clones this instance. public virtual ITransformer Clone() Returns ITransformer clone GetInverseTransformer() Gets the inverse transformer of this transformer. public ITransformer GetInverseTransformer() Returns ITransformer The inverse transformer. GetMat() Gets the transform matrix. public Mat4d GetMat() Returns Mat4d The transform matrix. GetMatInv() Gets the inverse transform matrix. public Mat4d GetMatInv() Returns Mat4d The inverse transform matrix. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public virtual XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Set(DynamicRotation) Copy from src. public void Set(DynamicRotation src) Parameters src DynamicRotation src ToPresentDto() Convert DynamicRotation to presentation DTO (Data Transfer Object) for JSON serialization. The returned object includes type metadata for web API presentation. public object ToPresentDto() Returns object DTO dictionary with Type, Axis, Angle_deg, and Pivot keys"
  },
  "api/Hi.Mech.Topo.DynamicTranslation.html": {
    "href": "api/Hi.Mech.Topo.DynamicTranslation.html",
    "title": "Class DynamicTranslation | HiAPI-C# 2025",
    "summary": "Class DynamicTranslation Namespace Hi.Mech.Topo Assembly HiMech.dll Dynamic translate transformer public class DynamicTranslation : IDynamicRegular, IDynamicTransformer, ITransformer, IMakeXmlSource, IGetInverseTransformer, IToPresentDto Inheritance object DynamicTranslation Implements IDynamicRegular IDynamicTransformer ITransformer IMakeXmlSource IGetInverseTransformer IToPresentDto Derived NcTranslation Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors DynamicTranslation() Ctor. public DynamicTranslation() DynamicTranslation(Vec3d, double) Ctor. public DynamicTranslation(Vec3d axis, double len = 0) Parameters axis Vec3d Translation axis len double length DynamicTranslation(XElement) Ctor. public DynamicTranslation(XElement src) Parameters src XElement XML Properties Axis Translation Axis. public Vec3d Axis { get; set; } Property Value Vec3d Len Length. public double Len { get; set; } Property Value double Step Gets or sets the step. public double Step { get; set; } Property Value double The step. XName Static name. public static string XName { get; } Property Value string Methods Clone() Clones this instance. public virtual ITransformer Clone() Returns ITransformer clone GetInverseTransformer() Gets the inverse transformer of this transformer. public ITransformer GetInverseTransformer() Returns ITransformer The inverse transformer. GetMat() Gets the transform matrix. public Mat4d GetMat() Returns Mat4d The transform matrix. GetMatInv() Gets the inverse transform matrix. public Mat4d GetMatInv() Returns Mat4d The inverse transform matrix. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public virtual XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Set(DynamicTranslation) Copy from src. public void Set(DynamicTranslation src) Parameters src DynamicTranslation src ToPresentDto() Convert DynamicTranslation to presentation DTO (Data Transfer Object) for JSON serialization. The returned object includes type metadata for web API presentation. public object ToPresentDto() Returns object DTO dictionary with Type, Axis, and Step keys"
  },
  "api/Hi.Mech.Topo.GeneralTransform.html": {
    "href": "api/Hi.Mech.Topo.GeneralTransform.html",
    "title": "Class GeneralTransform | HiAPI-C# 2025",
    "summary": "Class GeneralTransform Namespace Hi.Mech.Topo Assembly HiMech.dll Represents a general transformation that combines scaling, rotation, and translation. public class GeneralTransform : IStaticTransformer, ITransformer, IMakeXmlSource, IGetInverseTransformer, IToPresentDto Inheritance object GeneralTransform Implements IStaticTransformer ITransformer IMakeXmlSource IGetInverseTransformer IToPresentDto Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors GeneralTransform() Initializes a new instance of the GeneralTransform class. public GeneralTransform() GeneralTransform(Mat4d) Initializes a new instance of the GeneralTransform class from a 4x4 transformation matrix. public GeneralTransform(Mat4d mat) Parameters mat Mat4d The transformation matrix. GeneralTransform(double, StaticRotation, StaticTranslation) Initializes a new instance of the GeneralTransform class with specified scale, rotation, and translation. public GeneralTransform(double scale, StaticRotation rotation, StaticTranslation translation) Parameters scale double The scaling factor. rotation StaticRotation The rotation transformation. translation StaticTranslation The translation transformation. GeneralTransform(XElement) Ctor. public GeneralTransform(XElement src) Parameters src XElement XML Properties Rotation 2th transform. public StaticRotation Rotation { get; } Property Value StaticRotation Scale 1th transform. public double Scale { get; set; } Property Value double Translation 3th transform. public StaticTranslation Translation { get; } Property Value StaticTranslation XName Static name. public static string XName { get; } Property Value string Methods Clone() Clones this instance. public ITransformer Clone() Returns ITransformer clone GetInverseTransformer() Gets the inverse transformer of this transformer. public ITransformer GetInverseTransformer() Returns ITransformer The inverse transformer. GetMat() Gets the transform matrix. public Mat4d GetMat() Returns Mat4d The transform matrix. GetMatInv() Gets the inverse transform matrix. public Mat4d GetMatInv() Returns Mat4d The inverse transform matrix. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public virtual XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToPresentDto() Convert GeneralTransform to presentation DTO (Data Transfer Object) for JSON serialization. The returned object includes type metadata for web API presentation. public object ToPresentDto() Returns object DTO dictionary with Type, Scale, Rotation, and Translation keys"
  },
  "api/Hi.Mech.Topo.IAnchoredDisplayee.html": {
    "href": "api/Hi.Mech.Topo.IAnchoredDisplayee.html",
    "title": "Interface IAnchoredDisplayee | HiAPI-C# 2025",
    "summary": "Interface IAnchoredDisplayee Namespace Hi.Mech.Topo Assembly HiMech.dll Interface for objects that can be displayed and are anchored to a root point in a topology. public interface IAnchoredDisplayee : IGetAnchor, IGetTopoIndex, IDisplayee, IExpandToBox3d Inherited Members IGetAnchor.GetAnchor() IDisplayee.Display(Bind) IExpandToBox3d.ExpandToBox3d(Box3d) Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Mech.Topo.IDynamicRegular.html": {
    "href": "api/Hi.Mech.Topo.IDynamicRegular.html",
    "title": "Interface IDynamicRegular | HiAPI-C# 2025",
    "summary": "Interface IDynamicRegular Namespace Hi.Mech.Topo Assembly HiMech.dll Dynamic Regular Transformer public interface IDynamicRegular : IDynamicTransformer, ITransformer, IMakeXmlSource, IToPresentDto Inherited Members ITransformer.GetMat() ITransformer.GetMatInv() ITransformer.Clone() IMakeXmlSource.MakeXmlSource(string, string, bool) IToPresentDto.ToPresentDto() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Step Gets or sets the step. double Step { get; set; } Property Value double The step."
  },
  "api/Hi.Mech.Topo.IDynamicRotation.html": {
    "href": "api/Hi.Mech.Topo.IDynamicRotation.html",
    "title": "Interface IDynamicRotation | HiAPI-C# 2025",
    "summary": "Interface IDynamicRotation Namespace Hi.Mech.Topo Assembly HiMech.dll Topology joint that applies a single-axis rotation about Pivot by Angle_rad. public interface IDynamicRotation : IDynamicRegular, IDynamicTransformer, ITransformer, IMakeXmlSource, IGetInverseTransformer, IToPresentDto Inherited Members IDynamicRegular.Step ITransformer.GetMat() ITransformer.GetMatInv() ITransformer.Clone() IMakeXmlSource.MakeXmlSource(string, string, bool) IGetInverseTransformer.GetInverseTransformer() IToPresentDto.ToPresentDto() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Angle_deg Rotation angle in degree. double Angle_deg { get; set; } Property Value double Angle_rad Rotation angle in radian. double Angle_rad { get; set; } Property Value double Axis Rotation axis. Vec3d Axis { get; set; } Property Value Vec3d Pivot pivot Vec3d Pivot { get; set; } Property Value Vec3d"
  },
  "api/Hi.Mech.Topo.IDynamicTransformer.html": {
    "href": "api/Hi.Mech.Topo.IDynamicTransformer.html",
    "title": "Interface IDynamicTransformer | HiAPI-C# 2025",
    "summary": "Interface IDynamicTransformer Namespace Hi.Mech.Topo Assembly HiMech.dll Dynamic Transformer. public interface IDynamicTransformer : ITransformer, IMakeXmlSource, IToPresentDto Inherited Members ITransformer.GetMat() ITransformer.GetMatInv() ITransformer.Clone() IMakeXmlSource.MakeXmlSource(string, string, bool) IToPresentDto.ToPresentDto() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Mech.Topo.IGetAnchor.html": {
    "href": "api/Hi.Mech.Topo.IGetAnchor.html",
    "title": "Interface IGetAnchor | HiAPI-C# 2025",
    "summary": "Interface IGetAnchor Namespace Hi.Mech.Topo Assembly HiMech.dll Interface to get the key Anchor. public interface IGetAnchor : IGetTopoIndex Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetAnchor() Get key anchor. (i.e. root anchor) Anchor GetAnchor() Returns Anchor key anchor"
  },
  "api/Hi.Mech.Topo.IGetAnchoredDisplayeeList.html": {
    "href": "api/Hi.Mech.Topo.IGetAnchoredDisplayeeList.html",
    "title": "Interface IGetAnchoredDisplayeeList | HiAPI-C# 2025",
    "summary": "Interface IGetAnchoredDisplayeeList Namespace Hi.Mech.Topo Assembly HiMech.dll Interface for getting a list of anchored displayable objects. public interface IGetAnchoredDisplayeeList Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetAnchoredDisplayeeList() Gets a list of anchored displayable objects. List<IAnchoredDisplayee> GetAnchoredDisplayeeList() Returns List<IAnchoredDisplayee> A list of IAnchoredDisplayee objects"
  },
  "api/Hi.Mech.Topo.IGetAsmb.html": {
    "href": "api/Hi.Mech.Topo.IGetAsmb.html",
    "title": "Interface IGetAsmb | HiAPI-C# 2025",
    "summary": "Interface IGetAsmb Namespace Hi.Mech.Topo Assembly HiMech.dll Interface of Getting a key Asmb. public interface IGetAsmb : IGetTopoIndex Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetAsmb() Gets the key asmb. Asmb GetAsmb() Returns Asmb The key asmb."
  },
  "api/Hi.Mech.Topo.IGetFletchBuckle.html": {
    "href": "api/Hi.Mech.Topo.IGetFletchBuckle.html",
    "title": "Interface IGetFletchBuckle | HiAPI-C# 2025",
    "summary": "Interface IGetFletchBuckle Namespace Hi.Mech.Topo Assembly HiMech.dll Interface of GetFletchBuckle(). public interface IGetFletchBuckle Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetFletchBuckle() Get fletch buckle anchor. the anchor that generally connect to fixed part such as ground and triggering(motor)-side. Anchor GetFletchBuckle() Returns Anchor buckle anchor"
  },
  "api/Hi.Mech.Topo.IGetInverseTransformer.html": {
    "href": "api/Hi.Mech.Topo.IGetInverseTransformer.html",
    "title": "Interface IGetInverseTransformer | HiAPI-C# 2025",
    "summary": "Interface IGetInverseTransformer Namespace Hi.Mech.Topo Assembly HiMech.dll Interface for objects that can provide their inverse transformer. public interface IGetInverseTransformer Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetInverseTransformer() Gets the inverse transformer of this transformer. ITransformer GetInverseTransformer() Returns ITransformer The inverse transformer."
  },
  "api/Hi.Mech.Topo.IGetTopoIndex.html": {
    "href": "api/Hi.Mech.Topo.IGetTopoIndex.html",
    "title": "Interface IGetTopoIndex | HiAPI-C# 2025",
    "summary": "Interface IGetTopoIndex Namespace Hi.Mech.Topo Assembly HiMech.dll interface of IGetAnchor or IGetAsmb. public interface IGetTopoIndex Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Mech.Topo.IStaticTransformer.html": {
    "href": "api/Hi.Mech.Topo.IStaticTransformer.html",
    "title": "Interface IStaticTransformer | HiAPI-C# 2025",
    "summary": "Interface IStaticTransformer Namespace Hi.Mech.Topo Assembly HiMech.dll Static Transformer public interface IStaticTransformer : ITransformer, IMakeXmlSource, IToPresentDto Inherited Members ITransformer.GetMat() ITransformer.GetMatInv() ITransformer.Clone() IMakeXmlSource.MakeXmlSource(string, string, bool) IToPresentDto.ToPresentDto() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Mech.Topo.ITopo.html": {
    "href": "api/Hi.Mech.Topo.ITopo.html",
    "title": "Interface ITopo | HiAPI-C# 2025",
    "summary": "Interface ITopo Namespace Hi.Mech.Topo Assembly HiMech.dll Defines an interface for displaying topological elements that combines assembly, anchoring, and display capabilities. public interface ITopo : IGetAsmb, IGetAnchor, IGetTopoIndex, IGetAnchoredDisplayeeList Inherited Members IGetAsmb.GetAsmb() IGetAnchor.GetAnchor() IGetAnchoredDisplayeeList.GetAnchoredDisplayeeList() Extension Methods TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) TopoDisplayeeUtil.Display(ITopo, Bind) TopoDisplayeeUtil.ExpandToBox3d(ITopo, Box3d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Mech.Topo.ITopoDisplayee.html": {
    "href": "api/Hi.Mech.Topo.ITopoDisplayee.html",
    "title": "Interface ITopoDisplayee | HiAPI-C# 2025",
    "summary": "Interface ITopoDisplayee Namespace Hi.Mech.Topo Assembly HiMech.dll Represents a topology object that can be displayed and has an anchor. public interface ITopoDisplayee : ITopo, IGetAsmb, IGetAnchoredDisplayeeList, IAnchoredDisplayee, IGetAnchor, IGetTopoIndex, IDisplayee, IExpandToBox3d Inherited Members IGetAsmb.GetAsmb() IGetAnchoredDisplayeeList.GetAnchoredDisplayeeList() IGetAnchor.GetAnchor() IDisplayee.Display(Bind) IExpandToBox3d.ExpandToBox3d(Box3d) Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) TopoDisplayeeUtil.Display(ITopo, Bind) TopoDisplayeeUtil.ExpandToBox3d(ITopo, Box3d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Mech.Topo.ITransformer.html": {
    "href": "api/Hi.Mech.Topo.ITransformer.html",
    "title": "Interface ITransformer | HiAPI-C# 2025",
    "summary": "Interface ITransformer Namespace Hi.Mech.Topo Assembly HiMech.dll Interface of single transform matrix manipulation. public interface ITransformer : IMakeXmlSource, IToPresentDto Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) IToPresentDto.ToPresentDto() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods Clone() Clones this instance. ITransformer Clone() Returns ITransformer clone GetMat() Gets the transform matrix. Mat4d GetMat() Returns Mat4d The transform matrix. GetMatInv() Gets the inverse transform matrix. Mat4d GetMatInv() Returns Mat4d The inverse transform matrix."
  },
  "api/Hi.Mech.Topo.ITransformerProperty.html": {
    "href": "api/Hi.Mech.Topo.ITransformerProperty.html",
    "title": "Interface ITransformerProperty | HiAPI-C# 2025",
    "summary": "Interface ITransformerProperty Namespace Hi.Mech.Topo Assembly HiMech.dll Interface for objects that have a transformer property. public interface ITransformerProperty Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Transformer Gets or sets the transformer associated with this object. ITransformer Transformer { get; set; } Property Value ITransformer"
  },
  "api/Hi.Mech.Topo.NoTransform.html": {
    "href": "api/Hi.Mech.Topo.NoTransform.html",
    "title": "Class NoTransform | HiAPI-C# 2025",
    "summary": "Class NoTransform Namespace Hi.Mech.Topo Assembly HiMech.dll Static Identity Transformer. public class NoTransform : IStaticTransformer, ITransformer, IMakeXmlSource, IToPresentDto, IGetInverseTransformer Inheritance object NoTransform Implements IStaticTransformer ITransformer IMakeXmlSource IToPresentDto IGetInverseTransformer Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NoTransform() Ctor. public NoTransform() NoTransform(XElement) Ctor. public NoTransform(XElement src) Parameters src XElement XML Properties XName Static name. public static string XName { get; } Property Value string Methods Clone() Clones this instance. public ITransformer Clone() Returns ITransformer clone GetInverseTransformer() Gets the inverse transformer of this transformer. public ITransformer GetInverseTransformer() Returns ITransformer The inverse transformer. GetMat() Gets the transform matrix. public Mat4d GetMat() Returns Mat4d The transform matrix. GetMatInv() Gets the inverse transform matrix. public Mat4d GetMatInv() Returns Mat4d The inverse transform matrix. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public virtual XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToPresentDto() Convert NoTransform to presentation DTO (Data Transfer Object) for JSON serialization. The returned object includes type metadata for web API presentation. public object ToPresentDto() Returns object DTO dictionary with a Type key"
  },
  "api/Hi.Mech.Topo.StackTransformer.html": {
    "href": "api/Hi.Mech.Topo.StackTransformer.html",
    "title": "Class StackTransformer | HiAPI-C# 2025",
    "summary": "Class StackTransformer Namespace Hi.Mech.Topo Assembly HiMech.dll Represents a transformer that maintains a stack of transformations. public class StackTransformer : ITransformer, IMakeXmlSource, IToPresentDto, IDisposable Inheritance object StackTransformer Implements ITransformer IMakeXmlSource IToPresentDto IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors StackTransformer() Initializes a new instance of the StackTransformer class. public StackTransformer() StackTransformer(params ITransformer[]) Initializes a new instance of the StackTransformer class with the specified transformers. public StackTransformer(params ITransformer[] transformers) Parameters transformers ITransformer[] A variable-length array of transformers to add to the stack. StackTransformer(XElement, string, IProgress<IMessage>) Initializes a new instance of the StackTransformer class from XML data. public StackTransformer(XElement src, string baseDirectory, IProgress<IMessage> progress) Parameters src XElement The XML element containing the transformer stack configuration. baseDirectory string The base directory for resolving relative paths. progress IProgress<IMessage> The progress reporter. Properties Count Gets the number of transformers in the stack. public int Count { get; } Property Value int XName Static name. public static string XName { get; } Property Value string Methods Clear() Removes all transformers from the stack. public void Clear() Clone() Creates a deep copy of this transformer stack. public ITransformer Clone() Returns ITransformer A new StackTransformer instance with cloned transformers. Remarks The children ITransformer on stack are all cloned. Dispose() Releases all resources used by the StackTransformer. public void Dispose() Dispose(bool) Releases the unmanaged resources used by the StackTransformer and optionally releases the managed resources. protected virtual void Dispose(bool disposing) Parameters disposing bool true to release both managed and unmanaged resources; false to release only unmanaged resources. GetMat() Gets the combined transformation matrix of all transformers in the stack. public Mat4d GetMat() Returns Mat4d The combined 4x4 transformation matrix. Remarks The transformations are applied in order from bottom to top of the stack. GetMatInv() Gets the inverse of the combined transformation matrix of all transformers in the stack. public Mat4d GetMatInv() Returns Mat4d The inverse of the combined 4x4 transformation matrix. Remarks The inverse transformations are applied in reverse order (top to bottom of the stack). If forward mats is ABCD, then the inv-mats: DinvCinvBinvAinv. GetStack() Get the copied transformer stack. public List<ITransformer> GetStack() Returns List<ITransformer> copied stack MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public virtual XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Peek() Returns the transformer at the top of the stack without removing it. public ITransformer Peek() Returns ITransformer The transformer at the top of the stack, or null if the stack is empty. Pop() Removes and returns the transformer at the top of the stack. public ITransformer Pop() Returns ITransformer The transformer at the top of the stack, or null if the stack is empty. Push(ITransformer) Pushes a transformer onto the stack. public void Push(ITransformer transformer) Parameters transformer ITransformer The transformer to push. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToPresentDto() Convert StackTransformer to presentation DTO (Data Transfer Object) for JSON serialization. The returned object includes type metadata for web API presentation. public object ToPresentDto() Returns object DTO dictionary with Type and Stack keys"
  },
  "api/Hi.Mech.Topo.StaticFreeform.html": {
    "href": "api/Hi.Mech.Topo.StaticFreeform.html",
    "title": "Class StaticFreeform | HiAPI-C# 2025",
    "summary": "Class StaticFreeform Namespace Hi.Mech.Topo Assembly HiMech.dll Static Freeform transformer. public class StaticFreeform : IStaticTransformer, ITransformer, IMakeXmlSource, IGetInverseTransformer, IToPresentDto Inheritance object StaticFreeform Implements IStaticTransformer ITransformer IMakeXmlSource IGetInverseTransformer IToPresentDto Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors StaticFreeform() Ctor. public StaticFreeform() StaticFreeform(Mat4d) Ctor. public StaticFreeform(Mat4d mat) Parameters mat Mat4d transform matrix StaticFreeform(Mat4d, Mat4d) Ctor. public StaticFreeform(Mat4d mat, Mat4d matInv) Parameters mat Mat4d transform matrix matInv Mat4d inversed transform matrix StaticFreeform(XElement) Ctor. public StaticFreeform(XElement src) Parameters src XElement XML Properties XName Static name. public static string XName { get; } Property Value string Methods Clone() Clones this instance. public ITransformer Clone() Returns ITransformer clone GetInverseTransformer() Gets the inverse transformer of this transformer. public ITransformer GetInverseTransformer() Returns ITransformer The inverse transformer. GetMat() Gets the transform matrix. public Mat4d GetMat() Returns Mat4d The transform matrix. GetMatInv() Gets the inverse transform matrix. public Mat4d GetMatInv() Returns Mat4d The inverse transform matrix. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public virtual XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetMat(Mat4d) public void SetMat(Mat4d mat) Parameters mat Mat4d SetMat(Mat4d, Mat4d) Set transform matrix. public void SetMat(Mat4d mat, Mat4d matInv) Parameters mat Mat4d transform matrix matInv Mat4d inversed transform matrix ToPresentDto() Convert StaticFreeform to presentation DTO (Data Transfer Object) for JSON serialization. The returned object includes type metadata for web API presentation. public object ToPresentDto() Returns object DTO dictionary with Type and Matrix keys"
  },
  "api/Hi.Mech.Topo.StaticRotation.html": {
    "href": "api/Hi.Mech.Topo.StaticRotation.html",
    "title": "Class StaticRotation | HiAPI-C# 2025",
    "summary": "Class StaticRotation Namespace Hi.Mech.Topo Assembly HiMech.dll Static Rotation. public class StaticRotation : IStaticTransformer, ITransformer, IMakeXmlSource, IGetInverseTransformer, IToPresentDto Inheritance object StaticRotation Implements IStaticTransformer ITransformer IMakeXmlSource IGetInverseTransformer IToPresentDto Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors StaticRotation() Initializes a new instance of the StaticRotation class. public StaticRotation() StaticRotation(Vec3d, double) Ctor. public StaticRotation(Vec3d axis, double angle_rad) Parameters axis Vec3d Axis angle_rad double Angle_rad StaticRotation(Vec3d, double, Vec3d) Ctor. public StaticRotation(Vec3d axis, double angle_rad, Vec3d pivot) Parameters axis Vec3d angle_rad double pivot Vec3d StaticRotation(XElement) Initializes a new instance of the StaticRotation class from XML data. public StaticRotation(XElement src) Parameters src XElement The XML element containing the rotation data. Properties Angle_deg Gets or sets the rotation angle in degrees. public double Angle_deg { get; set; } Property Value double Angle_rad Gets or sets the rotation angle in radians. public double Angle_rad { get; set; } Property Value double Axis Gets or sets the rotation axis. public Vec3d Axis { get; set; } Property Value Vec3d Pivot Gets or sets the pivot point for the rotation. public Vec3d Pivot { get; set; } Property Value Vec3d XName Gets the XML element name for serialization. public static string XName { get; } Property Value string Methods Clone() Clones this instance. public ITransformer Clone() Returns ITransformer clone GetInverseTransformer() Gets a new transformer that represents the inverse of this rotation. public ITransformer GetInverseTransformer() Returns ITransformer An inverse transformer instance. GetMat() Gets the transformation matrix representing this rotation. public Mat4d GetMat() Returns Mat4d A 4x4 transformation matrix. GetMatInv() Gets the inverse transformation matrix of this rotation. public Mat4d GetMatInv() Returns Mat4d A 4x4 inverse transformation matrix. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public virtual XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToPresentDto() Convert StaticRotation to presentation DTO (Data Transfer Object) for JSON serialization. The returned object includes type metadata for web API presentation. public object ToPresentDto() Returns object DTO dictionary with Type, Axis, Angle_deg, and Pivot keys"
  },
  "api/Hi.Mech.Topo.StaticTranslation.html": {
    "href": "api/Hi.Mech.Topo.StaticTranslation.html",
    "title": "Class StaticTranslation | HiAPI-C# 2025",
    "summary": "Class StaticTranslation Namespace Hi.Mech.Topo Assembly HiMech.dll Static Translate. public class StaticTranslation : IStaticTransformer, ITransformer, IMakeXmlSource, IGetInverseTransformer, IToPresentDto Inheritance object StaticTranslation Implements IStaticTransformer ITransformer IMakeXmlSource IGetInverseTransformer IToPresentDto Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors StaticTranslation() Ctor. public StaticTranslation() StaticTranslation(Vec3d) Ctor. public StaticTranslation(Vec3d trans) Parameters trans Vec3d translation StaticTranslation(double, double, double) Ctor. public StaticTranslation(double x, double y, double z) Parameters x double translation x y double translation y z double translation z StaticTranslation(XElement) Ctor. public StaticTranslation(XElement src) Parameters src XElement XML Properties Trans Translation. public Vec3d Trans { get; set; } Property Value Vec3d XName Static name. public static string XName { get; } Property Value string Methods Clone() Clones this instance. public ITransformer Clone() Returns ITransformer clone GetInverseTransformer() Gets the inverse transformer of this transformer. public ITransformer GetInverseTransformer() Returns ITransformer The inverse transformer. GetMat() Gets the transform matrix. public Mat4d GetMat() Returns Mat4d The transform matrix. GetMatInv() Gets the inverse transform matrix. public Mat4d GetMatInv() Returns Mat4d The inverse transform matrix. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public virtual XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Set(StaticTranslation) Copy from src. public void Set(StaticTranslation src) Parameters src StaticTranslation src ToPresentDto() Convert StaticTranslation to presentation DTO (Data Transfer Object) for JSON serialization. The returned object includes type metadata for web API presentation. public object ToPresentDto() Returns object DTO dictionary with Type and Trans keys ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Mech.Topo.TopoDisplayee.html": {
    "href": "api/Hi.Mech.Topo.TopoDisplayee.html",
    "title": "Class TopoDisplayee | HiAPI-C# 2025",
    "summary": "Class TopoDisplayee Namespace Hi.Mech.Topo Assembly HiMech.dll Implements a displayable topological element that manages a collection of anchored displayees within an assembly. public class TopoDisplayee : ITopo, IGetAsmb, IGetAnchor, IGetTopoIndex, IGetAnchoredDisplayeeList Inheritance object TopoDisplayee Implements ITopo IGetAsmb IGetAnchor IGetTopoIndex IGetAnchoredDisplayeeList Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) TopoDisplayeeUtil.Display(ITopo, Bind) TopoDisplayeeUtil.ExpandToBox3d(ITopo, Box3d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors TopoDisplayee(Anchor, Asmb, params IAnchoredDisplayee[]) Initializes a new instance of the TopoDisplayee class with the specified root anchor, assembly, and displayees. public TopoDisplayee(Anchor rootAnchor, Asmb asmb, params IAnchoredDisplayee[] displayees) Parameters rootAnchor Anchor The root anchor for the topological displayee. asmb Asmb The assembly associated with the topological displayee. displayees IAnchoredDisplayee[] The array of anchored displayees to be managed. Properties AnchoredDisplayeeList Gets or sets the list of anchored displayees managed by this instance. public List<IAnchoredDisplayee> AnchoredDisplayeeList { get; set; } Property Value List<IAnchoredDisplayee> Asmb Gets or sets the assembly associated with this topological displayee. public Asmb Asmb { get; set; } Property Value Asmb RootAnchor Gets or sets the root anchor for this topological displayee. public Anchor RootAnchor { get; set; } Property Value Anchor Methods Display(Bind) public void Display(Bind bind) Parameters bind Bind ExpandToBox3d(Box3d) public void ExpandToBox3d(Box3d dst) Parameters dst Box3d GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor GetAnchoredDisplayeeList() Gets a list of anchored displayable objects. public List<IAnchoredDisplayee> GetAnchoredDisplayeeList() Returns List<IAnchoredDisplayee> A list of IAnchoredDisplayee objects GetAsmb() Gets the key asmb. public Asmb GetAsmb() Returns Asmb The key asmb."
  },
  "api/Hi.Mech.Topo.TopoDisplayeeUtil.html": {
    "href": "api/Hi.Mech.Topo.TopoDisplayeeUtil.html",
    "title": "Class TopoDisplayeeUtil | HiAPI-C# 2025",
    "summary": "Class TopoDisplayeeUtil Namespace Hi.Mech.Topo Assembly HiMech.dll Provides utility methods for displaying and manipulating topological displayees. public static class TopoDisplayeeUtil Inheritance object TopoDisplayeeUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods Display(ITopo, Bind) Displays the topological displayee using the specified bind context. public static void Display(this ITopo src, Bind bind) Parameters src ITopo The topological displayee to display. bind Bind The bind context used for displaying. ExpandToBox3d(ITopo, Box3d) Expands the bounding box to include the topological displayee's geometry. public static void ExpandToBox3d(this ITopo src, Box3d dst) Parameters src ITopo The topological displayee whose geometry should be included. dst Box3d The bounding box to expand."
  },
  "api/Hi.Mech.Topo.TopoReflection.html": {
    "href": "api/Hi.Mech.Topo.TopoReflection.html",
    "title": "Class TopoReflection | HiAPI-C# 2025",
    "summary": "Class TopoReflection Namespace Hi.Mech.Topo Assembly HiMech.dll Clone Asmb and provide map between source topology and cloned topology. public class TopoReflection Inheritance object TopoReflection Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors TopoReflection(Asmb) Ctor. public TopoReflection(Asmb rootAsmb) Parameters rootAsmb Asmb root assembly Properties AnchorMap Key is source anchor. Value is cloned anchor. public Dictionary<Anchor, Anchor> AnchorMap { get; } Property Value Dictionary<Anchor, Anchor> AsmbMap Key is source asmb. Value is cloned asmb. public Dictionary<Asmb, Asmb> AsmbMap { get; } Property Value Dictionary<Asmb, Asmb> BranchMap Key is source branch. Value is cloned branch. public Dictionary<Branch, Branch> BranchMap { get; } Property Value Dictionary<Branch, Branch> HostAsmbTwins Pair<TA, TB>.A is the source host; Pair<TA, TB>.B is the cloned host. public Pair<Asmb, Asmb> HostAsmbTwins { get; } Property Value Pair<Asmb, Asmb> TransformerMap Key is source branch. Value is cloned branch. public Dictionary<ITransformer, ITransformer> TransformerMap { get; } Property Value Dictionary<ITransformer, ITransformer>"
  },
  "api/Hi.Mech.Topo.TopoUtil.html": {
    "href": "api/Hi.Mech.Topo.TopoUtil.html",
    "title": "Class TopoUtil | HiAPI-C# 2025",
    "summary": "Class TopoUtil Namespace Hi.Mech.Topo Assembly HiMech.dll Utility of handling Anchor. public static class TopoUtil Inheritance object TopoUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) Display to rendering canvas. comp has to be IDisplayee to take effect. public static void Display(this IGetAnchor comp, Bind bind, Dictionary<Anchor, Mat4d> matMap) Parameters comp IGetAnchor component bind Bind rendering bind matMap Dictionary<Anchor, Mat4d> matrix map ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) Expand to Box3d. comp has to be IExpandToBox3d to take effect. public static void ExpandToBox3d(this IGetAnchor comp, Box3d dst, Dictionary<Anchor, Mat4d> matMap) Parameters comp IGetAnchor component dst Box3d dstination matMap Dictionary<Anchor, Mat4d> matrix map"
  },
  "api/Hi.Mech.Topo.TransformerUtil.html": {
    "href": "api/Hi.Mech.Topo.TransformerUtil.html",
    "title": "Class TransformerUtil | HiAPI-C# 2025",
    "summary": "Class TransformerUtil Namespace Hi.Mech.Topo Assembly HiMech.dll Utility for ITransformer. public static class TransformerUtil Inheritance object TransformerUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetSteps(IDynamicRegular[]) Gets the steps. public static double[] GetSteps(IDynamicRegular[] dynamics) Parameters dynamics IDynamicRegular[] The dynamics. Returns double[] the steps Reg(XFactory) Registers every concrete ITransformer implementation with the given XFactory: NoTransform, StaticTranslation, StaticRotation, StaticFreeform, DynamicTranslation, DynamicRotation, DynamicFreeform, StackTransformer, and GeneralTransform. Composites that deserialize a Branch (whose Transformer child can be any of the above) should chain this from their own Reg(factory). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetSteps(IDynamicRegular[], double[]) Sets the steps. public static void SetSteps(IDynamicRegular[] dynamics, double[] steps) Parameters dynamics IDynamicRegular[] The dynamics. steps double[] The steps."
  },
  "api/Hi.Mech.Topo.html": {
    "href": "api/Hi.Mech.Topo.html",
    "title": "Namespace Hi.Mech.Topo | HiAPI-C# 2025",
    "summary": "Namespace Hi.Mech.Topo Classes Anchor A coordinate system using in kinematic chain. AnchorFuncSource Provides an anchor through a function delegate. AnchoredBoxable Represents an object that is both anchored to a root point and can expand to a 3D box. AnchoredDisplayee Represents a displayable object that is anchored to a specific point in a topology. Asmb Collection of Anchor and Asmb. AsmbDraw Render all Anchors of the Asmb in form of CoordinateDrawing. Branch The linkage between two Anchor objects. DirectionBranchEntry A data pack contains Branch and a boolean isForward. DirectionBranchPackUtil Utility of topology. DynamicFreeform Dynamic Freeform transformer. DynamicRotation Dynamic rotate transformer. DynamicTranslation Dynamic translate transformer GeneralTransform Represents a general transformation that combines scaling, rotation, and translation. NoTransform Static Identity Transformer. StackTransformer Represents a transformer that maintains a stack of transformations. StaticFreeform Static Freeform transformer. StaticRotation Static Rotation. StaticTranslation Static Translate. TopoDisplayee Implements a displayable topological element that manages a collection of anchored displayees within an assembly. TopoDisplayeeUtil Provides utility methods for displaying and manipulating topological displayees. TopoReflection Clone Asmb and provide map between source topology and cloned topology. TopoUtil Utility of handling Anchor. TransformerUtil Utility for ITransformer. Interfaces IAnchoredDisplayee Interface for objects that can be displayed and are anchored to a root point in a topology. IDynamicRegular Dynamic Regular Transformer IDynamicRotation Topology joint that applies a single-axis rotation about Pivot by Angle_rad. IDynamicTransformer Dynamic Transformer. IGetAnchor Interface to get the key Anchor. IGetAnchoredDisplayeeList Interface for getting a list of anchored displayable objects. IGetAsmb Interface of Getting a key Asmb. IGetFletchBuckle Interface of GetFletchBuckle(). IGetInverseTransformer Interface for objects that can provide their inverse transformer. IGetTopoIndex interface of IGetAnchor or IGetAsmb. IStaticTransformer Static Transformer ITopo Defines an interface for displaying topological elements that combines assembly, anchoring, and display capabilities. ITopoDisplayee Represents a topology object that can be displayed and has an anchor. ITransformer Interface of single transform matrix manipulation. ITransformerProperty Interface for objects that have a transformer property."
  },
  "api/Hi.Mech.html": {
    "href": "api/Hi.Mech.html",
    "title": "Namespace Hi.Mech | HiAPI-C# 2025",
    "summary": "Namespace Hi.Mech Classes GeneralMechanism General Mechanism. MachiningChainUtil Utility methods for machining chains. Interfaces IGetAnchorToSolidDictionary Provides functionality to retrieve a dictionary mapping anchors to their corresponding solids. IGetMachiningChain Provides functionality to retrieve a machining chain instance. IMachiningChain Represents a machining chain with two ends, connecting a tool and a workpiece. IMachiningChainSource Provides XML serialization/deserialization capabilities for IMachiningChain objects."
  },
  "api/Hi.Milling.Apts.AptDerivative.html": {
    "href": "api/Hi.Milling.Apts.AptDerivative.html",
    "title": "Class AptDerivative | HiAPI-C# 2025",
    "summary": "Class AptDerivative Namespace Hi.Milling.Apts Assembly HiCbtr.dll Apt derivative. public class AptDerivative : IExpandToBox3d, IGetZrContour, IGenStl Inheritance object AptDerivative Implements IExpandToBox3d IGetZrContour IGenStl Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors AptDerivative(GeneralApt) Ctor. public AptDerivative(GeneralApt apt) Parameters apt GeneralApt apt Properties Apt Gets the general APT. public GeneralApt Apt { get; } Property Value GeneralApt CosAlpha Gets the cosine of Alpha angle. public double CosAlpha { get; } Property Value double CosBeta Gets the cosine of Beta angle. public double CosBeta { get; } Property Value double DefaultPolarResolution2d Gets or sets the default polar resolution for 2D operations. public static IPolarResolution2d DefaultPolarResolution2d { get; set; } Property Value IPolarResolution2d Mr Gets the radial coordinate of point M. public double Mr { get; } Property Value double Mz Gets the Z-coordinate of point M. public double Mz { get; } Property Value double Nr Gets the radial coordinate of point N. public double Nr { get; } Property Value double Nz Gets the Z-coordinate of point N. public double Nz { get; } Property Value double SinAlpha Gets the sine of Alpha angle. public double SinAlpha { get; } Property Value double SinBeta Gets the sine of Beta angle. public double SinBeta { get; } Property Value double TanAlpha Gets the tangent of Alpha angle. public double TanAlpha { get; } Property Value double TanBeta Gets the tangent of Beta angle. public double TanBeta { get; } Property Value double Methods ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GenStl(IPolarResolution2d) Generates an STL representation of the tool geometry. public Stl GenStl(IPolarResolution2d resolution) Parameters resolution IPolarResolution2d The polar resolution to use for generation. Returns Stl The generated STL object. GetNormal(double, double) Get Normal Vector by height and angle. public Vec3d GetNormal(double z, double rad) Parameters z double height rad double x-axis is begin; z-axis is principle Returns Vec3d GetRadius(double) Get Radius by z. public double GetRadius(double z) Parameters z double z Returns double radius at z GetZrContour(double) Gets Z-R contour data as a list of PairZr objects. The Z values should generally be ordered from smallest to largest. public IList<PairZr> GetZrContour(double latitudeAngleResolution_rad) Parameters latitudeAngleResolution_rad double Resolution of latitude angle in radians Returns IList<PairZr> Z-R contour data as a list of PairZr objects"
  },
  "api/Hi.Milling.Apts.BallApt.html": {
    "href": "api/Hi.Milling.Apts.BallApt.html",
    "title": "Class BallApt | HiAPI-C# 2025",
    "summary": "Class BallApt Namespace Hi.Milling.Apts Assembly HiCbtr.dll Ball End Apt. public class BallApt : IAptBased, IGetGeneralApt, IAbstractNote, IGetDiameter, IGetFluteHeight, IExpandToBox3d, IMakeXmlSource, IDuplicate, IToXElement Inheritance object BallApt Implements IAptBased IGetGeneralApt IAbstractNote IGetDiameter IGetFluteHeight IExpandToBox3d IMakeXmlSource IDuplicate IToXElement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors BallApt() Ctor. public BallApt() BallApt(XElement) Ctor. public BallApt(XElement src) Parameters src XElement XML Properties AbstractNote Gets a descriptive note or abstract about the object. public string AbstractNote { get; } Property Value string Diameter_mm Diameter. public double Diameter_mm { get; set; } Property Value double FluteHeight_mm Flute Height. public double FluteHeight_mm { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetGeneralApt() Get Apt. public GeneralApt GetGeneralApt() Returns GeneralApt Apt MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.Milling.Apts.BullNoseApt.html": {
    "href": "api/Hi.Milling.Apts.BullNoseApt.html",
    "title": "Class BullNoseApt | HiAPI-C# 2025",
    "summary": "Class BullNoseApt Namespace Hi.Milling.Apts Assembly HiCbtr.dll Bull Nose End APT. public class BullNoseApt : IAptBased, IGetGeneralApt, IAbstractNote, IGetDiameter, IGetFluteHeight, IExpandToBox3d, IMakeXmlSource, IDuplicate, IAptRc, IToXElement Inheritance object BullNoseApt Implements IAptBased IGetGeneralApt IAbstractNote IGetDiameter IGetFluteHeight IExpandToBox3d IMakeXmlSource IDuplicate IAptRc IToXElement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors BullNoseApt() Ctor. public BullNoseApt() BullNoseApt(XElement) Ctor. public BullNoseApt(XElement src) Parameters src XElement XML Properties AbstractNote Gets a descriptive note or abstract about the object. public string AbstractNote { get; } Property Value string Diameter_mm Diameter. public double Diameter_mm { get; set; } Property Value double FluteHeight_mm Flute Height. public double FluteHeight_mm { get; set; } Property Value double Rc_mm Round corner radius. public double Rc_mm { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetGeneralApt() Get Apt. public GeneralApt GetGeneralApt() Returns GeneralApt Apt MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.Milling.Apts.ColumnApt.html": {
    "href": "api/Hi.Milling.Apts.ColumnApt.html",
    "title": "Class ColumnApt | HiAPI-C# 2025",
    "summary": "Class ColumnApt Namespace Hi.Milling.Apts Assembly HiCbtr.dll Column End APT. The composition is identical to the BullNoseApt. However, the nose radius is generally smaller than the BullNoseApt. public class ColumnApt : IAptBased, IGetGeneralApt, IAbstractNote, IGetDiameter, IGetFluteHeight, IExpandToBox3d, IMakeXmlSource, IDuplicate, IAptRc, IToXElement Inheritance object ColumnApt Implements IAptBased IGetGeneralApt IAbstractNote IGetDiameter IGetFluteHeight IExpandToBox3d IMakeXmlSource IDuplicate IAptRc IToXElement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ColumnApt() Ctor. public ColumnApt() ColumnApt(XElement) Ctor. public ColumnApt(XElement src) Parameters src XElement XML Properties AbstractNote Gets a descriptive note or abstract about the object. public string AbstractNote { get; } Property Value string Diameter_mm Diameter. public double Diameter_mm { get; set; } Property Value double FluteHeight_mm Flute Height. public double FluteHeight_mm { get; set; } Property Value double Rc_mm Round corner radius. public double Rc_mm { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetGeneralApt() Get Apt. public GeneralApt GetGeneralApt() Returns GeneralApt Apt MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.Milling.Apts.ConeApt.html": {
    "href": "api/Hi.Milling.Apts.ConeApt.html",
    "title": "Class ConeApt | HiAPI-C# 2025",
    "summary": "Class ConeApt Namespace Hi.Milling.Apts Assembly HiCbtr.dll Cone End APT. public class ConeApt : IAptBased, IGetGeneralApt, IAbstractNote, IGetDiameter, IGetFluteHeight, IExpandToBox3d, IMakeXmlSource, IDuplicate, IAptAlpha, IToXElement Inheritance object ConeApt Implements IAptBased IGetGeneralApt IAbstractNote IGetDiameter IGetFluteHeight IExpandToBox3d IMakeXmlSource IDuplicate IAptAlpha IToXElement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ConeApt() Ctor. public ConeApt() ConeApt(XElement) Ctor. public ConeApt(XElement src) Parameters src XElement XML Properties AbstractNote Gets a descriptive note or abstract about the object. public string AbstractNote { get; } Property Value string Alpha_deg Alpha angle in degree. public double Alpha_deg { get; set; } Property Value double Alpha_rad Alpha angle in radian. public double Alpha_rad { get; set; } Property Value double Diameter_mm Diameter. public double Diameter_mm { get; set; } Property Value double FluteHeight_mm Flute Height. public double FluteHeight_mm { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetGeneralApt() Get Apt. public GeneralApt GetGeneralApt() Returns GeneralApt Apt MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.Milling.Apts.ExactColumnApt.html": {
    "href": "api/Hi.Milling.Apts.ExactColumnApt.html",
    "title": "Class ExactColumnApt | HiAPI-C# 2025",
    "summary": "Class ExactColumnApt Namespace Hi.Milling.Apts Assembly HiCbtr.dll Column End APT. public class ExactColumnApt : IAptBased, IGetGeneralApt, IAbstractNote, IGetDiameter, IGetFluteHeight, IExpandToBox3d, IMakeXmlSource, IDuplicate, IToXElement Inheritance object ExactColumnApt Implements IAptBased IGetGeneralApt IAbstractNote IGetDiameter IGetFluteHeight IExpandToBox3d IMakeXmlSource IDuplicate IToXElement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ExactColumnApt() Ctor. public ExactColumnApt() ExactColumnApt(XElement) Ctor. public ExactColumnApt(XElement src) Parameters src XElement XML Properties AbstractNote Gets a descriptive note or abstract about the object. public string AbstractNote { get; } Property Value string Diameter_mm Diameter. public double Diameter_mm { get; set; } Property Value double FluteHeight_mm Flute Height. public double FluteHeight_mm { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetGeneralApt() Get Apt. public GeneralApt GetGeneralApt() Returns GeneralApt Apt MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.Milling.Apts.GeneralApt.html": {
    "href": "api/Hi.Milling.Apts.GeneralApt.html",
    "title": "Class GeneralApt | HiAPI-C# 2025",
    "summary": "Class GeneralApt Namespace Hi.Milling.Apts Assembly HiCbtr.dll APT standard milling cutter geometry. public class GeneralApt : IAptBased, IGetGeneralApt, IAbstractNote, IGetDiameter, IGetFluteHeight, IExpandToBox3d, IMakeXmlSource, IDuplicate, IEquatable<GeneralApt>, IAptRc, IAptRr, IAptRz, IAptAlpha, IAptBeta, IGetZrContour, IToXElement, IGenStl, IClearCache Inheritance object GeneralApt Implements IAptBased IGetGeneralApt IAbstractNote IGetDiameter IGetFluteHeight IExpandToBox3d IMakeXmlSource IDuplicate IEquatable<GeneralApt> IAptRc IAptRr IAptRz IAptAlpha IAptBeta IGetZrContour IToXElement IGenStl IClearCache Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors GeneralApt() Ctor. public GeneralApt() GeneralApt(GeneralApt) Copy ctor. public GeneralApt(GeneralApt src) Parameters src GeneralApt src GeneralApt(double, double, double, double, double, double, double) Ctor. public GeneralApt(double D, double R0, double Rr, double Rz, double alpha_rad, double beta_rad, double fluteH) Parameters D double see Diameter_mm R0 double see Rc_mm Rr double see Rr_mm Rz double see Rz_mm alpha_rad double see Alpha_rad beta_rad double see Beta_rad fluteH double see FluteHeight_mm GeneralApt(XElement) Ctor. public GeneralApt(XElement src) Parameters src XElement XML Properties AbstractNote Gets a descriptive note or abstract about the object. public string AbstractNote { get; } Property Value string Alpha_deg Alpha_rad in degree. public double Alpha_deg { get; set; } Property Value double Alpha_rad The angle between horizontal plane and the cone surface of the cutter tip. The angle is downside the cutter round (if exists). If the cutter is cylindrical mill, the angle is 0. The unit is radian. public double Alpha_rad { get; set; } Property Value double AptDerivative Gets the APT derivative object, creating it if it doesn't exist. public AptDerivative AptDerivative { get; } Property Value AptDerivative Beta_deg Beta_rad in degree. public double Beta_deg { get; set; } Property Value double Beta_rad The angle between stick axis and the side plane of cutter. The angle is upside the cutter round (if exists). The unit is radian. public double Beta_rad { get; set; } Property Value double Diameter_mm Diameter. public double Diameter_mm { get; set; } Property Value double FluteHeight_mm Full Height. public double FluteHeight_mm { get; set; } Property Value double Rc_mm Round radius. public double Rc_mm { get; set; } Property Value double Rr_mm Distance between round center to the stick axis. public double Rr_mm { get; set; } Property Value double Rz_mm Center between the tip to the round center. public double Rz_mm { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods ClearCache() Clears the internal cache of APT derivative. public void ClearCache() Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object Equals(GeneralApt) Indicates whether the current object is equal to another object of the same type. public bool Equals(GeneralApt src) Parameters src GeneralApt Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GenStl(IPolarResolution2d) Generates a new STL. public Stl GenStl(IPolarResolution2d polarResolution) Parameters polarResolution IPolarResolution2d Returns Stl A newly created STL. GetGeneralApt() Get Apt. public GeneralApt GetGeneralApt() Returns GeneralApt Apt GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. GetZrContour(double) Gets Z-R contour data as a list of PairZr objects. The Z values should generally be ordered from smallest to largest. public IList<PairZr> GetZrContour(double latitudeAngleResolution_rad) Parameters latitudeAngleResolution_rad double Resolution of latitude angle in radians Returns IList<PairZr> Z-R contour data as a list of PairZr objects MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.Milling.Apts.IAptAlpha.html": {
    "href": "api/Hi.Milling.Apts.IAptAlpha.html",
    "title": "Interface IAptAlpha | HiAPI-C# 2025",
    "summary": "Interface IAptAlpha Namespace Hi.Milling.Apts Assembly HiCbtr.dll Interface for APT objects with alpha angle. public interface IAptAlpha Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Alpha_deg Alpha_rad in degree. double Alpha_deg { get; set; } Property Value double Alpha_rad The angle between horizontal plane and the cone surface of the cutter tip. The angle is downside the cutter round (if exists). If the cutter is cylindrical mill, the angle is 0. The unit is radian. double Alpha_rad { get; set; } Property Value double"
  },
  "api/Hi.Milling.Apts.IAptBased.html": {
    "href": "api/Hi.Milling.Apts.IAptBased.html",
    "title": "Interface IAptBased | HiAPI-C# 2025",
    "summary": "Interface IAptBased Namespace Hi.Milling.Apts Assembly HiCbtr.dll Interface for APT-based objects. public interface IAptBased : IGetGeneralApt, IAbstractNote, IGetDiameter, IGetFluteHeight, IExpandToBox3d, IMakeXmlSource, IDuplicate Inherited Members IGetGeneralApt.GetGeneralApt() IAbstractNote.AbstractNote IExpandToBox3d.ExpandToBox3d(Box3d) IMakeXmlSource.MakeXmlSource(string, string, bool) IDuplicate.Duplicate(params object[]) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Diameter_mm Diameter in mm. double Diameter_mm { get; set; } Property Value double FluteHeight_mm Height of flute. double FluteHeight_mm { get; set; } Property Value double"
  },
  "api/Hi.Milling.Apts.IAptBeta.html": {
    "href": "api/Hi.Milling.Apts.IAptBeta.html",
    "title": "Interface IAptBeta | HiAPI-C# 2025",
    "summary": "Interface IAptBeta Namespace Hi.Milling.Apts Assembly HiCbtr.dll Interface for APT objects with beta angle. public interface IAptBeta Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Beta_deg Beta_rad in degree. double Beta_deg { get; set; } Property Value double Beta_rad The angle between stick axis and the side plane of cutter. The angle is upside the cutter round (if exists). The unit is radian. double Beta_rad { get; set; } Property Value double"
  },
  "api/Hi.Milling.Apts.IAptRc.html": {
    "href": "api/Hi.Milling.Apts.IAptRc.html",
    "title": "Interface IAptRc | HiAPI-C# 2025",
    "summary": "Interface IAptRc Namespace Hi.Milling.Apts Assembly HiCbtr.dll Interface for APT objects with corner radius. public interface IAptRc Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Rc_mm Corner radius. Round radius. double Rc_mm { get; set; } Property Value double"
  },
  "api/Hi.Milling.Apts.IAptRr.html": {
    "href": "api/Hi.Milling.Apts.IAptRr.html",
    "title": "Interface IAptRr | HiAPI-C# 2025",
    "summary": "Interface IAptRr Namespace Hi.Milling.Apts Assembly HiCbtr.dll Interface for APT objects with round radius. public interface IAptRr Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Rr_mm Distance between round center to the stick axis. double Rr_mm { get; set; } Property Value double"
  },
  "api/Hi.Milling.Apts.IAptRz.html": {
    "href": "api/Hi.Milling.Apts.IAptRz.html",
    "title": "Interface IAptRz | HiAPI-C# 2025",
    "summary": "Interface IAptRz Namespace Hi.Milling.Apts Assembly HiCbtr.dll Interface for APT objects with Z-axis round center distance. public interface IAptRz Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Rz_mm Center between the tip to the round center. double Rz_mm { get; set; } Property Value double"
  },
  "api/Hi.Milling.Apts.IGetApt.html": {
    "href": "api/Hi.Milling.Apts.IGetApt.html",
    "title": "Interface IGetApt | HiAPI-C# 2025",
    "summary": "Interface IGetApt Namespace Hi.Milling.Apts Assembly HiCbtr.dll Interface for objects that can provide an APT-based object. public interface IGetApt Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Apt Gets the APT-based object. IAptBased Apt { get; } Property Value IAptBased"
  },
  "api/Hi.Milling.Apts.IGetGeneralApt.html": {
    "href": "api/Hi.Milling.Apts.IGetGeneralApt.html",
    "title": "Interface IGetGeneralApt | HiAPI-C# 2025",
    "summary": "Interface IGetGeneralApt Namespace Hi.Milling.Apts Assembly HiCbtr.dll Interface of GetGeneralApt(). public interface IGetGeneralApt Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetGeneralApt() Get Apt. GeneralApt GetGeneralApt() Returns GeneralApt Apt"
  },
  "api/Hi.Milling.Apts.TaperApt.html": {
    "href": "api/Hi.Milling.Apts.TaperApt.html",
    "title": "Class TaperApt | HiAPI-C# 2025",
    "summary": "Class TaperApt Namespace Hi.Milling.Apts Assembly HiCbtr.dll Taper End APT. public class TaperApt : IAptBased, IGetGeneralApt, IAbstractNote, IGetDiameter, IGetFluteHeight, IExpandToBox3d, IMakeXmlSource, IDuplicate, IAptRz, IAptAlpha, IAptBeta, IToXElement Inheritance object TaperApt Implements IAptBased IGetGeneralApt IAbstractNote IGetDiameter IGetFluteHeight IExpandToBox3d IMakeXmlSource IDuplicate IAptRz IAptAlpha IAptBeta IToXElement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors TaperApt() Ctor. public TaperApt() TaperApt(XElement) Ctor. public TaperApt(XElement src) Parameters src XElement XML Properties AbstractNote Gets a descriptive note or abstract about the object. public string AbstractNote { get; } Property Value string Alpha_deg Alpha_rad in degree. public double Alpha_deg { get; set; } Property Value double Alpha_rad The angle between horizontal plane and the cone surface of the cutter tip. The angle is downside the cutter round (if exists). If the cutter is cylindrical mill, the angle is 0. The unit is radian. public double Alpha_rad { get; set; } Property Value double Beta_deg Beta_rad in degree. public double Beta_deg { get; set; } Property Value double Beta_rad The angle between stick axis and the side plane of cutter. The angle is upside the cutter round (if exists). The unit is radian. public double Beta_rad { get; set; } Property Value double Diameter_mm Diameter. public double Diameter_mm { get; set; } Property Value double FluteHeight_mm Height of flute. public double FluteHeight_mm { get; set; } Property Value double Rz_mm Center between the tip to the round center. public double Rz_mm { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetGeneralApt() Get Apt. public GeneralApt GetGeneralApt() Returns GeneralApt Apt MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.Milling.Apts.apt_t.html": {
    "href": "api/Hi.Milling.Apts.apt_t.html",
    "title": "Struct apt_t | HiAPI-C# 2025",
    "summary": "Struct apt_t Namespace Hi.Milling.Apts Assembly HiCbtr.dll Native apt. public struct apt_t Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors apt_t() Ctor. public apt_t() apt_t(IGetGeneralApt) Ctor. public apt_t(IGetGeneralApt src) Parameters src IGetGeneralApt src Fields D Diameter. public double D Field Value double H Height. public double H Field Value double Rc Round radius. public double Rc Field Value double Rr Horizontal length from cutter axis to round center. public double Rr Field Value double Rz Vertical length from cutter tip to round center. public double Rz Field Value double alpha Angle (radian) between bottom surface and horizontal. public double alpha Field Value double beta Angle (radian) between wall surface and vertical. public double beta Field Value double"
  },
  "api/Hi.Milling.Apts.html": {
    "href": "api/Hi.Milling.Apts.html",
    "title": "Namespace Hi.Milling.Apts | HiAPI-C# 2025",
    "summary": "Namespace Hi.Milling.Apts Classes AptDerivative Apt derivative. BallApt Ball End Apt. BullNoseApt Bull Nose End APT. ColumnApt Column End APT. The composition is identical to the BullNoseApt. However, the nose radius is generally smaller than the BullNoseApt. ConeApt Cone End APT. ExactColumnApt Column End APT. GeneralApt APT standard milling cutter geometry. TaperApt Taper End APT. Structs apt_t Native apt. Interfaces IAptAlpha Interface for APT objects with alpha angle. IAptBased Interface for APT-based objects. IAptBeta Interface for APT objects with beta angle. IAptRc Interface for APT objects with corner radius. IAptRr Interface for APT objects with round radius. IAptRz Interface for APT objects with Z-axis round center distance. IGetApt Interface for objects that can provide an APT-based object. IGetGeneralApt Interface of GetGeneralApt()."
  },
  "api/Hi.Milling.Cutters.AptProfile.html": {
    "href": "api/Hi.Milling.Cutters.AptProfile.html",
    "title": "Class AptProfile | HiAPI-C# 2025",
    "summary": "Class AptProfile Namespace Hi.Milling.Cutters Assembly HiMech.dll Represents an APT (Automatically Programmed Tool) based profile for a milling cutter. This profile uses APT definitions to describe the cutter geometry. public class AptProfile : IShaperProfile, IMakeXmlSource, IAbstractNote, IGetZrList, IGenStl, IDuplicate, IGetSelectionName, IGetInitStickConvex, IVolumeRemover, IDisposable, IUpdateByContent, IClearCache Inheritance object AptProfile Implements IShaperProfile IMakeXmlSource IAbstractNote IGetZrList IGenStl IDuplicate IGetSelectionName IGetInitStickConvex IVolumeRemover IDisposable IUpdateByContent IClearCache Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors AptProfile() Initializes a new instance of the AptProfile class. public AptProfile() AptProfile(IAptBased) Initializes a new instance of the AptProfile class. public AptProfile(IAptBased apt) Parameters apt IAptBased The APT-based object. AptProfile(XElement, string, IProgress<IMessage>) Initializes a new instance of the AptProfile class. public AptProfile(XElement src, string baseDirectory, IProgress<IMessage> progress) Parameters src XElement XML element containing the profile configuration. baseDirectory string The base directory for resolving relative paths. progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. Properties AbstractNote Gets the abstract note from the APT definition. public string AbstractNote { get; } Property Value string Apt Gets or sets the APT-based definition for the profile. public IAptBased Apt { get; set; } Property Value IAptBased DefaultAngleResolution_rad Gets or sets the default angle resolution in radians. public static double DefaultAngleResolution_rad { get; set; } Property Value double DefaultLinearResolution_mm Gets or sets the default linear resolution in millimeters. public static double DefaultLinearResolution_mm { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods ClearCache() Clears all cached data. public void ClearCache() Dispose() Disposes of all resources. public void Dispose() Dispose(bool) Disposes of unmanaged resources. protected virtual void Dispose(bool disposing) Parameters disposing bool True if disposing, false if finalizing Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object GenStl(IPolarResolution2d) Generates a new STL. public Stl GenStl(IPolarResolution2d resolution) Parameters resolution IPolarResolution2d Polar resolution Returns Stl A newly created STL. GetInitStickConvex() Gets the initial stick convex representation of the profile. public InitStickConvex GetInitStickConvex() Returns InitStickConvex The initial stick convex representation GetSelectionName() Gets the display name for selection. public string GetSelectionName() Returns string The display name GetZrList() Gets the ZR contour list for the profile. public List<PairZr> GetZrList() Returns List<PairZr> The list of ZR pairs MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory UpdateByContent() Updates the profile based on content changes. public void UpdateByContent()"
  },
  "api/Hi.Milling.Cutters.ConstRatioProfile.html": {
    "href": "api/Hi.Milling.Cutters.ConstRatioProfile.html",
    "title": "Class ConstRatioProfile | HiAPI-C# 2025",
    "summary": "Class ConstRatioProfile Namespace Hi.Milling.Cutters Assembly HiMech.dll Represents a constant ratio profile for a milling cutter. This profile maintains a constant ratio between inner and outer radii. public class ConstRatioProfile : IShaperProfile, IMakeXmlSource, IAbstractNote, IGetZrList, IDuplicate, IClearCache, IGenStl, IZrListSourceProperty Inheritance object ConstRatioProfile Implements IShaperProfile IMakeXmlSource IAbstractNote IGetZrList IDuplicate IClearCache IGenStl IZrListSourceProperty Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ConstRatioProfile() Initializes a new instance of the ConstRatioProfile class. public ConstRatioProfile() ConstRatioProfile(double) Initializes a new instance of the ConstRatioProfile class with a specified radius ratio. public ConstRatioProfile(double innerRadiusRatio) Parameters innerRadiusRatio double The ratio between inner and outer radii ConstRatioProfile(XElement, string) Initializes a new instance of the ConstRatioProfile class. public ConstRatioProfile(XElement element, string baseDirectory) Parameters element XElement The XML element containing profile data. baseDirectory string The base directory for resolving relative paths. Properties AbstractNote Gets the abstract note describing the profile. public string AbstractNote { get; } Property Value string RadiusRatio Gets or sets the ratio between inner and outer radii. public double RadiusRatio { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string ZrListSource Get base geometry source. Runtime property. public Func<IGetZrList> ZrListSource { get; set; } Property Value Func<IGetZrList> Methods ClearCache() Clears any cached data held by the implementing object. public void ClearCache() Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object GenStl(IPolarResolution2d) Generates a new STL. public Stl GenStl(IPolarResolution2d resolution) Parameters resolution IPolarResolution2d Polar resolution Returns Stl A newly created STL. GetZrList() Gets a list of Z-R coordinate pairs. public List<PairZr> GetZrList() Returns List<PairZr> A list of PairZr objects representing Z-R coordinates. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Milling.Cutters.CustomSpinningProfile.html": {
    "href": "api/Hi.Milling.Cutters.CustomSpinningProfile.html",
    "title": "Class CustomSpinningProfile | HiAPI-C# 2025",
    "summary": "Class CustomSpinningProfile Namespace Hi.Milling.Cutters Assembly HiMech.dll Represents a custom spinning profile for a milling cutter. This profile allows for custom geometry to be used as the cutter profile. public class CustomSpinningProfile : IShaperProfile, IMakeXmlSource, IAbstractNote, IGetZrList, IGenStl, IDuplicate, IClearCache Inheritance object CustomSpinningProfile Implements IShaperProfile IMakeXmlSource IAbstractNote IGetZrList IGenStl IDuplicate IClearCache Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CustomSpinningProfile(IGetStl) Initializes a new instance of the CustomSpinningProfile class. public CustomSpinningProfile(IGetStl geom) Parameters geom IGetStl The geometry that defines the profile. CustomSpinningProfile(XElement, string, IProgress<IMessage>, object[]) Initializes a new instance of the CustomSpinningProfile class. public CustomSpinningProfile(XElement element, string baseDirectory, IProgress<IMessage> progress, object[] res) Parameters element XElement The XML element containing profile data. baseDirectory string The base directory for resolving relative paths. progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. res object[] Additional resolution parameters. Properties AbstractNote Gets the abstract note describing the profile. public string AbstractNote { get; } Property Value string Geom Gets or sets the geometry that defines the profile. public IGetStl Geom { get; set; } Property Value IGetStl XName Name for XML IO. public static string XName { get; } Property Value string Methods ClearCache() Clears any cached data. public void ClearCache() Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object GenStl(IPolarResolution2d) Generates a new STL. public Stl GenStl(IPolarResolution2d resolution) Parameters resolution IPolarResolution2d Polar resolution Returns Stl A newly created STL. GetZrList() Gets the ZR contour list for the profile. This method attempts to get the ZR list from various geometry types. public List<PairZr> GetZrList() Returns List<PairZr> The list of ZR pairs MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Milling.Cutters.CutterUtil.html": {
    "href": "api/Hi.Milling.Cutters.CutterUtil.html",
    "title": "Class CutterUtil | HiAPI-C# 2025",
    "summary": "Class CutterUtil Namespace Hi.Milling.Cutters Assembly HiMech.dll Utility class providing extension methods for cutter operations. public static class CutterUtil Inheritance object CutterUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetCutterBodyCoolingArea_mm2(ICutter) Gets the cooling area of the cutter body in square millimeters. public static double? GetCutterBodyCoolingArea_mm2(this ICutter cutter) Parameters cutter ICutter The cutter to calculate the cooling area for. Returns double? The cooling area in square millimeters, or null if the cutter is null."
  },
  "api/Hi.Milling.Cutters.FluteContourDisplayee.html": {
    "href": "api/Hi.Milling.Cutters.FluteContourDisplayee.html",
    "title": "Class FluteContourDisplayee | HiAPI-C# 2025",
    "summary": "Class FluteContourDisplayee Namespace Hi.Milling.Cutters Assembly HiMech.dll Provides display functionality for flute contours in milling cutters. This class handles the visualization of both front and back surfaces of flute contours. Internal Use Only public class FluteContourDisplayee : IDisplayee, IExpandToBox3d, IClearCache, IDisposable Inheritance object FluteContourDisplayee Implements IDisplayee IExpandToBox3d IClearCache IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FluteContourDisplayee(Func<MillingCutter>, FluteContour) Initializes a new instance of the FluteContourDisplayee class. Internal Use Only public FluteContourDisplayee(Func<MillingCutter> millingCutterHost, FluteContour fluteContour) Parameters millingCutterHost Func<MillingCutter> The function that provides the host milling cutter. fluteContour FluteContour The flute contour to be displayed. Properties FluteContour Gets or sets the flute contour to be displayed. Internal Use Only public FluteContour FluteContour { get; set; } Property Value FluteContour MillingCutterHost Gets or sets the function that provides the host milling cutter. Internal Use Only public Func<MillingCutter> MillingCutterHost { get; set; } Property Value Func<MillingCutter> Methods ClearCache() Clears the cached display data. Internal Use Only public void ClearCache() Display(Bind) Displays the flute contour using the specified binding. Internal Use Only public void Display(Bind bind) Parameters bind Bind The display binding to use. Dispose() Disposes of all resources. Internal Use Only public void Dispose() Dispose(bool) Disposes of unmanaged resources. Internal Use Only protected virtual void Dispose(bool disposing) Parameters disposing bool True if disposing, false if finalizing ExpandToBox3d(Box3d) Expands the destination box to include the bounds of this displayee. Internal Use Only public void ExpandToBox3d(Box3d dst) Parameters dst Box3d The box to expand."
  },
  "api/Hi.Milling.Cutters.FluteDependentRatioProfile.html": {
    "href": "api/Hi.Milling.Cutters.FluteDependentRatioProfile.html",
    "title": "Class FluteDependentRatioProfile | HiAPI-C# 2025",
    "summary": "Class FluteDependentRatioProfile Namespace Hi.Milling.Cutters Assembly HiMech.dll Represents a flute number dependent ratio profile for a milling cutter. This profile determines the ratio between inner and outer radii based on the number of flutes. public class FluteDependentRatioProfile : IShaperProfile, IMakeXmlSource, IAbstractNote, IGetZrList, IGenStl, IDuplicate, IClearCache, IFluteNumSourceProperty, IZrListSourceProperty Inheritance object FluteDependentRatioProfile Implements IShaperProfile IMakeXmlSource IAbstractNote IGetZrList IGenStl IDuplicate IClearCache IFluteNumSourceProperty IZrListSourceProperty Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FluteDependentRatioProfile() Initializes a new instance. public FluteDependentRatioProfile() FluteDependentRatioProfile(XElement, string) Initializes a new instance of the FluteDependentRatioProfile class. public FluteDependentRatioProfile(XElement element, string baseDirectory) Parameters element XElement The XML element containing profile data. baseDirectory string The base directory for resolving relative paths. Properties AbstractNote Gets the abstract note describing the profile. public string AbstractNote { get; } Property Value string FluteNumSource Gets or sets a delegate that returns the current flute number. public Func<int> FluteNumSource { get; set; } Property Value Func<int> RadiusRatio Gets the radius ratio based on the current number of flutes. public double RadiusRatio { get; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string ZrListSource Get base geometry source. Runtime property. public Func<IGetZrList> ZrListSource { get; set; } Property Value Func<IGetZrList> Methods ClearCache() Clears any cached data held by the implementing object. public void ClearCache() Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object GenStl(IPolarResolution2d) Generates a new STL. public Stl GenStl(IPolarResolution2d resolution) Parameters resolution IPolarResolution2d Polar resolution Returns Stl A newly created STL. GetZrList() Gets a list of Z-R coordinate pairs. public List<PairZr> GetZrList() Returns List<PairZr> A list of PairZr objects representing Z-R coordinates. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Milling.Cutters.IShaperProfile.html": {
    "href": "api/Hi.Milling.Cutters.IShaperProfile.html",
    "title": "Interface IShaperProfile | HiAPI-C# 2025",
    "summary": "Interface IShaperProfile Namespace Hi.Milling.Cutters Assembly HiMech.dll Interface defining the shape profile of a cutter flute. Mesh access is resolution-explicit: callers pass their value through GenStl(IPolarResolution2d), or state the profile's own default with a null argument. public interface IShaperProfile : IMakeXmlSource, IAbstractNote, IGetZrList, IGenStl, IDuplicate, IClearCache Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) IAbstractNote.AbstractNote IGetZrList.GetZrList() IGenStl.GenStl(IPolarResolution2d) IDuplicate.Duplicate(params object[]) IClearCache.ClearCache() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Milling.Cutters.MillingCutter.IntegralModeEnum.html": {
    "href": "api/Hi.Milling.Cutters.MillingCutter.IntegralModeEnum.html",
    "title": "Enum MillingCutter.IntegralModeEnum | HiAPI-C# 2025",
    "summary": "Enum MillingCutter.IntegralModeEnum Namespace Hi.Milling.Cutters Assembly HiMech.dll Defines the integral mode of the cutter. public enum MillingCutter.IntegralModeEnum Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields InsertEnd = 1 Insert end mode. SolidEnd = 0 Solid end mode."
  },
  "api/Hi.Milling.Cutters.MillingCutter.MassAssignmentMode.html": {
    "href": "api/Hi.Milling.Cutters.MillingCutter.MassAssignmentMode.html",
    "title": "Enum MillingCutter.MassAssignmentMode | HiAPI-C# 2025",
    "summary": "Enum MillingCutter.MassAssignmentMode Namespace Hi.Milling.Cutters Assembly HiMech.dll Defines the mass assignment mode for the cutter. public enum MillingCutter.MassAssignmentMode Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Custom = 0 Custom mass assignment mode. EvaluateByVolume = 1 Evaluate mass by volume mode."
  },
  "api/Hi.Milling.Cutters.MillingCutter.html": {
    "href": "api/Hi.Milling.Cutters.MillingCutter.html",
    "title": "Class MillingCutter | HiAPI-C# 2025",
    "summary": "Class MillingCutter Namespace Hi.Milling.Cutters Assembly HiMech.dll Represents a milling cutter with its geometric and physical properties. public class MillingCutter : ICutter, IGetSweptable, IAnchoredDisplayee, IGetFletchBuckle, IMakeXmlSource, IAbstractNote, IAnchoredCollidableStem, IAnchoredCollidableNode, IAnchoredCollidableBased, IDisposable, INameNote, IGetFluteHeight, IDisplayee, IExpandToBox3d, IUpdateByContent, IClearCache, IGetThermalLayerList, ITopo, IGetAsmb, IGetAnchor, IGetTopoIndex, IGetAnchoredDisplayeeList, IDuplicate, IGetInitStickConvex, IVolumeRemover, IGetZrList Inheritance object MillingCutter Implements ICutter IGetSweptable IAnchoredDisplayee IGetFletchBuckle IMakeXmlSource IAbstractNote IAnchoredCollidableStem IAnchoredCollidableNode IAnchoredCollidableBased IDisposable INameNote IGetFluteHeight IDisplayee IExpandToBox3d IUpdateByContent IClearCache IGetThermalLayerList ITopo IGetAsmb IGetAnchor IGetTopoIndex IGetAnchoredDisplayeeList IDuplicate IGetInitStickConvex IVolumeRemover IGetZrList Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) CutterUtil.GetCutterBodyCoolingArea_mm2(ICutter) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) TopoDisplayeeUtil.Display(ITopo, Bind) TopoDisplayeeUtil.ExpandToBox3d(ITopo, Box3d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MillingTemperatureUtil.GetMaterial(IGetThermalLayerList, double) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks The cutter can be solid end or insert end. The term “Flute” is the edge part of the solid end cutter or the full insert of the insert end body. The term “Shank” is the full part except for edge part (i.e. Flute) of the solid end cutter. Shank and Flute compose the full cutter. Constructors MillingCutter() Initializes a new instance of the MillingCutter class. public MillingCutter() MillingCutter(XElement, string, string, IProgress<IMessage>, object[]) Ctor. public MillingCutter(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress, object[] res) Parameters src XElement XML baseDirectory string Base directory path for resolving relative paths relFile string Relative file path progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. res object[] Additional optional resources Properties AbstractNote Gets a descriptive note or abstract about the object. public string AbstractNote { get; } Property Value string CoatingLayerList Gets or sets the list of coating thermal layers. The sequence starts from surface, i.e. from outer to inner. public List<ThermalLayer1D> CoatingLayerList { get; set; } Property Value List<ThermalLayer1D> CollidableName Gets the name of the collidable object. public string CollidableName { get; } Property Value string CutterTip Gets the anchor point at the cutter tip. public Anchor CutterTip { get; } Property Value Anchor DefaultAngleResolution_rad Gets or sets the default angle resolution in radians. public static double DefaultAngleResolution_rad { get; set; } Property Value double DefaultLinearResolution_mm Gets or sets the default linear resolution in millimeters. public static double DefaultLinearResolution_mm { get; set; } Property Value double DefaultShaperStlResolution Mesh resolution a fresh cutter's shaper solid is born with — the explicit Setup-face display-quality contract. A play swaps the solid for one born with the runtime-derived resolution (see SetShaperStlResolution(PolarResolution2d)). public static PolarResolution2d DefaultShaperStlResolution { get; } Property Value PolarResolution2d DefaultStlLongitudeNum Gets or sets the default number of longitude lines for STL generation. public static int DefaultStlLongitudeNum { get; set; } Property Value int EffectiveCuttingDiameter_mm Cutting Diameter for calculate cutting speed. Pure computation — deliberately uncached (see Hi.Milling.Cutters.MillingCutter.SideRakeAngle_rad); per-step session paths read the value from MillingToolPhysicsPack. public double EffectiveCuttingDiameter_mm { get; } Property Value double ExposedHeight_mm Has to be simultanous with ExposedCutterHeight_mm. public double ExposedHeight_mm { get; set; } Property Value double FluteHeight_mm Gets the height of the flute in millimeters. public double FluteHeight_mm { get; } Property Value double FluteMaterial Material of the flute. public CutterMaterial FluteMaterial { get; set; } Property Value CutterMaterial FluteMaterialFile Gets or sets the file path for the flute material definition. public string FluteMaterialFile { get; set; } Property Value string Fluting Gets or sets the cutter's fluting — the whole set of flute contours, either one shared baseline repeated evenly around the cutter (UniformFluting) or one contour defined per flute (FreeFluting). public IFluting Fluting { get; set; } Property Value IFluting FullHeight_mm Gets the full height of the cutter in millimeters. public double FullHeight_mm { get; } Property Value double HoneRadius_mm Gets or sets the hone radius in millimeters. public double HoneRadius_mm { get; set; } Property Value double HoneRadius_um Gets the hone radius in micrometers. public double HoneRadius_um { get; set; } Property Value double InnerBeamProfile Gets or sets the inner beam profile. public IShaperProfile InnerBeamProfile { get; set; } Property Value IShaperProfile Remarks InnerBeamProfile may be dependent on ShaperProfile. InnerBeamProfile.ClearCache() and initialization must be performed after ShaperProfile.ClearCache() and initialization. InsertNum Gets or sets Insert Number. The property should be used Only if IntegralMode is InsertEnd. However, there is no exception mechanism. public int InsertNum { get; set; } Property Value int InsertThickness_mm Thickness of an insert. Only available if the cutter is InsertEnd. public double InsertThickness_mm { get; set; } Property Value double IntegralMode Gets or sets the main integral mode of the cutter. public MillingCutter.IntegralModeEnum IntegralMode { get; set; } Property Value MillingCutter.IntegralModeEnum IsSpinningCutter Is cutter spining when machining. public bool IsSpinningCutter { get; } Property Value bool Is cutter spining when machining. MillingCutterOptLimit public MillingCutterOptOption MillingCutterOptLimit { get; set; } Property Value MillingCutterOptOption Name Name. public string Name { get; set; } Property Value string Note Note. public string Note { get; set; } Property Value string ReliefAngle_deg Gets or sets the relief angle in degrees. public double ReliefAngle_deg { get; set; } Property Value double ReliefAngle_rad Gets or sets the relief angle in radians. public double ReliefAngle_rad { get; set; } Property Value double ShankMassAssignmentMode Gets or sets the mass assignment mode for the shank. public MillingCutter.MassAssignmentMode ShankMassAssignmentMode { get; set; } Property Value MillingCutter.MassAssignmentMode ShankMass_g Gets or sets the cutter shank mass in grams. If IntegralMode is SolidEnd, the mass is the full cutter mass. If IntegralMode is InsertEnd, the mass is the shank mass. since the flute mass is assumed small and dynamic depends on the CWE (Cutter-Workpiece-Engagement). public double ShankMass_g { get; set; } Property Value double ShankMaterial Material of the shank. It should be the same with FluteMaterial if the cutter is SolidEnd. public IStructureMaterial ShankMaterial { get; set; } Property Value IStructureMaterial ShankMaterialFile Gets or sets the file path for the shank material definition. It should be the same with FluteMaterialFile if the cutter is SolidEnd. public string ShankMaterialFile { get; set; } Property Value string ShaperProfile Gets or sets the shaper profile that defines the cutter's shape. public IShaperProfile ShaperProfile { get; set; } Property Value IShaperProfile ShaperTopoBrick cutable part of cutter. the part cut the workpiece if overlapped. public ITopoBrick ShaperTopoBrick { get; } Property Value ITopoBrick SingleInsertMass_g Gets or sets the total inserts' mass in grams. The property should be used Only if IntegralMode is InsertEnd. However, there is no exception mechanism. public double SingleInsertMass_g { get; set; } Property Value double StrutTopoBrick uncutable part of cutter. the part triggers collision to workpiece if overlapped. public ITopoBrick StrutTopoBrick { get; } Property Value ITopoBrick SumInsertMass_g Gets the total mass of all inserts in grams calculated from SingleInsertMass_g * InsertNum. public double SumInsertMass_g { get; } Property Value double SurfaceMaterial Gets the surface material of the cutter. public CutterMaterial SurfaceMaterial { get; } Property Value CutterMaterial UpperBeamGeom Gets the upper beam geometry of the cutter. public IGetStl UpperBeamGeom { get; set; } Property Value IGetStl XName Name for XML IO. public static string XName { get; } Property Value string Methods ClearCache() Clears all cached data. public void ClearCache() ClearThermalLayerListCache() Clears the thermal layer list cache. public void ClearThermalLayerListCache() Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor GetAnchoredCollidableNode() Gets the anchored collidable node associated with this object. public IAnchoredCollidableNode GetAnchoredCollidableNode() Returns IAnchoredCollidableNode The anchored collidable node. GetAnchoredCollidables() Gets the list of anchored collidable nodes contained by this stem. public List<IAnchoredCollidableNode> GetAnchoredCollidables() Returns List<IAnchoredCollidableNode> A list of anchored collidable nodes. GetAnchoredDisplayeeList() Gets a list of anchored displayable objects. public List<IAnchoredDisplayee> GetAnchoredDisplayeeList() Returns List<IAnchoredDisplayee> A list of IAnchoredDisplayee objects GetAsmb() Gets the key asmb. public Asmb GetAsmb() Returns Asmb The key asmb. GetCutterFluteDisplayee() Gets the cutter flute displayee for visualization. public IAnchoredDisplayee GetCutterFluteDisplayee() Returns IAnchoredDisplayee The anchored displayee for the cutter flute. GetDeflectionPara_umdN(out double, out double) (L^3)/(3EI). Where deflection = F(L^3)/(3EI). for cantiliver beam. public void GetDeflectionPara_umdN(out double bendingPara_umdN, out double zDeflectionPara_umdN) Parameters bendingPara_umdN double zDeflectionPara_umdN double Exceptions Exception GetFletchBuckle() Get fletch buckle anchor. the anchor that generally connect to fixed part such as ground and triggering(motor)-side. public Anchor GetFletchBuckle() Returns Anchor buckle anchor GetFluteThermalLayerList() Flute material layer From outer(i.e. surface) to inner. public List<ThermalLayer1D> GetFluteThermalLayerList() Returns List<ThermalLayer1D> GetGuessShankMass_g() Get guess mass by volume and density. The volume is count from InnerBeamProfile and UpperBeamGeom. public double GetGuessShankMass_g() Returns double GetInitStickConvex() Get InitStickConvex. public InitStickConvex GetInitStickConvex() Returns InitStickConvex InitStickConvex GetMinimumUncutChipThickness_mm(ICuttingPara) Gets the minimum uncut chip thickness in millimeters for the specified cutting parameters. The value is dependent on HoneRadius_um. Pure computation — deliberately uncached (see GetStagnantAngle_rad(ICuttingPara)); session paths read the value from MillingToolPhysicsPack. public double GetMinimumUncutChipThickness_mm(ICuttingPara millingPara) Parameters millingPara ICuttingPara The cutting parameters to use for calculation. Returns double The minimum uncut chip thickness in millimeters. GetMinimumUncutChipThickness_um(ICuttingPara) Gets the minimum uncut chip thickness in micrometers for the specified cutting parameters. public double GetMinimumUncutChipThickness_um(ICuttingPara millingPara) Parameters millingPara ICuttingPara The cutting parameters to use for calculation. Returns double The minimum uncut chip thickness in micrometers. GetNobleAnchoredDisplayee() Gets a noble anchored displayee for visualization. public AnchoredDisplayee GetNobleAnchoredDisplayee() Returns AnchoredDisplayee The anchored displayee. GetSweptable(double) Get Sweptable. public Sweptable GetSweptable(double fractionTolerance) Parameters fractionTolerance double The fraction tolerance for the sweptable. Returns Sweptable Sweptable GetTestBallCutter() Creates a test ball cutter. public static MillingCutter GetTestBallCutter() Returns MillingCutter A new ball cutter instance for testing. GetTestBottomCutter() Creates a test bottom cutter. public static MillingCutter GetTestBottomCutter() Returns MillingCutter A new bottom cutter instance for testing. GetTestFreeCutter() Creates a test free cutter. public static MillingCutter GetTestFreeCutter() Returns MillingCutter A new free cutter instance for testing. GetThermalLayerList() Gets the list of thermal layers. public List<ThermalLayer1D> GetThermalLayerList() Returns List<ThermalLayer1D> List of thermal layers. GetUpperBeamGeometryIssues() Collects human-readable configuration issues on the upper-beam / shank geometry — the settings that used to surface only as an opaque per-step NullReferenceException cascade inside the thermal physics (e.g. an ExtendedCylinder beam whose FullLength is below the flute height, so the shank solid inverts and Hi.Milling.Cutters.MillingCutter.GetShankThermalZrList() cannot build). Returns (Id, Message) pairs following the structured-id convention of the IMessage channel (e.g. Cutter-UpperBeam–BelowFluteHeight); empty when no upper beam is configured (a legal state — physics runs without a shank) or the beam is consistent. Shared by the physics runner (tool-change ConfigurationError) and the web API (post-edit validation warnings). public List<(string Id, string Message)> GetUpperBeamGeometryIssues() Returns List<(string FilterTitle, string FileExtension)> GetZrList() Gets a list of Z-R coordinate pairs. public List<PairZr> GetZrList() Returns List<PairZr> A list of PairZr objects representing Z-R coordinates. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetShaperStlResolution(PolarResolution2d) Equips the runtime-derived mesh resolution: swaps the shaper solid for one born with resolution and drops the swept-mesh cache; a matching resolution keeps the current solid untouched. Runtime-only — the authored cutter data and its serialized form never carry the value. The strut (upper-beam) solid is equipped by the sibling SetStrutStlResolution(PolarResolution2d). public void SetShaperStlResolution(PolarResolution2d resolution) Parameters resolution PolarResolution2d Runtime-derived mesh resolution; null lets the shaper profile apply its own default. SetStrutStlResolution(PolarResolution2d) Equips the runtime-derived mesh resolution on the strut (upper-beam) solid — the same swap-not-mutate contract as SetShaperStlResolution(PolarResolution2d): a matching resolution keeps the current solid untouched, and the authored cutter data never carries the value. At rest the strut solid stays on its born-with null resolution (the geometry's own default). public void SetStrutStlResolution(PolarResolution2d resolution) Parameters resolution PolarResolution2d Runtime-derived mesh resolution; null lets the geometry apply its own default. UpdateByContent() Updates the object based on its current content. public void UpdateByContent()"
  },
  "api/Hi.Milling.Cutters.MillingCutterEditorDisplayee.ShapeModeEnum.html": {
    "href": "api/Hi.Milling.Cutters.MillingCutterEditorDisplayee.ShapeModeEnum.html",
    "title": "Enum MillingCutterEditorDisplayee.ShapeModeEnum | HiAPI-C# 2025",
    "summary": "Enum MillingCutterEditorDisplayee.ShapeModeEnum Namespace Hi.Milling.Cutters Assembly HiMech.dll Display shape mode for the cutter. public enum MillingCutterEditorDisplayee.ShapeModeEnum Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields DetailPhysicsShape = 1 Render detailed physics-related shapes. SolidBoundingShape = 0 Render only a simplified solid bounding shape."
  },
  "api/Hi.Milling.Cutters.MillingCutterEditorDisplayee.html": {
    "href": "api/Hi.Milling.Cutters.MillingCutterEditorDisplayee.html",
    "title": "Class MillingCutterEditorDisplayee | HiAPI-C# 2025",
    "summary": "Class MillingCutterEditorDisplayee Namespace Hi.Milling.Cutters Assembly HiMech.dll Represents a displayable editor for milling cutter visualization. This class handles the rendering of cutter geometry, including flutes, profiles, and inner structures. Internal Use Only public class MillingCutterEditorDisplayee : IAnchoredDisplayee, IGetAnchor, IGetTopoIndex, IDisplayee, IExpandToBox3d, IClearCache, IDisposable Inheritance object MillingCutterEditorDisplayee Implements IAnchoredDisplayee IGetAnchor IGetTopoIndex IDisplayee IExpandToBox3d IClearCache IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MillingCutterEditorDisplayee() Initializes a new instance of the MillingCutterEditorDisplayee class. public MillingCutterEditorDisplayee() MillingCutterEditorDisplayee(Func<MillingCutter>) Initializes a new instance of the MillingCutterEditorDisplayee class with a milling cutter host. public MillingCutterEditorDisplayee(Func<MillingCutter> millingCutterHost) Parameters millingCutterHost Func<MillingCutter> Function that provides the milling cutter instance Properties MillingCutterSourceFunc Gets or sets the function that provides the milling cutter instance. public Func<MillingCutter> MillingCutterSourceFunc { get; set; } Property Value Func<MillingCutter> ShapeMode Gets or sets the current display shape mode. public MillingCutterEditorDisplayee.ShapeModeEnum ShapeMode { get; set; } Property Value MillingCutterEditorDisplayee.ShapeModeEnum Methods ClearCache() Clears all cached display data. public void ClearCache() Display(Bind) Displays the milling cutter visualization. public void Display(Bind bind) Parameters bind Bind The binding context for display Dispose() Disposes of all resources. public void Dispose() Dispose(bool) Disposes of unmanaged resources. protected virtual void Dispose(bool disposing) Parameters disposing bool True if disposing, false if finalizing ExpandToBox3d(Box3d) Expands the bounding box to include the cutter geometry. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d The destination bounding box to expand GetAnchor() Gets the root anchor point of the cutter. public Anchor GetAnchor() Returns Anchor The cutter tip anchor"
  },
  "api/Hi.Milling.Cutters.html": {
    "href": "api/Hi.Milling.Cutters.html",
    "title": "Namespace Hi.Milling.Cutters | HiAPI-C# 2025",
    "summary": "Namespace Hi.Milling.Cutters Classes AptProfile Represents an APT (Automatically Programmed Tool) based profile for a milling cutter. This profile uses APT definitions to describe the cutter geometry. ConstRatioProfile Represents a constant ratio profile for a milling cutter. This profile maintains a constant ratio between inner and outer radii. CustomSpinningProfile Represents a custom spinning profile for a milling cutter. This profile allows for custom geometry to be used as the cutter profile. CutterUtil Utility class providing extension methods for cutter operations. FluteContourDisplayee Provides display functionality for flute contours in milling cutters. This class handles the visualization of both front and back surfaces of flute contours. Internal Use Only FluteDependentRatioProfile Represents a flute number dependent ratio profile for a milling cutter. This profile determines the ratio between inner and outer radii based on the number of flutes. MillingCutter Represents a milling cutter with its geometric and physical properties. MillingCutterEditorDisplayee Represents a displayable editor for milling cutter visualization. This class handles the rendering of cutter geometry, including flutes, profiles, and inner structures. Internal Use Only Interfaces IShaperProfile Interface defining the shape profile of a cutter flute. Mesh access is resolution-explicit: callers pass their value through GenStl(IPolarResolution2d), or state the profile's own default with a null argument. Enums MillingCutter.IntegralModeEnum Defines the integral mode of the cutter. MillingCutter.MassAssignmentMode Defines the mass assignment mode for the cutter. MillingCutterEditorDisplayee.ShapeModeEnum Display shape mode for the cutter."
  },
  "api/Hi.Milling.Engagements.BitwiseMillingEngagement.html": {
    "href": "api/Hi.Milling.Engagements.BitwiseMillingEngagement.html",
    "title": "Class BitwiseMillingEngagement | HiAPI-C# 2025",
    "summary": "Class BitwiseMillingEngagement Namespace Hi.Milling.Engagements Assembly HiMech.dll Represents a bitwise milling engagement that uses bit arrays to efficiently store engagement information. public class BitwiseMillingEngagement Inheritance object BitwiseMillingEngagement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors BitwiseMillingEngagement(List<PairZr>, List<List<Vec3d>>, SeqPair<Mat4d>, double, double) Initializes a new instance of the BitwiseMillingEngagement class. public BitwiseMillingEngagement(List<PairZr> fluteZrContour, List<List<Vec3d>> orthodoxForwardContours, SeqPair<Mat4d> seqOnToolRunningCoordinate, double zInterval, double rInterval) Parameters fluteZrContour List<PairZr> The flute Z-R contour. orthodoxForwardContours List<List<Vec3d>> The orthodox forward contours. seqOnToolRunningCoordinate SeqPair<Mat4d> The sequence on tool running coordinate. zInterval double The Z interval. rInterval double The R interval. Fields angleIntervalNum Number of angle interval. public const int angleIntervalNum = 64 Field Value int angleInterval_rad angle interval in radian. public const double angleInterval_rad = 0.09817477042468103 Field Value double Properties BottomBits Gets or sets the bottom bits representing bottom engagement. public List<ulong> BottomBits { get; set; } Property Value List<ulong> SideBits Gets or sets the side bits representing side engagement. public List<ulong> SideBits { get; set; } Property Value List<ulong> Methods Delta(BitwiseMillingEngagement, BitwiseMillingEngagement, out int) Contact area difference from engagement1. public static int Delta(BitwiseMillingEngagement engagement0, BitwiseMillingEngagement engagement1, out int deltaIncreaseNum) Parameters engagement0 BitwiseMillingEngagement previous engagement on time line. Null value is accepted. engagement1 BitwiseMillingEngagement current engagement on time line. Null value is accepted. deltaIncreaseNum int The relative increase number of contact area from engagement0 to engagement1. Negative value means the contact area decreased. Returns int Contact area difference ToBottomBitString() Converts the bottom bits to a string representation. public string ToBottomBitString() Returns string A string representation of the bottom bits. ToSideBitString() Converts the side bits to a string representation. public string ToSideBitString() Returns string A string representation of the side bits."
  },
  "api/Hi.Milling.Engagements.EngagementLayer.html": {
    "href": "api/Hi.Milling.Engagements.EngagementLayer.html",
    "title": "Class EngagementLayer | HiAPI-C# 2025",
    "summary": "Class EngagementLayer Namespace Hi.Milling.Engagements Assembly HiMech.dll Represents a layer of engagement between a tool and workpiece. public class EngagementLayer : IWriteBin Inheritance object EngagementLayer Implements IWriteBin Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors EngagementLayer() Initializes a new instance of the EngagementLayer class public EngagementLayer() EngagementLayer(BinaryReader) Initializes a new instance of the EngagementLayer class by reading from a binary stream public EngagementLayer(BinaryReader reader) Parameters reader BinaryReader The binary reader to read the engagement layer data from Properties Dv Gets or sets the interval value (in millimeters) for either Z coordinate (for side engagement) or R coordinate (for bottom engagement) public double Dv { get; set; } Property Value double Ranges Gets or sets the list of angular ranges where the tool engages with the workpiece. Each range represents a start and end angle in radians. public List<Range<double>> Ranges { get; set; } Property Value List<Range<double>> Methods ToString() Returns a string representation of the engagement layer public override string ToString() Returns string A string containing the Dv value and the ranges of engagement angles WriteBin(BinaryWriter) Writes the engagement layer data to a binary stream public void WriteBin(BinaryWriter writer) Parameters writer BinaryWriter The binary writer to write the data to"
  },
  "api/Hi.Milling.Engagements.EngagementSlice.html": {
    "href": "api/Hi.Milling.Engagements.EngagementSlice.html",
    "title": "Class EngagementSlice | HiAPI-C# 2025",
    "summary": "Class EngagementSlice Namespace Hi.Milling.Engagements Assembly HiMech.dll Engagement slice. public class EngagementSlice Inheritance object EngagementSlice Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors EngagementSlice(double, double, double) Initializes a new instance of the EngagementSlice class. public EngagementSlice(double v, double begin, double end) Parameters v double The z or r value. begin double The begin angle in radians. end double The end angle in radians. Fields begin begin angle in radian. public double begin Field Value double end end angle in radian. public double end Field Value double v z or r. public double v Field Value double Methods ToString() Returns a string that represents the current engagement slice. public override string ToString() Returns string A string that represents the current engagement slice."
  },
  "api/Hi.Milling.Engagements.IBitwiseMillingEngagementSupport.html": {
    "href": "api/Hi.Milling.Engagements.IBitwiseMillingEngagementSupport.html",
    "title": "Interface IBitwiseMillingEngagementSupport | HiAPI-C# 2025",
    "summary": "Interface IBitwiseMillingEngagementSupport Namespace Hi.Milling.Engagements Assembly HiMech.dll Interface for classes that support bitwise milling engagement. public interface IBitwiseMillingEngagementSupport Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties BitwiseMillingEngagement Gets or sets the bitwise milling engagement. BitwiseMillingEngagement BitwiseMillingEngagement { get; set; } Property Value BitwiseMillingEngagement"
  },
  "api/Hi.Milling.Engagements.IGetLayerMillingEngagement.html": {
    "href": "api/Hi.Milling.Engagements.IGetLayerMillingEngagement.html",
    "title": "Interface IGetLayerMillingEngagement | HiAPI-C# 2025",
    "summary": "Interface IGetLayerMillingEngagement Namespace Hi.Milling.Engagements Assembly HiMech.dll Interface of GetLayerMillingEngagement(). public interface IGetLayerMillingEngagement Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetLayerMillingEngagement() Get LayerMillingEngagement. LayerMillingEngagement GetLayerMillingEngagement() Returns LayerMillingEngagement LayerMillingEngagement"
  },
  "api/Hi.Milling.Engagements.LayerMillingEngagement.html": {
    "href": "api/Hi.Milling.Engagements.LayerMillingEngagement.html",
    "title": "Class LayerMillingEngagement | HiAPI-C# 2025",
    "summary": "Class LayerMillingEngagement Namespace Hi.Milling.Engagements Assembly HiMech.dll Milling Engagement. public class LayerMillingEngagement : IWriteBin Inheritance object LayerMillingEngagement Implements IWriteBin Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors LayerMillingEngagement() Initializes a new instance of the LayerMillingEngagement class. public LayerMillingEngagement() LayerMillingEngagement(BinaryReader) Ctor. public LayerMillingEngagement(BinaryReader reader) Parameters reader BinaryReader Properties AvgTouchedPeriodRatio Gets the average touched period ratio public double AvgTouchedPeriodRatio { get; } Property Value double BottomEngagements Gets or sets the bottom engagements. Maps R values to engagement layers public SortedList<double, EngagementLayer> BottomEngagements { get; set; } Property Value SortedList<double, EngagementLayer> BottomEngagementsByteArray Gets or sets the bottom engagements as a byte array for serialization public byte[] BottomEngagementsByteArray { get; set; } Property Value byte[] RInterval Gets or sets the R interval, which is equivalent to the Resolution public double RInterval { get; set; } Property Value double Resolution Gets or sets the resolution value for engagement calculations in millimeters public double Resolution { get; set; } Property Value double SideEngagements Gets or sets the side engagements. Maps Z values to engagement layers public SortedList<double, EngagementLayer> SideEngagements { get; set; } Property Value SortedList<double, EngagementLayer> SideEngagementsByteArray Gets or sets the side engagements as a byte array for serialization public byte[] SideEngagementsByteArray { get; set; } Property Value byte[] StepIndex Step index. For database saving. [Key] [DatabaseGenerated(DatabaseGeneratedOption.None)] public int StepIndex { get; set; } Property Value int Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. WriteBin(BinaryWriter) Writes the object's data to a binary stream. public void WriteBin(BinaryWriter writer) Parameters writer BinaryWriter The binary writer to write to"
  },
  "api/Hi.Milling.Engagements.MillingEngagementUtil.html": {
    "href": "api/Hi.Milling.Engagements.MillingEngagementUtil.html",
    "title": "Class MillingEngagementUtil | HiAPI-C# 2025",
    "summary": "Class MillingEngagementUtil Namespace Hi.Milling.Engagements Assembly HiMech.dll Utility of LayerMillingEngagement. public static class MillingEngagementUtil Inheritance object MillingEngagementUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetContoursDrawing(List<List<Vec3d>>) Gets a drawing representation of the contours. public static Drawing GetContoursDrawing(List<List<Vec3d>> contours) Parameters contours List<List<Vec3d>> The list of contours to draw. Returns Drawing A drawing object representing the contours. GetZToDzList(List<double>, double) Get Z to dZ list. The z values, i.e. the key of generated list, are all not repeated with the source z values. The generated z values are interpolated by the source z values. And each of the dz area is the same slope from the original source. public static SortedList<double, double> GetZToDzList(List<double> constantZlopeZs, double resolution) Parameters constantZlopeZs List<double> resolution double Returns SortedList<double, double>"
  },
  "api/Hi.Milling.Engagements.html": {
    "href": "api/Hi.Milling.Engagements.html",
    "title": "Namespace Hi.Milling.Engagements | HiAPI-C# 2025",
    "summary": "Namespace Hi.Milling.Engagements Classes BitwiseMillingEngagement Represents a bitwise milling engagement that uses bit arrays to efficiently store engagement information. EngagementLayer Represents a layer of engagement between a tool and workpiece. EngagementSlice Engagement slice. LayerMillingEngagement Milling Engagement. MillingEngagementUtil Utility of LayerMillingEngagement. Interfaces IBitwiseMillingEngagementSupport Interface for classes that support bitwise milling engagement. IGetLayerMillingEngagement Interface of GetLayerMillingEngagement()."
  },
  "api/Hi.Milling.FluteContours.ConstHelixSideContour.html": {
    "href": "api/Hi.Milling.FluteContours.ConstHelixSideContour.html",
    "title": "Class ConstHelixSideContour | HiAPI-C# 2025",
    "summary": "Class ConstHelixSideContour Namespace Hi.Milling.FluteContours Assembly HiMech.dll Represents a constant helix side contour for milling cutters. public class ConstHelixSideContour : ISideContour, IWorkingContour, IExpandToBox3d, IMakeXmlSource, IUpdateByContent, IClearCache, IEquatable<ConstHelixSideContour> Inheritance object ConstHelixSideContour Implements ISideContour IWorkingContour IExpandToBox3d IMakeXmlSource IUpdateByContent IClearCache IEquatable<ConstHelixSideContour> Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) FluteContourUtil.GetDrawing(ISideContour, out Drawing, out Drawing, out NativeTopoStl3d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ConstHelixSideContour(IGetZrList) Initializes a new instance of the ConstHelixSideContour class. public ConstHelixSideContour(IGetZrList zrListHost) Parameters zrListHost IGetZrList The Z-R list host. ConstHelixSideContour(double, double, IGetZrList) Initializes a new instance of the ConstHelixSideContour class. public ConstHelixSideContour(double helix_rad, double radialRakeAngle_rad, IGetZrList zrListHost) Parameters helix_rad double The helix angle in radians. radialRakeAngle_rad double The radial rake angle in radians. zrListHost IGetZrList The Z-R list host. ConstHelixSideContour(XElement, string, IGetZrList) Initializes a new instance of the ConstHelixSideContour class from XML. public ConstHelixSideContour(XElement src, string baseDirectory, IGetZrList zrListHost) Parameters src XElement The XML element containing the configuration. baseDirectory string The base directory for resolving relative paths. zrListHost IGetZrList The Z-R list host. Properties Helix_deg Helix_rad in degree. public double Helix_deg { get; set; } Property Value double Helix_rad Helix angle in radian. public double Helix_rad { get; set; } Property Value double KeyRange Gets the key range of the flute contour. public Range<double> KeyRange { get; } Property Value Range<double> Remarks For ISideContour, this represents the Z-value range (height range) For IBottomContour, this represents the R-value range (radial range) RadialRakeAngle_deg Gets or sets the radial rake angle in degrees. public double RadialRakeAngle_deg { get; set; } Property Value double RadialRakeAngle_rad Gets or sets the radial rake angle in radians. public double RadialRakeAngle_rad { get; set; } Property Value double RadialReliefAngle_deg Gets or sets the radial relief angle in degrees. public double RadialReliefAngle_deg { get; set; } Property Value double RadialReliefAngle_rad Gets or sets the radial relief angle in radians. public double RadialReliefAngle_rad { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string ZrListHost Gets or sets the Z-R list host. public IGetZrList ZrListHost { get; set; } Property Value IGetZrList Methods ClearCache() Clears the cached data. public void ClearCache() Duplicate(IGetZrList) Creates a duplicate of this contour with a new Z-R list host. public IWorkingContour Duplicate(IGetZrList zrListHost) Parameters zrListHost IGetZrList The new Z-R list host. Returns IWorkingContour A duplicate of this contour. Equals(ConstHelixSideContour) Indicates whether the current object is equal to another object of the same type. public bool Equals(ConstHelixSideContour other) Parameters other ConstHelixSideContour An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. GetSpanContourPosList() Gets a list of span contour positions that define the working contour geometry. public List<SpanContourPos4d> GetSpanContourPosList() Returns List<SpanContourPos4d> A list of SpanContourPos4d objects representing the contour geometry Remarks The positions are ordered: For ISideContour, positions are ordered by ascending Z values For IBottomContour, positions are ordered by ascending R values Note: Future implementation may use List<List<SpanContourPos4d>> for block flute support. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory UpdateByContent() Updates the object based on its current content. public void UpdateByContent()"
  },
  "api/Hi.Milling.FluteContours.FluteContour.html": {
    "href": "api/Hi.Milling.FluteContours.FluteContour.html",
    "title": "Class FluteContour | HiAPI-C# 2025",
    "summary": "Class FluteContour Namespace Hi.Milling.FluteContours Assembly HiMech.dll Represents a flute contour for milling tools. public class FluteContour : IMakeXmlSource, IDisposable, IClearCache Inheritance object FluteContour Implements IMakeXmlSource IDisposable IClearCache Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FluteContour() Initializes a new instance of the FluteContour class public FluteContour() FluteContour(FluteContour, double) Initializes a new instance of the FluteContour class with a source contour and shift angle public FluteContour(FluteContour src, double shiftAngle_rad) Parameters src FluteContour The source flute contour to copy from shiftAngle_rad double The shift angle in radians FluteContour(XElement, string, IProgress<IMessage>, object[]) Initializes a new instance of the FluteContour class from XML data public FluteContour(XElement src, string baseDirectory, IProgress<IMessage> progress, object[] res) Parameters src XElement The source XML element baseDirectory string The base directory for resolving relative paths progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. res object[] Additional resources for initialization Properties BaseBottomContour Gets or sets the base bottom contour of the flute. This represents the original bottom profile before any transformations. public IWorkingContour BaseBottomContour { get; set; } Property Value IWorkingContour BaseSideContour Gets or sets the base side contour of the flute. This represents the original side profile before any transformations. public IWorkingContour BaseSideContour { get; set; } Property Value IWorkingContour SetupAngle_deg Gets or sets the setup angle in degrees. This is a convenience property that converts ShiftAngle_rad to degrees. public double SetupAngle_deg { get; set; } Property Value double ShiftAngle_rad Gets or sets the shift angle in radians. This angle represents the angular offset of the flute from its base position. public double ShiftAngle_rad { get; set; } Property Value double ShiftedBottomContour Gets the shifted bottom contour of the flute. This is the bottom profile after applying the shift angle transformation. public ShiftedWorkingContour ShiftedBottomContour { get; } Property Value ShiftedWorkingContour ShiftedSideContour Gets the shifted side contour of the flute. This is the side profile after applying the shift angle transformation. public ShiftedWorkingContour ShiftedSideContour { get; } Property Value ShiftedWorkingContour XName Gets the XML name for serialization public static string XName { get; } Property Value string Methods ClearCache() Clears any cached data in the flute contour public void ClearCache() Dispose() Releases all resources used by the FluteContour public void Dispose() Dispose(bool) Releases the unmanaged resources used by the FluteContour and optionally releases the managed resources protected virtual void Dispose(bool disposing) Parameters disposing bool true to release both managed and unmanaged resources; false to release only unmanaged resources Duplicate(IGetZrList) Creates a duplicate of this flute contour public FluteContour Duplicate(IGetZrList zrListHost) Parameters zrListHost IGetZrList The host containing Z-R list information Returns FluteContour A new instance of FluteContour with the same properties ExpandToBox3d(Box3d) Expands the given bounding box to include this flute contour public void ExpandToBox3d(Box3d dst) Parameters dst Box3d The bounding box to expand MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory UpdateByContent() Updates the internal state based on the current content public void UpdateByContent()"
  },
  "api/Hi.Milling.FluteContours.FluteContourUtil.html": {
    "href": "api/Hi.Milling.FluteContours.FluteContourUtil.html",
    "title": "Class FluteContourUtil | HiAPI-C# 2025",
    "summary": "Class FluteContourUtil Namespace Hi.Milling.FluteContours Assembly HiMech.dll Provides utility methods for working with flute contours in milling tools. public static class FluteContourUtil Inheritance object FluteContourUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetDrawing(ISideContour, out Drawing, out Drawing, out NativeTopoStl3d) Generates drawing representations for a side contour. public static void GetDrawing(this ISideContour src, out Drawing faceDrawing, out Drawing lineDrawing, out NativeTopoStl3d topoStl) Parameters src ISideContour The source side contour to generate drawings from faceDrawing Drawing Output parameter that receives the face drawing representation lineDrawing Drawing Output parameter that receives the line drawing representation topoStl NativeTopoStl3d Output parameter that receives the STL topology representation Remarks This method creates three different visual representations of the contour: A face drawing showing the surface A line drawing showing the edges An STL representation for 3D visualization The method uses a constant inner radius ratio of 0.4 and calculates appropriate angles for the radial rake to create a smooth transition between the outer and inner surfaces."
  },
  "api/Hi.Milling.FluteContours.FreeFluting.html": {
    "href": "api/Hi.Milling.FluteContours.FreeFluting.html",
    "title": "Class FreeFluting | HiAPI-C# 2025",
    "summary": "Class FreeFluting Namespace Hi.Milling.FluteContours Assembly HiMech.dll A milling cutter's fluting in which every flute is defined individually — each flute carries its own contour, so spacing, helix and rake need not repeat. Use UniformFluting when one baseline contour repeated evenly around the cutter is enough. public class FreeFluting : IFluting, IMakeXmlSource, IExpandToBox3d, IUpdateByContent, IClearCache, IGetFluteNum Inheritance object FreeFluting Implements IFluting IMakeXmlSource IExpandToBox3d IUpdateByContent IClearCache IGetFluteNum Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks This class provides a flexible way to manage multiple flute contours: Supports XML serialization for data persistence Allows arbitrary arrangement of flute contours Implements IFluting for standard fluting functionality Constructors FreeFluting() Initializes a new instance of the FreeFluting class public FreeFluting() FreeFluting(XElement, string, IProgress<IMessage>, object[]) Initializes a new instance of the FreeFluting class from XML data public FreeFluting(XElement src, string baseDirectory, IProgress<IMessage> progress, object[] res) Parameters src XElement The source XML element containing the fluting data baseDirectory string The base directory for resolving relative paths progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. res object[] Additional resources for initialization Properties ContourList Gets or sets the list of flute contours in this fluting public List<FluteContour> ContourList { get; set; } Property Value List<FluteContour> XName Gets the XML name for serialization public static string XName { get; } Property Value string XmlSourceFile public string XmlSourceFile { get; set; } Property Value string Methods ClearCache() Clears any cached data held by the implementing object. public void ClearCache() Duplicate(IGetZrList) Creates a duplicate of this fluting public IFluting Duplicate(IGetZrList zrListHost) Parameters zrListHost IGetZrList The host containing Z-R list information Returns IFluting A new instance of FreeFluting with the same properties ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetFluteContourList() Gets the list of flute contours that make up this fluting. public List<FluteContour> GetFluteContourList() Returns List<FluteContour> A list of flute contours. GetFluteNum() Gets the number of flutes. public int GetFluteNum() Returns int MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory UpdateByContent() Updates the object based on its current content. public void UpdateByContent()"
  },
  "api/Hi.Milling.FluteContours.FreeformBottomContour.html": {
    "href": "api/Hi.Milling.FluteContours.FreeformBottomContour.html",
    "title": "Class FreeformBottomContour | HiAPI-C# 2025",
    "summary": "Class FreeformBottomContour Namespace Hi.Milling.FluteContours Assembly HiMech.dll Represents a freeform bottom contour for milling tools, allowing arbitrary contour shapes. public class FreeformBottomContour : IBottomContour, IWorkingContour, IExpandToBox3d, IMakeXmlSource, IUpdateByContent, IClearCache, IEquatable<FreeformBottomContour> Inheritance object FreeformBottomContour Implements IBottomContour IWorkingContour IExpandToBox3d IMakeXmlSource IUpdateByContent IClearCache IEquatable<FreeformBottomContour> Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks This class provides a flexible way to define bottom contours with custom shapes: Implements IBottomContour for basic bottom contour functionality Supports XML serialization for data persistence Maintains a list of contour positions ordered by R-coordinate (radius) Constructors FreeformBottomContour() Initializes a new instance of the FreeformBottomContour class public FreeformBottomContour() FreeformBottomContour(XElement, string) Initializes a new instance of the FreeformBottomContour class from XML data public FreeformBottomContour(XElement src, string baseDirectory) Parameters src XElement The source XML element containing the contour data baseDirectory string The base directory for resolving relative paths Properties KeyRange Gets the R-value range (radial range) of the contour public Range<double> KeyRange { get; } Property Value Range<double> Remarks The range is calculated from the first and last points in the SpanContourPosList, which are ordered by R-coordinate (radius) SpanContourPosList Gets or sets the list of contour positions ordered by R-coordinate (radius) public List<SpanContourPos4d> SpanContourPosList { get; set; } Property Value List<SpanContourPos4d> Remarks Each position in the list represents a point on the contour with its associated geometric and angular properties XName Gets the XML name for serialization public static string XName { get; } Property Value string Methods ClearCache() Clears the cached key range value public void ClearCache() Duplicate(IGetZrList) Creates a duplicate of this freeform bottom contour public IWorkingContour Duplicate(IGetZrList zrListHost) Parameters zrListHost IGetZrList The host containing Z-R list information Returns IWorkingContour A new instance of FreeformBottomContour with the same properties Equals(FreeformBottomContour) Determines whether the specified FreeformBottomContour is equal to the current FreeformBottomContour public bool Equals(FreeformBottomContour other) Parameters other FreeformBottomContour The FreeformBottomContour to compare with the current FreeformBottomContour Returns bool true if the specified FreeformBottomContour is equal to the current FreeformBottomContour; otherwise, false Equals(object) Determines whether the specified object is equal to the current object public override bool Equals(object obj) Parameters obj object The object to compare with the current object Returns bool true if the specified object is equal to the current object; otherwise, false ExpandToBox3d(Box3d) Expands the given bounding box to include this contour public void ExpandToBox3d(Box3d dst) Parameters dst Box3d The bounding box to expand GetHashCode() Returns a hash code for this instance public override int GetHashCode() Returns int A hash code value based on the contour positions GetSpanContourPosList() Gets the list of span contour positions that define the contour geometry public List<SpanContourPos4d> GetSpanContourPosList() Returns List<SpanContourPos4d> The list of contour positions ordered by R-coordinate (radius) MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory UpdateByContent() Updates the contour's internal state based on its current content public void UpdateByContent()"
  },
  "api/Hi.Milling.FluteContours.FreeformSideContour.html": {
    "href": "api/Hi.Milling.FluteContours.FreeformSideContour.html",
    "title": "Class FreeformSideContour | HiAPI-C# 2025",
    "summary": "Class FreeformSideContour Namespace Hi.Milling.FluteContours Assembly HiMech.dll Represents a freeform side contour for milling tools, allowing arbitrary contour shapes. public class FreeformSideContour : ISideContour, IWorkingContour, IExpandToBox3d, IMakeXmlSource, IUpdateByContent, IClearCache, IEquatable<FreeformSideContour> Inheritance object FreeformSideContour Implements ISideContour IWorkingContour IExpandToBox3d IMakeXmlSource IUpdateByContent IClearCache IEquatable<FreeformSideContour> Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) FluteContourUtil.GetDrawing(ISideContour, out Drawing, out Drawing, out NativeTopoStl3d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks This class provides a flexible way to define side contours with custom shapes: Implements ISideContour for basic side contour functionality Supports XML serialization for data persistence Maintains a list of contour positions ordered by Z-coordinate Constructors FreeformSideContour() Initializes a new instance of the FreeformSideContour class public FreeformSideContour() FreeformSideContour(XElement, string) Initializes a new instance of the FreeformSideContour class from XML data public FreeformSideContour(XElement src, string baseDirectory) Parameters src XElement The source XML element containing the contour data baseDirectory string The base directory for resolving relative paths Properties KeyRange Gets the Z-value range (height range) of the contour public Range<double> KeyRange { get; } Property Value Range<double> Remarks The range is calculated from the first and last points in the SpanContourPosList, which are ordered by Z-coordinate SpanContourPosList Gets or sets the list of contour positions ordered by Z-coordinate public List<SpanContourPos4d> SpanContourPosList { get; set; } Property Value List<SpanContourPos4d> Remarks Each position in the list represents a point on the contour with its associated geometric and angular properties XName Gets the XML name for serialization public static string XName { get; } Property Value string Methods ClearCache() Clears the cached key range value public void ClearCache() Duplicate(IGetZrList) Creates a duplicate of this freeform side contour public IWorkingContour Duplicate(IGetZrList zrListHost) Parameters zrListHost IGetZrList The host containing Z-R list information Returns IWorkingContour A new instance of FreeformSideContour with the same properties Equals(FreeformSideContour) Determines whether the specified FreeformSideContour is equal to the current FreeformSideContour public bool Equals(FreeformSideContour other) Parameters other FreeformSideContour The FreeformSideContour to compare with the current FreeformSideContour Returns bool true if the specified FreeformSideContour is equal to the current FreeformSideContour; otherwise, false Equals(object) Determines whether the specified object is equal to the current object public override bool Equals(object obj) Parameters obj object The object to compare with the current object Returns bool true if the specified object is equal to the current object; otherwise, false ExpandToBox3d(Box3d) Expands the given bounding box to include this contour public void ExpandToBox3d(Box3d dst) Parameters dst Box3d The bounding box to expand GetHashCode() Returns a hash code for this instance public override int GetHashCode() Returns int A hash code value based on the contour positions GetSpanContourPosList() Gets the list of span contour positions that define the contour geometry public List<SpanContourPos4d> GetSpanContourPosList() Returns List<SpanContourPos4d> The list of contour positions ordered by Z-coordinate MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory UpdateByContent() Updates the contour's internal state based on its current content public void UpdateByContent()"
  },
  "api/Hi.Milling.FluteContours.IBottomContour.html": {
    "href": "api/Hi.Milling.FluteContours.IBottomContour.html",
    "title": "Interface IBottomContour | HiAPI-C# 2025",
    "summary": "Interface IBottomContour Namespace Hi.Milling.FluteContours Assembly HiMech.dll Represents a bottom flute contour for milling tools. public interface IBottomContour : IWorkingContour, IMakeXmlSource, IExpandToBox3d, IClearCache Inherited Members IWorkingContour.KeyRange IWorkingContour.GetSpanContourPosList() IWorkingContour.Duplicate(IGetZrList) IMakeXmlSource.MakeXmlSource(string, string, bool) IExpandToBox3d.ExpandToBox3d(Box3d) IClearCache.ClearCache() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks The bottom contour defines the cutting geometry at the bottom of the tool: Implements IWorkingContour for basic contour functionality Uses R-axis values (radius) as the key range for radial operations Provides geometry for bottom cutting operations in milling tools"
  },
  "api/Hi.Milling.FluteContours.IFluteNumSourceProperty.html": {
    "href": "api/Hi.Milling.FluteContours.IFluteNumSourceProperty.html",
    "title": "Interface IFluteNumSourceProperty | HiAPI-C# 2025",
    "summary": "Interface IFluteNumSourceProperty Namespace Hi.Milling.FluteContours Assembly HiMech.dll Interface that requiring a FluteNumSource property. public interface IFluteNumSourceProperty Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties FluteNumSource Gets or sets a delegate that returns the current flute number. Func<int> FluteNumSource { get; set; } Property Value Func<int>"
  },
  "api/Hi.Milling.FluteContours.IFluting.html": {
    "href": "api/Hi.Milling.FluteContours.IFluting.html",
    "title": "Interface IFluting | HiAPI-C# 2025",
    "summary": "Interface IFluting Namespace Hi.Milling.FluteContours Assembly HiMech.dll A milling cutter's fluting: the complete set of flute contours that do the cutting. Either one shared baseline repeated evenly around the cutter (UniformFluting) or one individually defined contour per flute (FreeFluting) — every flute is definable on its own. “Fluting” is the machining noun for a cutter's flute geometry and carries no size of its own, so it describes the flute set of a 4 mm end mill exactly as well as that of a large face mill. public interface IFluting : IMakeXmlSource, IExpandToBox3d, IUpdateByContent, IClearCache, IGetFluteNum Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) IExpandToBox3d.ExpandToBox3d(Box3d) IUpdateByContent.UpdateByContent() IClearCache.ClearCache() IGetFluteNum.GetFluteNum() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods Duplicate(IGetZrList) Creates a duplicate of this fluting. IFluting Duplicate(IGetZrList zrListHost) Parameters zrListHost IGetZrList The host containing Z-R list information. Returns IFluting A new instance of IFluting with the same properties. GetFluteContourList() Gets the list of flute contours that make up this fluting. List<FluteContour> GetFluteContourList() Returns List<FluteContour> A list of flute contours."
  },
  "api/Hi.Milling.FluteContours.IGetFluteNum.html": {
    "href": "api/Hi.Milling.FluteContours.IGetFluteNum.html",
    "title": "Interface IGetFluteNum | HiAPI-C# 2025",
    "summary": "Interface IGetFluteNum Namespace Hi.Milling.FluteContours Assembly HiMech.dll Provides a method to get the number of flutes. public interface IGetFluteNum Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetFluteNum() Gets the number of flutes. int GetFluteNum() Returns int"
  },
  "api/Hi.Milling.FluteContours.ISideContour.html": {
    "href": "api/Hi.Milling.FluteContours.ISideContour.html",
    "title": "Interface ISideContour | HiAPI-C# 2025",
    "summary": "Interface ISideContour Namespace Hi.Milling.FluteContours Assembly HiMech.dll Represents a side flute contour for milling tools. public interface ISideContour : IWorkingContour, IMakeXmlSource, IExpandToBox3d, IClearCache Inherited Members IWorkingContour.KeyRange IWorkingContour.GetSpanContourPosList() IWorkingContour.Duplicate(IGetZrList) IMakeXmlSource.MakeXmlSource(string, string, bool) IExpandToBox3d.ExpandToBox3d(Box3d) IClearCache.ClearCache() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) FluteContourUtil.GetDrawing(ISideContour, out Drawing, out Drawing, out NativeTopoStl3d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks The side contour defines the cutting geometry along the side of the tool: Implements IWorkingContour for basic contour functionality Uses Z-axis values as the key range for height-based operations Provides geometry for side cutting operations in milling tools"
  },
  "api/Hi.Milling.FluteContours.IWorkingContour.html": {
    "href": "api/Hi.Milling.FluteContours.IWorkingContour.html",
    "title": "Interface IWorkingContour | HiAPI-C# 2025",
    "summary": "Interface IWorkingContour Namespace Hi.Milling.FluteContours Assembly HiMech.dll Represents a working contour for cutting operations in milling tools. This interface is implemented by both side contours (ISideContour) and bottom contours (IBottomContour). public interface IWorkingContour : IMakeXmlSource, IExpandToBox3d, IClearCache Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) IExpandToBox3d.ExpandToBox3d(Box3d) IClearCache.ClearCache() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks The working contour provides essential geometry for tool cutting operations: For side contours, the key range represents Z values (height) For bottom contours, the key range represents R values (radius) Properties KeyRange Gets the key range of the flute contour. Range<double> KeyRange { get; } Property Value Range<double> Remarks For ISideContour, this represents the Z-value range (height range) For IBottomContour, this represents the R-value range (radial range) Methods Duplicate(IGetZrList) Creates a duplicate of this working contour. IWorkingContour Duplicate(IGetZrList zrListHost) Parameters zrListHost IGetZrList The host containing Z-R list information for the new contour. Returns IWorkingContour A new instance of IWorkingContour with the same properties and geometry. GetSpanContourPosList() Gets a list of span contour positions that define the working contour geometry. List<SpanContourPos4d> GetSpanContourPosList() Returns List<SpanContourPos4d> A list of SpanContourPos4d objects representing the contour geometry Remarks The positions are ordered: For ISideContour, positions are ordered by ascending Z values For IBottomContour, positions are ordered by ascending R values Note: Future implementation may use List<List<SpanContourPos4d>> for block flute support."
  },
  "api/Hi.Milling.FluteContours.ShiftedWorkingContour.html": {
    "href": "api/Hi.Milling.FluteContours.ShiftedWorkingContour.html",
    "title": "Class ShiftedWorkingContour | HiAPI-C# 2025",
    "summary": "Class ShiftedWorkingContour Namespace Hi.Milling.FluteContours Assembly HiMech.dll Represents a working contour that has been shifted by a specified angle. This class wraps another working contour and applies an angular transformation to it. public class ShiftedWorkingContour : IWorkingContour, IExpandToBox3d, IClearCache, IMakeXmlSource, IEquatable<ShiftedWorkingContour> Inheritance object ShiftedWorkingContour Implements IWorkingContour IExpandToBox3d IClearCache IMakeXmlSource IEquatable<ShiftedWorkingContour> Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ShiftedWorkingContour() Initializes a new instance of the ShiftedWorkingContour class public ShiftedWorkingContour() ShiftedWorkingContour(double, IWorkingContour) Initializes a new instance of the ShiftedWorkingContour class with a specified shift angle and baseline contour public ShiftedWorkingContour(double shiftAngle_rad, IWorkingContour baselineWorkingContour) Parameters shiftAngle_rad double The shift angle in radians baselineWorkingContour IWorkingContour The baseline working contour to be shifted ShiftedWorkingContour(XElement, string, IWorkingContour) Initializes a new instance of the ShiftedWorkingContour class from XML data public ShiftedWorkingContour(XElement src, string baseDirectory, IWorkingContour baselineWorkingContour) Parameters src XElement The source XML element baseDirectory string The base directory for resolving relative paths baselineWorkingContour IWorkingContour The baseline working contour to be shifted Properties BaselineWorkingContour Gets or sets the baseline working contour that is being shifted public IWorkingContour BaselineWorkingContour { get; set; } Property Value IWorkingContour KeyRange Gets the key range of the baseline working contour public Range<double> KeyRange { get; } Property Value Range<double> ShiftAngle_deg Gets or sets the shift angle in degrees public double ShiftAngle_deg { get; set; } Property Value double ShiftAngle_rad Gets or sets the shift angle in radians public double ShiftAngle_rad { get; set; } Property Value double XName Gets the XML name for serialization public static string XName { get; } Property Value string Methods ClearCache() Clears any cached data held by the implementing object. public void ClearCache() Duplicate(IGetZrList) Creates a duplicate of this contour with a new Z-radius list provider. public IWorkingContour Duplicate(IGetZrList zrList) Parameters zrList IGetZrList The Z-radius list provider for the duplicate. Returns IWorkingContour A new instance of ShiftedWorkingContour. Equals(ShiftedWorkingContour) Determines whether the specified ShiftedWorkingContour is equal to the current ShiftedWorkingContour public bool Equals(ShiftedWorkingContour contour) Parameters contour ShiftedWorkingContour The ShiftedWorkingContour to compare with the current ShiftedWorkingContour Returns bool true if the specified ShiftedWorkingContour is equal to the current ShiftedWorkingContour; otherwise, false Equals(object) Determines whether the specified object is equal to the current object public override bool Equals(object obj) Parameters obj object The object to compare with the current object Returns bool true if the specified object is equal to the current object; otherwise, false ExpandToBox3d(Box3d) Expands the given bounding box to include this shifted working contour public void ExpandToBox3d(Box3d dst) Parameters dst Box3d The bounding box to expand GetHashCode() Returns a hash code for this instance public override int GetHashCode() Returns int A hash code value GetSpanContourPosList() Gets the list of span contour positions after applying the shift transformation public List<SpanContourPos4d> GetSpanContourPosList() Returns List<SpanContourPos4d> A list of transformed span contour positions MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Operators operator ==(ShiftedWorkingContour, ShiftedWorkingContour) Determines whether two ShiftedWorkingContour instances are equal public static bool operator ==(ShiftedWorkingContour left, ShiftedWorkingContour right) Parameters left ShiftedWorkingContour The first ShiftedWorkingContour to compare right ShiftedWorkingContour The second ShiftedWorkingContour to compare Returns bool true if the specified ShiftedWorkingContour instances are equal; otherwise, false operator !=(ShiftedWorkingContour, ShiftedWorkingContour) Determines whether two ShiftedWorkingContour instances are not equal public static bool operator !=(ShiftedWorkingContour left, ShiftedWorkingContour right) Parameters left ShiftedWorkingContour The first ShiftedWorkingContour to compare right ShiftedWorkingContour The second ShiftedWorkingContour to compare Returns bool true if the specified ShiftedWorkingContour instances are not equal; otherwise, false"
  },
  "api/Hi.Milling.FluteContours.SideContourDisplayee.html": {
    "href": "api/Hi.Milling.FluteContours.SideContourDisplayee.html",
    "title": "Class SideContourDisplayee | HiAPI-C# 2025",
    "summary": "Class SideContourDisplayee Namespace Hi.Milling.FluteContours Assembly HiMech.dll Represents a displayable side contour. public class SideContourDisplayee : IDisplayee, IExpandToBox3d, IDisposable Inheritance object SideContourDisplayee Implements IDisplayee IExpandToBox3d IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SideContourDisplayee(ISideContour) Initializes a new instance of the SideContourDisplayee class. public SideContourDisplayee(ISideContour sideContourSurface) Parameters sideContourSurface ISideContour The side contour surface to display. Properties SideContourSurface Gets or sets the side contour surface. public ISideContour SideContourSurface { get; set; } Property Value ISideContour Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box ResetDrawingCache() Resets the drawing cache. public void ResetDrawingCache()"
  },
  "api/Hi.Milling.FluteContours.SlideBottomContour.html": {
    "href": "api/Hi.Milling.FluteContours.SlideBottomContour.html",
    "title": "Class SlideBottomContour | HiAPI-C# 2025",
    "summary": "Class SlideBottomContour Namespace Hi.Milling.FluteContours Assembly HiMech.dll Represents a slide bottom contour for milling cutters. public class SlideBottomContour : IBottomContour, IWorkingContour, IMakeXmlSource, IExpandToBox3d, IClearCache Inheritance object SlideBottomContour Implements IBottomContour IWorkingContour IMakeXmlSource IExpandToBox3d IClearCache Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SlideBottomContour() Initializes a new instance of the SlideBottomContour class. public SlideBottomContour() SlideBottomContour(XElement, string) Ctor by XML. public SlideBottomContour(XElement src, string baseDirectory) Parameters src XElement XML baseDirectory string Base directory path for resolving relative paths Properties AxialRakeAngle_deg AxialRakeAngle_rad in degree. public double AxialRakeAngle_deg { get; set; } Property Value double AxialRakeAngle_rad Axial rake angle. Sometimes it is equal to Helix angle from side contour. in radian. public double AxialRakeAngle_rad { get; set; } Property Value double CutterLengthOnBottomProjection_mm cutter length projection from outer edge on bottom plane. public double CutterLengthOnBottomProjection_mm { get; set; } Property Value double DiskAngle_deg angle between bottom surface and horizontal plane. unit is degree. public double DiskAngle_deg { get; set; } Property Value double DiskAngle_rad angle between bottom surface and horizontal plane. unit is radian. public double DiskAngle_rad { get; set; } Property Value double EccentricAngle_deg Gets or sets the eccentric angle in degrees. public double EccentricAngle_deg { get; set; } Property Value double EccentricAngle_rad Projection angle between the line from outer edge tip to center and bottom flute contour on bottom plane. Sometimes it is equal to Radial Rake Angle from side contour. in radian. public double EccentricAngle_rad { get; set; } Property Value double InnerHeight_mm Gets the inner height of the contour in millimeters. public double InnerHeight_mm { get; } Property Value double KeyRange Gets the key range of the flute contour. public Range<double> KeyRange { get; } Property Value Range<double> Remarks For ISideContour, this represents the Z-value range (height range) For IBottomContour, this represents the R-value range (radial range) OuterRadius_mm Gets or sets the outer radius of the contour in millimeters. public double OuterRadius_mm { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods ClearCache() Clears any cached data held by the implementing object. public void ClearCache() Duplicate(IGetZrList) Creates a duplicate of this contour with the specified ZR list host. public IWorkingContour Duplicate(IGetZrList zrListHost) Parameters zrListHost IGetZrList The ZR list host to use for the duplicate Returns IWorkingContour A new working contour instance ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetSpanContourPos4d(double) public SpanContourPos4d GetSpanContourPos4d(double r) Parameters r double specific radius Returns SpanContourPos4d GetSpanContourPosList() Gets a list of span contour positions that define the working contour geometry. public List<SpanContourPos4d> GetSpanContourPosList() Returns List<SpanContourPos4d> A list of SpanContourPos4d objects representing the contour geometry Remarks The positions are ordered: For ISideContour, positions are ordered by ascending Z values For IBottomContour, positions are ordered by ascending R values Note: Future implementation may use List<List<SpanContourPos4d>> for block flute support. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Milling.FluteContours.SpanContourPos4d.html": {
    "href": "api/Hi.Milling.FluteContours.SpanContourPos4d.html",
    "title": "Class SpanContourPos4d | HiAPI-C# 2025",
    "summary": "Class SpanContourPos4d Namespace Hi.Milling.FluteContours Assembly HiMech.dll Represents a position in 4D space (r, theta, z, radial angle) for contour spans public class SpanContourPos4d : IAdditionOperators<SpanContourPos4d, SpanContourPos4d, SpanContourPos4d>, IMultiplyOperators<SpanContourPos4d, double, SpanContourPos4d>, IDivisionOperators<SpanContourPos4d, double, SpanContourPos4d>, ICsvRowIo Inheritance object SpanContourPos4d Implements IAdditionOperators<SpanContourPos4d, SpanContourPos4d, SpanContourPos4d> IMultiplyOperators<SpanContourPos4d, double, SpanContourPos4d> IDivisionOperators<SpanContourPos4d, double, SpanContourPos4d> ICsvRowIo Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SpanContourPos4d() Initializes a new instance of the SpanContourPos4d class public SpanContourPos4d() SpanContourPos4d(Polar3d, double) Initializes a new instance of the SpanContourPos4d class with specified polar coordinates and radial angle public SpanContourPos4d(Polar3d polar, double radialAngle_rad) Parameters polar Polar3d The polar coordinates radialAngle_rad double The radial angle in radians SpanContourPos4d(SpanContourPos4d) Initializes a new instance of the SpanContourPos4d class by copying another instance public SpanContourPos4d(SpanContourPos4d src) Parameters src SpanContourPos4d The source instance to copy from Properties CsvText Gets or sets the CSV text representation of this instance public string CsvText { get; set; } Property Value string CsvTitleText Gets the CSV title text for this instance public string CsvTitleText { get; } Property Value string Polar Gets or sets the polar coordinates (r, theta, z) public Polar3d Polar { get; set; } Property Value Polar3d RadialAngle_deg Gets or sets the radial angle in degrees public double RadialAngle_deg { get; set; } Property Value double RadialAngle_rad Gets or sets the radial angle in radians. The radial angle is the angle between surface and radial line. The radial line is the line vertical to the z-axis for side flute or vertical to the r-axis for bottom flute. public double RadialAngle_rad { get; set; } Property Value double StaticCsvTitleText Gets the static CSV title text for the class public static string StaticCsvTitleText { get; } Property Value string Operators operator +(SpanContourPos4d, SpanContourPos4d) Plus. public static SpanContourPos4d operator +(SpanContourPos4d a, SpanContourPos4d b) Parameters a SpanContourPos4d a b SpanContourPos4d b Returns SpanContourPos4d ContourSurfacePos4d(a.Polar+b.Polar,a.RadialAngle_rad+b.RadialAngle_rad) operator /(SpanContourPos4d, double) Get a new object from a scaled by 1/d. public static SpanContourPos4d operator /(SpanContourPos4d a, double d) Parameters a SpanContourPos4d a d double denominator Returns SpanContourPos4d result operator *(SpanContourPos4d, double) Scale a by s. public static SpanContourPos4d operator *(SpanContourPos4d a, double s) Parameters a SpanContourPos4d value s double scale Returns SpanContourPos4d ContourSurfacePos4d(a.Polar * s, a.RadialAngle_rad * s) operator -(SpanContourPos4d, SpanContourPos4d) Plus. public static SpanContourPos4d operator -(SpanContourPos4d a, SpanContourPos4d b) Parameters a SpanContourPos4d a b SpanContourPos4d b Returns SpanContourPos4d ContourSurfacePos4d(a.Polar - b.Polar, a.RadialAngle_rad - b.RadialAngle_rad)"
  },
  "api/Hi.Milling.FluteContours.UniformFluting.html": {
    "href": "api/Hi.Milling.FluteContours.UniformFluting.html",
    "title": "Class UniformFluting | HiAPI-C# 2025",
    "summary": "Class UniformFluting Namespace Hi.Milling.FluteContours Assembly HiMech.dll A milling cutter's fluting built from one shared baseline contour repeated evenly around the cutter: every flute has the same geometry, spaced at equal angles. Use FreeFluting when the flutes need to be defined individually. public class UniformFluting : IFluting, IMakeXmlSource, IExpandToBox3d, IGetFluteNum, IUpdateByContent, IClearCache Inheritance object UniformFluting Implements IFluting IMakeXmlSource IExpandToBox3d IGetFluteNum IUpdateByContent IClearCache Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors UniformFluting() Initializes a new instance of the UniformFluting class. public UniformFluting() UniformFluting(XElement, string, IProgress<IMessage>, object[]) Ctor. public UniformFluting(XElement src, string baseDirectory, IProgress<IMessage> progress, object[] res) Parameters src XElement XML baseDirectory string Base directory path for resolving relative paths progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. res object[] Additional optional resources Properties BaselineContourShiftAngle_deg Gets or sets the baseline contour shift angle in degrees. public double BaselineContourShiftAngle_deg { get; set; } Property Value double BaselineOneContour Gets or sets the baseline contour. public FluteContour BaselineOneContour { get; set; } Property Value FluteContour TrackNum Gets or sets the number of flutes this fluting repeats the baseline contour into. public int TrackNum { get; set; } Property Value int XName Name for XML IO. public static string XName { get; } Property Value string Methods ClearCache() Clears any cached data held by the implementing object. public void ClearCache() Duplicate(IGetZrList) Creates a duplicate of this fluting with the specified ZR list host. public IFluting Duplicate(IGetZrList zrListHost) Parameters zrListHost IGetZrList The ZR list host to use for the duplicate Returns IFluting A new fluting instance ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetFluteContourList() Gets the list of flute contours that make up this fluting. public List<FluteContour> GetFluteContourList() Returns List<FluteContour> A list of flute contours. GetFluteNum() Gets the number of flutes. public int GetFluteNum() Returns int The number of flutes. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory UpdateByContent() Updates the object based on its current content. public void UpdateByContent()"
  },
  "api/Hi.Milling.FluteContours.html": {
    "href": "api/Hi.Milling.FluteContours.html",
    "title": "Namespace Hi.Milling.FluteContours | HiAPI-C# 2025",
    "summary": "Namespace Hi.Milling.FluteContours Classes ConstHelixSideContour Represents a constant helix side contour for milling cutters. FluteContour Represents a flute contour for milling tools. FluteContourUtil Provides utility methods for working with flute contours in milling tools. FreeFluting A milling cutter's fluting in which every flute is defined individually — each flute carries its own contour, so spacing, helix and rake need not repeat. Use UniformFluting when one baseline contour repeated evenly around the cutter is enough. FreeformBottomContour Represents a freeform bottom contour for milling tools, allowing arbitrary contour shapes. FreeformSideContour Represents a freeform side contour for milling tools, allowing arbitrary contour shapes. ShiftedWorkingContour Represents a working contour that has been shifted by a specified angle. This class wraps another working contour and applies an angular transformation to it. SideContourDisplayee Represents a displayable side contour. SlideBottomContour Represents a slide bottom contour for milling cutters. SpanContourPos4d Represents a position in 4D space (r, theta, z, radial angle) for contour spans UniformFluting A milling cutter's fluting built from one shared baseline contour repeated evenly around the cutter: every flute has the same geometry, spaced at equal angles. Use FreeFluting when the flutes need to be defined individually. Interfaces IBottomContour Represents a bottom flute contour for milling tools. IFluteNumSourceProperty Interface that requiring a FluteNumSource property. IFluting A milling cutter's fluting: the complete set of flute contours that do the cutting. Either one shared baseline repeated evenly around the cutter (UniformFluting) or one individually defined contour per flute (FreeFluting) — every flute is definable on its own. “Fluting” is the machining noun for a cutter's flute geometry and carries no size of its own, so it describes the flute set of a 4 mm end mill exactly as well as that of a large face mill. IGetFluteNum Provides a method to get the number of flutes. ISideContour Represents a side flute contour for milling tools. IWorkingContour Represents a working contour for cutting operations in milling tools. This interface is implemented by both side contours (ISideContour) and bottom contours (IBottomContour)."
  },
  "api/Hi.Milling.IGetDiameter.html": {
    "href": "api/Hi.Milling.IGetDiameter.html",
    "title": "Interface IGetDiameter | HiAPI-C# 2025",
    "summary": "Interface IGetDiameter Namespace Hi.Milling Assembly HiGeom.dll Interface for objects that provide diameter information. public interface IGetDiameter Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Diameter_mm Gets the diameter in millimeters. double Diameter_mm { get; } Property Value double"
  },
  "api/Hi.Milling.IGetFluteHeight.html": {
    "href": "api/Hi.Milling.IGetFluteHeight.html",
    "title": "Interface IGetFluteHeight | HiAPI-C# 2025",
    "summary": "Interface IGetFluteHeight Namespace Hi.Milling Assembly HiGeom.dll Interface for objects that provide flute height information. public interface IGetFluteHeight Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties FluteHeight_mm Gets the height of the flute in millimeters. double FluteHeight_mm { get; } Property Value double"
  },
  "api/Hi.Milling.IGetMillingGeomBrief.html": {
    "href": "api/Hi.Milling.IGetMillingGeomBrief.html",
    "title": "Interface IGetMillingGeomBrief | HiAPI-C# 2025",
    "summary": "Interface IGetMillingGeomBrief Namespace Hi.Milling Assembly HiGeom.dll Interface for retrieving milling geometry brief information. public interface IGetMillingGeomBrief Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetMillingGeomBrief() Gets the milling geometry brief information. MillingGeomBrief GetMillingGeomBrief() Returns MillingGeomBrief The milling geometry brief information."
  },
  "api/Hi.Milling.IGetRadialReliefAngle.html": {
    "href": "api/Hi.Milling.IGetRadialReliefAngle.html",
    "title": "Interface IGetRadialReliefAngle | HiAPI-C# 2025",
    "summary": "Interface IGetRadialReliefAngle Namespace Hi.Milling Assembly HiGeom.dll Interface for objects that provide radial relief angle information. public interface IGetRadialReliefAngle Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties RadialReliefAngle_rad Gets the radial relief angle in radians. double RadialReliefAngle_rad { get; } Property Value double"
  },
  "api/Hi.Milling.IMillingGeomBriefAccessor.html": {
    "href": "api/Hi.Milling.IMillingGeomBriefAccessor.html",
    "title": "Interface IMillingGeomBriefAccessor | HiAPI-C# 2025",
    "summary": "Interface IMillingGeomBriefAccessor Namespace Hi.Milling Assembly HiGeom.dll Interface for accessing and modifying milling geometry brief information. public interface IMillingGeomBriefAccessor : IGetMillingGeomBrief Inherited Members IGetMillingGeomBrief.GetMillingGeomBrief() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties MillingGeomBrief Gets or sets the milling geometry brief information. MillingGeomBrief MillingGeomBrief { get; set; } Property Value MillingGeomBrief"
  },
  "api/Hi.Milling.MillingGeomBrief.html": {
    "href": "api/Hi.Milling.MillingGeomBrief.html",
    "title": "Class MillingGeomBrief | HiAPI-C# 2025",
    "summary": "Class MillingGeomBrief Namespace Hi.Milling Assembly HiGeom.dll Brief of milling geometry. public class MillingGeomBrief : IGetMillingGeomBrief, IGetQuantityByKey, IGetCsvDictionary Inheritance object MillingGeomBrief Implements IGetMillingGeomBrief IGetQuantityByKey IGetCsvDictionary Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MillingGeomBrief() Ctor. public MillingGeomBrief() MillingGeomBrief(DVec3d, Vec3d, bool?, double, double, double, double) Ctor. public MillingGeomBrief(DVec3d cl, Vec3d movingDirection, bool? isTouched, double radialWidth, double axialDepth, double mrr_mm3ds, double chipThickness) Parameters cl DVec3d cutter location movingDirection Vec3d moving direction on Workpiece Coordinate isTouched bool? is touched radialWidth double radial width axialDepth double axial depth mrr_mm3ds double meterial removal rate mm3/s chipThickness double chip thickness Properties AxialDepth Axial depth. public double AxialDepth { get; set; } Property Value double ChipThickness Max chip thickness in mm. public double ChipThickness { get; set; } Property Value double Cl Cutter location. public DVec3d Cl { get; set; } Property Value DVec3d IsTouched Is touched. public bool? IsTouched { get; set; } Property Value bool? MovingDirectionOnWorkpieceCoordinate Moving direction on Workpiece Coordinate public Vec3d MovingDirectionOnWorkpieceCoordinate { get; set; } Property Value Vec3d Mrr_mm3ds Material removal rate. Unit: mm3/s. public double Mrr_mm3ds { get; set; } Property Value double RadialWidth Radial width. public double RadialWidth { get; set; } Property Value double Methods GetCsvDictionary() Get row dictionary. It suits for CSV output. public Dictionary<string, string> GetCsvDictionary() Returns Dictionary<string, string> csv row dictionary GetMillingGeomBrief() Gets the milling geometry brief information. public MillingGeomBrief GetMillingGeomBrief() Returns MillingGeomBrief The milling geometry brief information. GetQuantityByKey(string) Gets a quantity value associated with the specified key. public double GetQuantityByKey(string key) Parameters key string The key to look up Returns double The quantity value associated with the key GetQuantityDictionary() public Dictionary<string, double> GetQuantityDictionary() Returns Dictionary<string, double> SetByCsvDictionary(Dictionary<string, string>, bool) Sets the properties of this object from a CSV dictionary. public void SetByCsvDictionary(Dictionary<string, string> src, bool removeFromSource = false) Parameters src Dictionary<string, string> The source dictionary containing property values as strings removeFromSource bool If true, removes the entries from the source dictionary after retrieving them"
  },
  "api/Hi.Milling.MillingRemovalUtil.html": {
    "href": "api/Hi.Milling.MillingRemovalUtil.html",
    "title": "Class MillingRemovalUtil | HiAPI-C# 2025",
    "summary": "Class MillingRemovalUtil Namespace Hi.Milling Assembly HiMech.dll Utility for milling removal. public static class MillingRemovalUtil Inheritance object MillingRemovalUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetContoursOnToolRunningCoordinate(Substraction, MachineMotionStep) Gets contours on tool running coordinate from a subtraction. public static List<List<Vec3d>> GetContoursOnToolRunningCoordinate(this Substraction substraction, MachineMotionStep machineStep) Parameters substraction Substraction The subtraction containing contact contours. machineStep MachineMotionStep The machining step with coordinate transformation. Returns List<List<Vec3d>> List of contours on tool running coordinate. GetMrr_mm3ds(List<List<Vec3d>>, Vec3d, double) Calculates the material removal rate in cubic millimeters per second. public static double GetMrr_mm3ds(List<List<Vec3d>> contoursOnToolRunningCoordinate, Vec3d movingDirectionOnToolRunningCoordinate, double feedrate_mmds) Parameters contoursOnToolRunningCoordinate List<List<Vec3d>> Contours on tool running coordinate. movingDirectionOnToolRunningCoordinate Vec3d Moving direction on tool running coordinate. feedrate_mmds double Feed rate in millimeters per second. Returns double Material removal rate in cubic millimeters per second."
  },
  "api/Hi.Milling.MillingTools.MillingTool.html": {
    "href": "api/Hi.Milling.MillingTools.MillingTool.html",
    "title": "Class MillingTool | HiAPI-C# 2025",
    "summary": "Class MillingTool Namespace Hi.Milling.MillingTools Assembly HiMech.dll Represents a central stick milling tool that combines a holder and a cutter. public class MillingTool : IMachiningTool, IDisplayee, IExpandToBox3d, ITopo, IGetAsmb, IGetAnchor, IGetTopoIndex, IGetAnchoredDisplayeeList, IGetFletchBuckle, IMakeXmlSource, IAbstractNote, IDuplicate, IClearCache, IGetFluteNum Inheritance object MillingTool Implements IMachiningTool IDisplayee IExpandToBox3d ITopo IGetAsmb IGetAnchor IGetTopoIndex IGetAnchoredDisplayeeList IGetFletchBuckle IMakeXmlSource IAbstractNote IDuplicate IClearCache IGetFluteNum Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) MillingToolUtil.GetFullH(IMachiningTool) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) TopoDisplayeeUtil.Display(ITopo, Bind) TopoDisplayeeUtil.ExpandToBox3d(ITopo, Box3d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MillingTool() Ctor. public MillingTool() MillingTool(XElement, string, string, IProgress<IMessage>) Initializes a new instance of the MillingTool class. public MillingTool(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress) Parameters src XElement The XML element containing the tool configuration. baseDirectory string The base directory for resolving relative paths. relFile string The relative file path. progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. Properties AbstractNote Gets an abstract note describing the tool's dimensions and cutter. public string AbstractNote { get; } Property Value string Asmb Gets the assembly containing the tool components. public Asmb Asmb { get; } Property Value Asmb Cutter Gets the cutting tool. public ICutter Cutter { get; set; } Property Value ICutter CutterFile Gets or sets the file path of the cutter. public string CutterFile { get; set; } Property Value string ExposedCutterBendingPara_umdN Gets the parameter for exposed cutter bending in micrometers per Newton. Pure computation — deliberately uncached: a lazy cache on this shared object races with the parallel per-step force build; per-step session paths read the pair from MillingToolPhysicsPack instead. public double ExposedCutterBendingPara_umdN { get; } Property Value double ExposedCutterHeight_mm Gets or sets the exposed cutter height in millimeters. public double ExposedCutterHeight_mm { get; set; } Property Value double ExposedCutterZDeflectionPara_umdN Gets the parameter for exposed cutter Z-axis deflection in micrometers per Newton. Pure computation — see ExposedCutterBendingPara_umdN. public double ExposedCutterZDeflectionPara_umdN { get; } Property Value double Holder Gets or sets the tool holder. public IHolder Holder { get; set; } Property Value IHolder HolderFile Gets or sets the holder file path. public string HolderFile { get; set; } Property Value string Note Gets or sets a note for this machining tool. public string Note { get; set; } Property Value string ObservationAnchor Gets the tool anchor reference point. public Anchor ObservationAnchor { get; } Property Value Anchor ObservationAnchorReference Gets the tool observation anchor reference point. public MillingToolAnchorReference ObservationAnchorReference { get; set; } Property Value MillingToolAnchorReference ObservationHeightFromToolTip Gets the tool observation point relative to the reference. Pure computation (an Asmb walk) — deliberately uncached; per-step session paths read the value from MillingToolPhysicsPack. public double ObservationHeightFromToolTip { get; } Property Value double ObservationRingRadius_mm Obsoleted. Gets the tool observation reference point. public double ObservationRingRadius_mm { get; set; } Property Value double PreservedDistanceBetweenFluteAndSpindleNose_mm Gets or sets the preserved distance between flute and clamp in millimeters. public double PreservedDistanceBetweenFluteAndSpindleNose_mm { get; set; } Property Value double RelativeHeightFromObservationAnchor_mm Gets the tool observation point relative to the reference. public double RelativeHeightFromObservationAnchor_mm { get; set; } Property Value double SpindleBuckle Gets the motor-side buckle. public Anchor SpindleBuckle { get; } Property Value Anchor SpindleBuckleToToolTipLength Height For NC Compensation table and step number computation. Pure computation (an Asmb walk) — deliberately uncached: a lazy cache on this shared object races with concurrent readers; hot session paths read the value from MillingToolPhysicsPack (per step) or a run-scoped memo (CL parsing). public double SpindleBuckleToToolTipLength { get; } Property Value double ToolTip Gets the tool tip anchor point from the cutter. public Anchor ToolTip { get; } Property Value Anchor XName Initializes a new instance of the StickMachiningTool class from XML data. public static string XName { get; } Property Value string Methods AlignAnchorByExposedCutterHeight() Aligns the anchor by the exposed cutter height. public void AlignAnchorByExposedCutterHeight() ClearCache() Clears any cached data held by the implementing object. public void ClearCache() Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box Remarks For display GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor GetAnchoredDisplayeeList() Gets a list of anchored displayable objects. public List<IAnchoredDisplayee> GetAnchoredDisplayeeList() Returns List<IAnchoredDisplayee> A list of IAnchoredDisplayee objects GetAsmb() Gets the key asmb. public Asmb GetAsmb() Returns Asmb The key asmb. GetFletchBuckle() Get fletch buckle anchor. the anchor that generally connect to fixed part such as ground and triggering(motor)-side. public Anchor GetFletchBuckle() Returns Anchor buckle anchor GetFluteNum() Gets the number of flutes. public int GetFluteNum() Returns int MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Milling.MillingTools.MillingToolAnchorReference.html": {
    "href": "api/Hi.Milling.MillingTools.MillingToolAnchorReference.html",
    "title": "Enum MillingToolAnchorReference | HiAPI-C# 2025",
    "summary": "Enum MillingToolAnchorReference Namespace Hi.Milling.MillingTools Assembly HiMech.dll Defines reference points for anchoring milling tools. public enum MillingToolAnchorReference Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields HolderAnc = 2 The holder anchor as the reference point. None = 0 No specific anchor reference point. SpindleBuckleAnc = 4 The spindle buckle anchor as the reference point. ToolTip = 1 The tool tip as the anchor reference point."
  },
  "api/Hi.Milling.MillingTools.MillingToolEditorDisplayee.html": {
    "href": "api/Hi.Milling.MillingTools.MillingToolEditorDisplayee.html",
    "title": "Class MillingToolEditorDisplayee | HiAPI-C# 2025",
    "summary": "Class MillingToolEditorDisplayee Namespace Hi.Milling.MillingTools Assembly HiMech.dll Display host for a milling tool composed of a cutter and a holder. public class MillingToolEditorDisplayee : ITopoDisplayee, ITopo, IGetAsmb, IGetAnchoredDisplayeeList, IAnchoredDisplayee, IGetAnchor, IGetTopoIndex, IDisplayee, IExpandToBox3d, IClearCache Inheritance object MillingToolEditorDisplayee Implements ITopoDisplayee ITopo IGetAsmb IGetAnchoredDisplayeeList IAnchoredDisplayee IGetAnchor IGetTopoIndex IDisplayee IExpandToBox3d IClearCache Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) TopoDisplayeeUtil.Display(ITopo, Bind) TopoDisplayeeUtil.ExpandToBox3d(ITopo, Box3d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties HolderEditorDisplayee Gets the displayee for the holder. public HolderEditorDisplayee HolderEditorDisplayee { get; } Property Value HolderEditorDisplayee MillingCutterEditorDisplayee Gets the displayee for the milling cutter. public MillingCutterEditorDisplayee MillingCutterEditorDisplayee { get; } Property Value MillingCutterEditorDisplayee MillingTool Gets the current MillingTool instance. public MillingTool MillingTool { get; } Property Value MillingTool MillingToolGetter Gets or sets the delegate that provides the MillingTool instance. public Func<MillingTool> MillingToolGetter { get; set; } Property Value Func<MillingTool> ShowCutter Gets or sets whether to show the cutter. public bool ShowCutter { get; set; } Property Value bool ShowHolder Gets or sets whether to show the holder. public bool ShowHolder { get; set; } Property Value bool Methods ClearCache() Clears any cached data held by the implementing object. public void ClearCache() Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor GetAnchoredDisplayeeList() Gets a list of anchored displayable objects. public List<IAnchoredDisplayee> GetAnchoredDisplayeeList() Returns List<IAnchoredDisplayee> A list of IAnchoredDisplayee objects GetAsmb() Gets the key asmb. public Asmb GetAsmb() Returns Asmb The key asmb."
  },
  "api/Hi.Milling.MillingTools.MillingToolPhysicsPack.html": {
    "href": "api/Hi.Milling.MillingTools.MillingToolPhysicsPack.html",
    "title": "Class MillingToolPhysicsPack | HiAPI-C# 2025",
    "summary": "Class MillingToolPhysicsPack Namespace Hi.Milling.MillingTools Assembly HiMech.dll The scalar physics derivations of one tool (and one cutting-parameter set), computed once on a sequential boundary and frozen. The per-step force build, the sequential physics, and the step/shot writers read these values thousands to millions of times per play; the tool and cutter objects themselves expose them as deliberately uncached pure computations, so hot session paths read this pack instead — callers outside a session simply pass null and the pure computation runs on use. Owned per session by MachiningSession, keyed by tool id. A pack is never updated in place: the paths that change tool/cutter/para state invalidate the session's packs explicitly (run-op start, tool change — see MachiningSession.InvalidateToolPhysicsPacks), and IsStaleFor(IMachiningTool, ICuttingPara) re-keys on object replacement. public sealed record MillingToolPhysicsPack : IEquatable<MillingToolPhysicsPack> Inheritance object MillingToolPhysicsPack Implements IEquatable<MillingToolPhysicsPack> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MillingToolPhysicsPack(IMachiningTool, ICuttingPara, double, double, double, double, double, double, double) The scalar physics derivations of one tool (and one cutting-parameter set), computed once on a sequential boundary and frozen. The per-step force build, the sequential physics, and the step/shot writers read these values thousands to millions of times per play; the tool and cutter objects themselves expose them as deliberately uncached pure computations, so hot session paths read this pack instead — callers outside a session simply pass null and the pure computation runs on use. Owned per session by MachiningSession, keyed by tool id. A pack is never updated in place: the paths that change tool/cutter/para state invalidate the session's packs explicitly (run-op start, tool change — see MachiningSession.InvalidateToolPhysicsPacks), and IsStaleFor(IMachiningTool, ICuttingPara) re-keys on object replacement. public MillingToolPhysicsPack(IMachiningTool Tool, ICuttingPara Para, double SpindleBuckleToToolTipLength, double ObservationHeightFromToolTip, double EffectiveCuttingDiameter_mm, double BendingPara_umdN, double ZDeflectionPara_umdN, double FakeRakeAngle_rad, double MinimumUncutChipThickness_mm) Parameters Tool IMachiningTool The tool the pack was built from. Para ICuttingPara The cutting-parameter set the para-dependent members were built from (may be null). SpindleBuckleToToolTipLength double See SpindleBuckleToToolTipLength. ObservationHeightFromToolTip double See ObservationHeightFromToolTip; NaN when the tool is not a MillingTool. EffectiveCuttingDiameter_mm double See EffectiveCuttingDiameter_mm; NaN without a MillingCutter. BendingPara_umdN double See ExposedCutterBendingPara_umdN; NaN when the deflection geometry is degenerate (the pure getter throws there instead — the pack stays buildable so geometry-only paths keep working). ZDeflectionPara_umdN double The pair member of BendingPara_umdN — see ExposedCutterZDeflectionPara_umdN. FakeRakeAngle_rad double The simplified (side/bottom averaged) rake angle; NaN without a MillingCutter. MinimumUncutChipThickness_mm double See GetMinimumUncutChipThickness_mm(ICuttingPara) for Para. Properties BendingPara_umdN See ExposedCutterBendingPara_umdN; NaN when the deflection geometry is degenerate (the pure getter throws there instead — the pack stays buildable so geometry-only paths keep working). public double BendingPara_umdN { get; init; } Property Value double EffectiveCuttingDiameter_mm See EffectiveCuttingDiameter_mm; NaN without a MillingCutter. public double EffectiveCuttingDiameter_mm { get; init; } Property Value double FakeRakeAngle_rad The simplified (side/bottom averaged) rake angle; NaN without a MillingCutter. public double FakeRakeAngle_rad { get; init; } Property Value double MinimumUncutChipThickness_mm See GetMinimumUncutChipThickness_mm(ICuttingPara) for Para. public double MinimumUncutChipThickness_mm { get; init; } Property Value double ObservationHeightFromToolTip See ObservationHeightFromToolTip; NaN when the tool is not a MillingTool. public double ObservationHeightFromToolTip { get; init; } Property Value double Para The cutting-parameter set the para-dependent members were built from (may be null). public ICuttingPara Para { get; init; } Property Value ICuttingPara SpindleBuckleToToolTipLength See SpindleBuckleToToolTipLength. public double SpindleBuckleToToolTipLength { get; init; } Property Value double Tool The tool the pack was built from. public IMachiningTool Tool { get; init; } Property Value IMachiningTool ZDeflectionPara_umdN The pair member of BendingPara_umdN — see ExposedCutterZDeflectionPara_umdN. public double ZDeflectionPara_umdN { get; init; } Property Value double Methods Build(IMachiningTool, ICuttingPara) Builds a pack from the tool's (and cutter's) pure computations. Call on a sequential boundary (session/play start, tool change) or ad hoc from a no-session caller that wants the values bundled. public static MillingToolPhysicsPack Build(IMachiningTool tool, ICuttingPara para) Parameters tool IMachiningTool The tool to derive from; null yields null. para ICuttingPara The cutting-parameter set for the para-dependent members; may be null. Returns MillingToolPhysicsPack The frozen pack, or null when tool is null. IsStaleFor(IMachiningTool, ICuttingPara) Whether this pack was built from different objects than the live ones — a replaced tool under the same id, or a swapped cutting para. In-place edits are not detected here; they are covered by the explicit invalidation points (MachiningSession.InvalidateToolPhysicsPacks). public bool IsStaleFor(IMachiningTool tool, ICuttingPara para) Parameters tool IMachiningTool The live tool to compare against. para ICuttingPara The live cutting-parameter set to compare against. Returns bool True when the pack must be rebuilt."
  },
  "api/Hi.Milling.MillingTools.MillingToolUtil.html": {
    "href": "api/Hi.Milling.MillingTools.MillingToolUtil.html",
    "title": "Class MillingToolUtil | HiAPI-C# 2025",
    "summary": "Class MillingToolUtil Namespace Hi.Milling.MillingTools Assembly HiMech.dll Provides utility methods for working with milling tools. public static class MillingToolUtil Inheritance object MillingToolUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetFullH(IMachiningTool) Gets the full height of the milling tool. public static double GetFullH(this IMachiningTool millingTool) Parameters millingTool IMachiningTool The milling tool to measure. Returns double The height of the tool in the Z dimension."
  },
  "api/Hi.Milling.MillingTools.html": {
    "href": "api/Hi.Milling.MillingTools.html",
    "title": "Namespace Hi.Milling.MillingTools | HiAPI-C# 2025",
    "summary": "Namespace Hi.Milling.MillingTools Classes MillingTool Represents a central stick milling tool that combines a holder and a cutter. MillingToolEditorDisplayee Display host for a milling tool composed of a cutter and a holder. MillingToolPhysicsPack The scalar physics derivations of one tool (and one cutting-parameter set), computed once on a sequential boundary and frozen. The per-step force build, the sequential physics, and the step/shot writers read these values thousands to millions of times per play; the tool and cutter objects themselves expose them as deliberately uncached pure computations, so hot session paths read this pack instead — callers outside a session simply pass null and the pure computation runs on use. Owned per session by MachiningSession, keyed by tool id. A pack is never updated in place: the paths that change tool/cutter/para state invalidate the session's packs explicitly (run-op start, tool change — see MachiningSession.InvalidateToolPhysicsPacks), and IsStaleFor(IMachiningTool, ICuttingPara) re-keys on object replacement. MillingToolUtil Provides utility methods for working with milling tools. Enums MillingToolAnchorReference Defines reference points for anchoring milling tools."
  },
  "api/Hi.Milling.SpindleCapability.html": {
    "href": "api/Hi.Milling.SpindleCapability.html",
    "title": "Class SpindleCapability | HiAPI-C# 2025",
    "summary": "Class SpindleCapability Namespace Hi.Milling Assembly HiMech.dll Represents the capability of a spindle, including power, torque, and thermal characteristics. Internal Use Only public class SpindleCapability : IMakeXmlSource, INameNote Inheritance object SpindleCapability Implements IMakeXmlSource INameNote Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SpindleCapability() Ctor. public SpindleCapability() SpindleCapability(XElement, string, params object[]) Initializes a new instance of the SpindleCapability class. public SpindleCapability(XElement src, string baseDirectory, params object[] res) Parameters src XElement The XML element containing spindle data. baseDirectory string The base directory for resolving relative paths. res object[] Additional resolution parameters. Properties DryRunFrictionPowerCoefficient_mWdrpm Dry Run Friction Power Coefficient. unit is mW/rpm. DryRunFrictionPower = DryRunFrictionPowerCoefficient * S. public double DryRunFrictionPowerCoefficient_mWdrpm { get; set; } Property Value double Remarks default value 4.82 is estimated by paper: The Friction of Radially Loaded Hybrid Spindle Bearings under High Speeds. Figure 13. At 9k rpm, Torque 0.046Nm. DryRunWindagePowerCoefficient_pWdrpm3 Dry Run Windage Power Coefficient. unit is pW/(rpm^3). DryRunWindagePower = DryRunWindagePowerCoefficient * (S^3). public double DryRunWindagePowerCoefficient_pWdrpm3 { get; set; } Property Value double Remarks default value 90 is estimated by paper: CFD Study on the Windage Power Loss of High Speed Gear. rpm W 5000 12 6000 20 7000 29 EnergyEfficiency Energy Conversion Efficiency. Where is Ouput/Input. public double EnergyEfficiency { get; set; } Property Value double GearShiftSpindleSpeed_cycleds Crossover speed. Gear Shift speed. spindle speed at shifting point between low gear mode and high gear mode. null means there is no gear shift mechanism. public double? GearShiftSpindleSpeed_cycleds { get; set; } Property Value double? GearShiftSpindleSpeed_rpm Gear shift spindle speed in RPM. public double? GearShiftSpindleSpeed_rpm { get; set; } Property Value double? InfInsistentSpindleSpeedToPower_cycleDs_kW SpindleSpeed(cycle/sec) to Power(kW) at infinte workable time. public List<Vec2d> InfInsistentSpindleSpeedToPower_cycleDs_kW { get; set; } Property Value List<Vec2d> InfInsistentSpindleSpeedToTorque_cycleDs_Nm SpindleSpeed(cycle/sec) to Torque(Nm) at 100% insistent ratio. public List<Vec2d> InfInsistentSpindleSpeedToTorque_cycleDs_Nm { get; set; } Property Value List<Vec2d> Name Name. public string Name { get; set; } Property Value string Note Note. public string Note { get; set; } Property Value string WorkableDurationToSpindleSpeedPowerContoursDictionary_min_cycleDs_kW WorkableDuration To SpindleSpeedToPowerContours. The dictionary is workable time (min) to (x:SpindleSpeed(cycle/sec), y:Power(kW)) public Dictionary<double, List<Vec2d>> WorkableDurationToSpindleSpeedPowerContoursDictionary_min_cycleDs_kW { get; set; } Property Value Dictionary<double, List<Vec2d>> WorkableDurationToSpindleSpeedTorqueContoursDictionary_min_cycleDs_Nm WorkableDuration To SpindleSpeedToTorqueContours. The dictionary is workable time (min) to (x:SpindleSpeed(cycle/sec), y:Torque(Nm)). public Dictionary<double, List<Vec2d>> WorkableDurationToSpindleSpeedTorqueContoursDictionary_min_cycleDs_Nm { get; set; } Property Value Dictionary<double, List<Vec2d>> WorkingTemperatureUpperBoundary_C Upper boundary of working temperature in Celsius. public double WorkingTemperatureUpperBoundary_C { get; set; } Property Value double WorkingTemperatureUpperBoundary_K Upper boundary of working temperature in Kelvin. public double WorkingTemperatureUpperBoundary_K { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods GetHeatPara(double) Gets thermal parameters for the spindle at a given speed. Internal Use Only public (double HeatCapacity_JdK, double ConvectionPara_WdK) GetHeatPara(double spindleSpeed_cycleDs) Parameters spindleSpeed_cycleDs double Spindle speed in cycles per second Returns (double HeatCapacity_JdK, double ConvectionPara_WdK) A tuple containing heat capacity and convection parameter MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Milling.html": {
    "href": "api/Hi.Milling.html",
    "title": "Namespace Hi.Milling | HiAPI-C# 2025",
    "summary": "Namespace Hi.Milling Classes MillingGeomBrief Brief of milling geometry. MillingRemovalUtil Utility for milling removal. SpindleCapability Represents the capability of a spindle, including power, torque, and thermal characteristics. Internal Use Only Interfaces IGetDiameter Interface for objects that provide diameter information. IGetFluteHeight Interface for objects that provide flute height information. IGetMillingGeomBrief Interface for retrieving milling geometry brief information. IGetRadialReliefAngle Interface for objects that provide radial relief angle information. IMillingGeomBriefAccessor Interface for accessing and modifying milling geometry brief information."
  },
  "api/Hi.MillingForces.Fittings.CuttingParaUtil.html": {
    "href": "api/Hi.MillingForces.Fittings.CuttingParaUtil.html",
    "title": "Class CuttingParaUtil | HiAPI-C# 2025",
    "summary": "Class CuttingParaUtil Namespace Hi.MillingForces.Fittings Assembly HiMech.dll Utility methods for working with cutting parameters. public static class CuttingParaUtil Inheritance object CuttingParaUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods ToRakeFaceCuttingPara(ICuttingPara) Converts various cutting parameter types to a RakeFaceCuttingPara. This function is for adjusting obsoleted design as some milling parameter formats are not used anymore. public static RakeFaceCuttingPara3d ToRakeFaceCuttingPara(this ICuttingPara millingPara) Parameters millingPara ICuttingPara The cutting parameter to convert. Returns RakeFaceCuttingPara3d A RakeFaceCuttingPara instance, or null if conversion is not possible."
  },
  "api/Hi.MillingForces.Fittings.ICuttingPara.html": {
    "href": "api/Hi.MillingForces.Fittings.ICuttingPara.html",
    "title": "Interface ICuttingPara | HiAPI-C# 2025",
    "summary": "Interface ICuttingPara Namespace Hi.MillingForces.Fittings Assembly HiMech.dll Interface of milling parameter. The milling parameter is trainable. public interface ICuttingPara : IGetCuttingPara, IMakeXmlSource, INameNote Inherited Members IGetCuttingPara.GetCuttingPara() IMakeXmlSource.MakeXmlSource(string, string, bool) INameNote.Name INameNote.Note Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) CuttingParaUtil.ToRakeFaceCuttingPara(ICuttingPara) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties ElementNum Element number. int ElementNum { get; } Property Value int FluteFormNum Flute form number. int FluteFormNum { get; } Property Value int Methods CloneTemplate() Clone template. ICuttingPara CloneTemplate() Returns ICuttingPara clone template GenUnitParas() Generate the ICuttingPara set used by parameter training. The list length equals ElementNum; entry i corresponds to the element of index i (see SetElementByIndex). List<ICuttingPara> GenUnitParas() Returns List<ICuttingPara> training parameters. GetElementByIndex(int) Get element by index. For parameter training. double GetElementByIndex(int elementIndex) Parameters elementIndex int element index Returns double value SetElementByIndex(int, double) Set element by index. For parameter training. void SetElementByIndex(int elementIndex, double v) Parameters elementIndex int element index v double value ToTemplateXElement() Get XElement for templating. XElement ToTemplateXElement() Returns XElement"
  },
  "api/Hi.MillingForces.Fittings.IGetCuttingPara.html": {
    "href": "api/Hi.MillingForces.Fittings.IGetCuttingPara.html",
    "title": "Interface IGetCuttingPara | HiAPI-C# 2025",
    "summary": "Interface IGetCuttingPara Namespace Hi.MillingForces.Fittings Assembly HiMech.dll Interface of GetCuttingPara(). public interface IGetCuttingPara : IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetCuttingPara() Get ICuttingPara. ICuttingPara GetCuttingPara() Returns ICuttingPara ICuttingPara"
  },
  "api/Hi.MillingForces.Fittings.SampleCategory.html": {
    "href": "api/Hi.MillingForces.Fittings.SampleCategory.html",
    "title": "Class SampleCategory | HiAPI-C# 2025",
    "summary": "Class SampleCategory Namespace Hi.MillingForces.Fittings Assembly HiMech.dll Represents a category for milling force samples with step and division information. public class SampleCategory Inheritance object SampleCategory Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SampleCategory() Initializes a new instance of the SampleCategory class. public SampleCategory() SampleCategory(int, int, SampleFlag) Initializes a new instance of the SampleCategory class with specified step index, division index, and sample flag. public SampleCategory(int stepIndex, int localDivisionIndex, SampleFlag sampleDataEnum) Parameters stepIndex int The step index. localDivisionIndex int The local division index. sampleDataEnum SampleFlag The sample data flag. Properties LocalDivisionIndex Gets or sets the local division index. public int LocalDivisionIndex { get; set; } Property Value int SampleDataEnum Gets or sets the sample data flag. public SampleFlag SampleDataEnum { get; set; } Property Value SampleFlag SampleInstance Gets or sets the sample instance. public SampleInstance SampleInstance { get; set; } Property Value SampleInstance StepIndex Gets or sets the step index. public int StepIndex { get; set; } Property Value int Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.MillingForces.Fittings.SampleFlag.html": {
    "href": "api/Hi.MillingForces.Fittings.SampleFlag.html",
    "title": "Enum SampleFlag | HiAPI-C# 2025",
    "summary": "Enum SampleFlag Namespace Hi.MillingForces.Fittings Assembly HiMech.dll Flags representing different types of force and moment samples in milling operations. [Flags] public enum SampleFlag Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) SampleFlagUtil.IsForce(SampleFlag) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Fx = 1 Force in X direction. Fy = 2 Force in Y direction. Fz = 4 Force in Z direction. Mx = 8 Moment around X axis. My = 16 Moment around Y axis. Mz = 32 Moment around Z axis. Virtual = 0 Virtual or no sample."
  },
  "api/Hi.MillingForces.Fittings.SampleFlagUtil.html": {
    "href": "api/Hi.MillingForces.Fittings.SampleFlagUtil.html",
    "title": "Class SampleFlagUtil | HiAPI-C# 2025",
    "summary": "Class SampleFlagUtil Namespace Hi.MillingForces.Fittings Assembly HiMech.dll Utility methods for working with sample flags. public static class SampleFlagUtil Inheritance object SampleFlagUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods IsForce(SampleFlag) Determines if the sample flag represents a force component (Fx, Fy, or Fz). public static bool IsForce(this SampleFlag src) Parameters src SampleFlag The sample flag to check. Returns bool True if the flag represents a force component; otherwise, false."
  },
  "api/Hi.MillingForces.Fittings.SampleInstance.html": {
    "href": "api/Hi.MillingForces.Fittings.SampleInstance.html",
    "title": "Class SampleInstance | HiAPI-C# 2025",
    "summary": "Class SampleInstance Namespace Hi.MillingForces.Fittings Assembly HiMech.dll Represents a sample instance with step and local division indices for milling force analysis. public class SampleInstance : IEquatable<SampleInstance> Inheritance object SampleInstance Implements IEquatable<SampleInstance> Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SampleInstance() Initializes a new instance of the SampleInstance class. public SampleInstance() SampleInstance(int, int) Initializes a new instance of the SampleInstance class with specified step and local division indices. public SampleInstance(int stepIndex, int localDivisionIndex) Parameters stepIndex int The step index. localDivisionIndex int The local division index. Properties LocalDivisionIndex Gets or sets the local division index. public int LocalDivisionIndex { get; set; } Property Value int StepIndex Gets or sets the step index. public int StepIndex { get; set; } Property Value int Methods Equals(SampleInstance) Indicates whether the current object is equal to another object of the same type. public bool Equals(SampleInstance other) Parameters other SampleInstance An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.MillingForces.Fittings.TimeForce.html": {
    "href": "api/Hi.MillingForces.Fittings.TimeForce.html",
    "title": "Class TimeForce | HiAPI-C# 2025",
    "summary": "Class TimeForce Namespace Hi.MillingForces.Fittings Assembly HiMech.dll Represents a force measurement at a specific time point. public class TimeForce Inheritance object TimeForce Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors TimeForce(double, Vec3d) Initializes a new instance of the TimeForce class. public TimeForce(double time_sec, Vec3d force_N) Parameters time_sec double Time in seconds. force_N Vec3d Force in Newtons. Properties Force_N Gets or sets the force vector in Newtons. public Vec3d Force_N { get; set; } Property Value Vec3d Time_s Gets or sets the time in seconds. public double Time_s { get; set; } Property Value double"
  },
  "api/Hi.MillingForces.Fittings.TimeForceFrequencyDomain.html": {
    "href": "api/Hi.MillingForces.Fittings.TimeForceFrequencyDomain.html",
    "title": "Class TimeForceFrequencyDomain | HiAPI-C# 2025",
    "summary": "Class TimeForceFrequencyDomain Namespace Hi.MillingForces.Fittings Assembly HiMech.dll Represents force data in the frequency domain after Fourier transformation. public class TimeForceFrequencyDomain Inheritance object TimeForceFrequencyDomain Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties AmpXs Gets or sets the amplitude values for each frequency component. public double[] AmpXs { get; set; } Property Value double[] PhaseXs Gets or sets the phase values for each frequency component. public double[] PhaseXs { get; set; } Property Value double[] SamplingTimeInterval_s Gets or sets the sampling time interval in seconds. public double SamplingTimeInterval_s { get; set; } Property Value double SamplingTime_s Gets or sets the total sampling time in seconds. public double SamplingTime_s { get; set; } Property Value double"
  },
  "api/Hi.MillingForces.Fittings.TimeForceSeries.html": {
    "href": "api/Hi.MillingForces.Fittings.TimeForceSeries.html",
    "title": "Class TimeForceSeries | HiAPI-C# 2025",
    "summary": "Class TimeForceSeries Namespace Hi.MillingForces.Fittings Assembly HiMech.dll Represents a time series of force measurements. public class TimeForceSeries Inheritance object TimeForceSeries Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties TimeForceList TimeForce list. The time is sorted in ascending order. public List<TimeForce> TimeForceList { get; set; } Property Value List<TimeForce> Methods FourierTransform(int, double, out double[], out double[]) Performs Fourier transform on the force data in the specified direction. public void FourierTransform(int dir, double samplingTimeInterval_s, out double[] amplitudes, out double[] phases) Parameters dir int The direction index (0=X, 1=Y, 2=Z) for the force component to transform. samplingTimeInterval_s double The sampling time interval in seconds. amplitudes double[] Output array of amplitude values for each frequency component. phases double[] Output array of phase values for each frequency component. ReadCsv(string) Reads time-force data from a CSV file. public void ReadCsv(string file) Parameters file string Path to the CSV file containing time-force data."
  },
  "api/Hi.MillingForces.Fittings.TimeForceUtil.html": {
    "href": "api/Hi.MillingForces.Fittings.TimeForceUtil.html",
    "title": "Class TimeForceUtil | HiAPI-C# 2025",
    "summary": "Class TimeForceUtil Namespace Hi.MillingForces.Fittings Assembly HiMech.dll Utility class for reading and processing time-based force measurement data. public static class TimeForceUtil Inheritance object TimeForceUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods ReadCsv(string) Reads time-force data from a CSV file. public static List<TimeForce> ReadCsv(string file) Parameters file string The path to the CSV file containing time-force data. Returns List<TimeForce> A list of TimeForce objects containing the parsed data. The CSV file should have at least 4 columns: Column 1: Time in seconds Column 2: X-component of force in Newtons Column 3: Y-component of force in Newtons Column 4: Z-component of force in Newtons Remarks The method: Skips the first line (assumed to be headers) Parses each subsequent line into time and force components Validates that each line has at least 4 numeric values Creates a TimeForce object for each valid line"
  },
  "api/Hi.MillingForces.Fittings.TimeVsForceSeries.html": {
    "href": "api/Hi.MillingForces.Fittings.TimeVsForceSeries.html",
    "title": "Class TimeVsForceSeries | HiAPI-C# 2025",
    "summary": "Class TimeVsForceSeries Namespace Hi.MillingForces.Fittings Assembly HiMech.dll Represents a time series of force measurements with compensation capabilities. public class TimeVsForceSeries Inheritance object TimeVsForceSeries Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties CompensatedTimeVsForce Gets the force data with offset compensation applied. public SortedList<double, Vec3d> CompensatedTimeVsForce { get; } Property Value SortedList<double, Vec3d> ForceOffset Gets the force offset calculated as the average force in the zero zone. public Vec3d ForceOffset { get; } Property Value Vec3d OriginalTimeVsForce Gets or sets the original time-force data pairs, where the key is time and the value is the force vector. public SortedList<double, Vec3d> OriginalTimeVsForce { get; set; } Property Value SortedList<double, Vec3d> ZeroZoneTimeBegin Gets or sets the start time of the zero force zone used for offset calculation. public double ZeroZoneTimeBegin { get; set; } Property Value double ZeroZoneTimeEnd Gets or sets the end time of the zero force zone used for offset calculation. public double ZeroZoneTimeEnd { get; set; } Property Value double Methods ReadCsv(string) Reads force data from a CSV file. public void ReadCsv(string file) Parameters file string The path to the CSV file containing time-force data."
  },
  "api/Hi.MillingForces.Fittings.TimeVsTorqueSeries.html": {
    "href": "api/Hi.MillingForces.Fittings.TimeVsTorqueSeries.html",
    "title": "Class TimeVsTorqueSeries | HiAPI-C# 2025",
    "summary": "Class TimeVsTorqueSeries Namespace Hi.MillingForces.Fittings Assembly HiMech.dll Represents a time series of torque measurements with compensation capabilities. public class TimeVsTorqueSeries Inheritance object TimeVsTorqueSeries Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties CompensatedTimeVsTorque Gets the torque data with offset compensation applied. public SortedList<double, double> CompensatedTimeVsTorque { get; } Property Value SortedList<double, double> OriginalTimeVsTorque Gets or sets the original time-torque data pairs, where the key is time and the value is the torque magnitude. public SortedList<double, double> OriginalTimeVsTorque { get; set; } Property Value SortedList<double, double> TorqueOffset Gets the torque offset calculated as the average torque in the zero zone. public double TorqueOffset { get; } Property Value double ZeroZoneTimeBegin Gets or sets the start time of the zero torque zone used for offset calculation. public double ZeroZoneTimeBegin { get; set; } Property Value double ZeroZoneTimeEnd Gets or sets the end time of the zero torque zone used for offset calculation. public double ZeroZoneTimeEnd { get; set; } Property Value double Methods ReadCsv(string) Reads torque data from a CSV file. public void ReadCsv(string file) Parameters file string The path to the CSV file containing time-torque data."
  },
  "api/Hi.MillingForces.Fittings.TrainingSample.html": {
    "href": "api/Hi.MillingForces.Fittings.TrainingSample.html",
    "title": "Class TrainingSample | HiAPI-C# 2025",
    "summary": "Class TrainingSample Namespace Hi.MillingForces.Fittings Assembly HiMech.dll Represents a training sample for milling force prediction models. public class TrainingSample Inheritance object TrainingSample Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Category Gets or sets the category information for this sample. public SampleCategory Category { get; set; } Property Value SampleCategory InputArray Gets or sets the input feature array for the training sample. public double[] InputArray { get; set; } Property Value double[] Output Gets or sets the output value according to the angle offset. public double Output { get; set; } Property Value double Methods NormalizeByInput() public void NormalizeByInput() Remarks The input normalization deminish the quantity effect. The R-value decreases from 99% to 70% in an observed moment-training case. ToString() Returns a string representation of the training sample. public override string ToString() Returns string A string containing the category, output, and input array values."
  },
  "api/Hi.MillingForces.Fittings.html": {
    "href": "api/Hi.MillingForces.Fittings.html",
    "title": "Namespace Hi.MillingForces.Fittings | HiAPI-C# 2025",
    "summary": "Namespace Hi.MillingForces.Fittings Classes CuttingParaUtil Utility methods for working with cutting parameters. SampleCategory Represents a category for milling force samples with step and division information. SampleFlagUtil Utility methods for working with sample flags. SampleInstance Represents a sample instance with step and local division indices for milling force analysis. TimeForce Represents a force measurement at a specific time point. TimeForceFrequencyDomain Represents force data in the frequency domain after Fourier transformation. TimeForceSeries Represents a time series of force measurements. TimeForceUtil Utility class for reading and processing time-based force measurement data. TimeVsForceSeries Represents a time series of force measurements with compensation capabilities. TimeVsTorqueSeries Represents a time series of torque measurements with compensation capabilities. TrainingSample Represents a training sample for milling force prediction models. Interfaces ICuttingPara Interface of milling parameter. The milling parameter is trainable. IGetCuttingPara Interface of GetCuttingPara(). Enums SampleFlag Flags representing different types of force and moment samples in milling operations."
  },
  "api/Hi.MillingForces.IGetMillingForce.html": {
    "href": "api/Hi.MillingForces.IGetMillingForce.html",
    "title": "Interface IGetMillingForce | HiAPI-C# 2025",
    "summary": "Interface IGetMillingForce Namespace Hi.MillingForces Assembly HiMech.dll Interface of GetMillingForce(). public interface IGetMillingForce Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetMillingForce() Get MillingForce. MillingForce GetMillingForce() Returns MillingForce MillingForce"
  },
  "api/Hi.MillingForces.IMillingForceAccessor.html": {
    "href": "api/Hi.MillingForces.IMillingForceAccessor.html",
    "title": "Interface IMillingForceAccessor | HiAPI-C# 2025",
    "summary": "Interface IMillingForceAccessor Namespace Hi.MillingForces Assembly HiMech.dll Interface of MillingForce. public interface IMillingForceAccessor : IGetMillingForce Inherited Members IGetMillingForce.GetMillingForce() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties MillingForce Milling force. MillingForce MillingForce { get; set; } Property Value MillingForce"
  },
  "api/Hi.MillingForces.MillingForce.html": {
    "href": "api/Hi.MillingForces.MillingForce.html",
    "title": "Class MillingForce | HiAPI-C# 2025",
    "summary": "Class MillingForce Namespace Hi.MillingForces Assembly HiMech.dll Milling force. public class MillingForce : IGetFeedrate, IGetSpindleSpeed, IGetMillingForce, IGetQuantityByKey, IGetCsvDictionary, IWriteBin Inheritance object MillingForce Implements IGetFeedrate IGetSpindleSpeed IGetMillingForce IGetQuantityByKey IGetCsvDictionary IWriteBin Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks The data list such as CuttingForcesToToolOnToolRunningCoordinate in this class is in sequence of time. Constructors MillingForce(BinaryReader) Initializes a new instance of the MillingForce class from binary data. public MillingForce(BinaryReader reader) Parameters reader BinaryReader The binary reader containing the serialized milling force data. Fields DefaultRotationDivisionNum Gets the default number of divisions for one complete rotation. public const int DefaultRotationDivisionNum = 36 Field Value int Remarks This value determines the resolution of force calculations during tool rotation. A higher value provides more detailed force analysis but requires more computational resources. Properties AbsAvgForce Absolute average force. public double AbsAvgForce { get; } Property Value double AbsAxialPower_W Gets the absolute axial power in watts. public double AbsAxialPower_W { get; } Property Value double AvgAbsMomentsAboutSpindle_Nm Gets the average absolute moments about spindle on the spindle sensor coordinate system. public Vec3d AvgAbsMomentsAboutSpindle_Nm { get; } Property Value Vec3d Remarks Calculates the average of absolute values for each component (X, Y, Z) of the moments about the spindle. AvgAxialTorque_Nm Get avg axial torque in N*m. The observation point is at tool tip. The torque is taken by tool. public double AvgAxialTorque_Nm { get; } Property Value double AvgBendingMomentsAboutSpindle_Nm Gets the average bending moments about spindle in Newton-meters. public double? AvgBendingMomentsAboutSpindle_Nm { get; } Property Value double? Remarks Calculates the magnitude of the average bending moment by taking the square root of the sum of squares of the X and Y components of the average absolute moments. AvgContactEdgeLengthPerFlute_mm Gets the average contact edge length per flute in millimeters. public double AvgContactEdgeLengthPerFlute_mm { get; } Property Value double AvgForceToToolOnToolRunningCoordinate Avg cutting force to tool on tool running coordinate. public Vec3d AvgForceToToolOnToolRunningCoordinate { get; } Property Value Vec3d AvgForceToWorkpieceOnWorkpieceCoordinate Avg cutting force on workpiece coordinate. public Vec3d AvgForceToWorkpieceOnWorkpieceCoordinate { get; } Property Value Vec3d AvgIntersectedContactArea_mm2 contact area along cutter outside contact point to circle center direction. The average is for each rotation angle. This property is for computing heat transfer. public double AvgIntersectedContactArea_mm2 { get; } Property Value double AvgMomentToToolAboutObservationPointOnToolRunningZero_Nm Gets the average moment to tool about observation point on tool running zero in Newton-meters. public Vec3d AvgMomentToToolAboutObservationPointOnToolRunningZero_Nm { get; } Property Value Vec3d AxialPowerTakenByWorkpiece_W Axial Power that the spindle has to create due to axial torque. The empowered item is workpiece. The fulcrum is at the tool tip. Unit is Watt. public double AxialPowerTakenByWorkpiece_W { get; } Property Value double CdnTransformFromToolRunningZeroToWorkpieceGeom Tool running coordinate to workpiece geom coordinate. public Mat4d CdnTransformFromToolRunningZeroToWorkpieceGeom { get; } Property Value Mat4d ChipVolume_mm3 Gets the chip volume in cubic millimeters. public double ChipVolume_mm3 { get; } Property Value double CuttingForcesToToolOnToolRunningCoordinate Cutting forces on tool running coordinate. The forced item is tool. public List<Vec3d> CuttingForcesToToolOnToolRunningCoordinate { get; } Property Value List<Vec3d> CuttingForcesToToolOnWorkpieceCoodinate Cutting forces on workpiece coordinate. The forced item is tool. public List<Vec3d> CuttingForcesToToolOnWorkpieceCoodinate { get; } Property Value List<Vec3d> CuttingForcesToWorkpieceOnWorkpieceCoordinate Cutting forces on workpiece coordinate. The forced item is workpiece. public List<Vec3d> CuttingForcesToWorkpieceOnWorkpieceCoordinate { get; } Property Value List<Vec3d> CyclePeriod_s Gets the cycle period in seconds, calculated as 60 / SpindleSpeed_rpm. public double CyclePeriod_s { get; } Property Value double DAngle_deg Delta angle in degree. The value is 360 / RotationDivisionNum. public double DAngle_deg { get; } Property Value double DAngle_rad Delta angle in radian. The value is 2 * pi / RotationDivisionNum. public double DAngle_rad { get; } Property Value double Feedrate_mmds The tool-tip feedrate the force step was computed with, in millimeters per second: the step's real tip feedrate (ActualTipFeedrate_mmds), or a solver's candidate feed on a trial step. public double Feedrate_mmds { get; } Property Value double FluteNum Gets the number of flutes on the cutting tool. public int FluteNum { get; } Property Value int FrictionPower_W friction power to workpiece. the unit is watt. public double FrictionPower_W { get; } Property Value double IndexAtMaxCuttingForce Gets the index at which the maximum cutting force occurs. public int IndexAtMaxCuttingForce { get; } Property Value int IsCw Gets a value indicating whether the spindle rotation is clockwise. public bool IsCw { get; } Property Value bool KinematicPowerDivDensity_Wmm3dg Gets the kinematic power divided by density in watts per cubic millimeter per degree. public double KinematicPowerDivDensity_Wmm3dg { get; } Property Value double MaxAbsForce Gets the maximum absolute force magnitude. public double MaxAbsForce { get; } Property Value double MaxAbsForceSlope_NdDeg Absolute max force changed per degree. public double MaxAbsForceSlope_NdDeg { get; } Property Value double MaxAbsMomentAboutObservationPoint_Nm Gets the maximum absolute moment about observation point in Newton-meters. public double MaxAbsMomentAboutObservationPoint_Nm { get; } Property Value double MaxAxialTorqueToToolByToolTip_Nm Get max axial torque in N*m. The observation point is at tool tip. The torque is taken by tool. public double MaxAxialTorqueToToolByToolTip_Nm { get; } Property Value double MaxForceToToolOnToolRunningCoordinate Max cutting force on tool running coordinate. public Vec3d MaxForceToToolOnToolRunningCoordinate { get; } Property Value Vec3d MaxMomentToToolAboutObservationPointOnToolRunningZero_Nm Gets the maximum moment to tool about observation point on tool running zero in Newton-meters. public Vec3d MaxMomentToToolAboutObservationPointOnToolRunningZero_Nm { get; } Property Value Vec3d MaxMomentToToolAboutObservationPointOnWorkpiceGeom_Nm Gets the maximum moment to tool about observation point on workpiece geometry in Newton-meters. public Vec3d MaxMomentToToolAboutObservationPointOnWorkpiceGeom_Nm { get; } Property Value Vec3d MinAbsMomentAboutObservationPoint_Nm Gets the minimum absolute moment about the observation point in Newton-meters. public double MinAbsMomentAboutObservationPoint_Nm { get; } Property Value double MomentsAboutObservationPointOnObservationCoordinate_Nm Gets the moments about observation point on observation coordinate in Newton-meters. public List<Vec3d> MomentsAboutObservationPointOnObservationCoordinate_Nm { get; } Property Value List<Vec3d> MomentsAboutObservationPointOnToolRunningZero_Nm Gets the minimum absolute moment about the observation point in Newton-meters. public List<Vec3d> MomentsAboutObservationPointOnToolRunningZero_Nm { get; } Property Value List<Vec3d> MomentsAboutSpindle_Nm Gets the moments about spindle on the spindle sensor coordinate system. public List<Vec3d> MomentsAboutSpindle_Nm { get; } Property Value List<Vec3d> Remarks The moments are calculated by transforming the moments about the observation point to the spindle sensor coordinate system using the current rotation angle. MomentsToToolAboutObservationPointOnSpindleRotationZero_Nm Gets the moments to tool about observation point on spindle rotation zero in Newton-meters. public List<Vec3d> MomentsToToolAboutObservationPointOnSpindleRotationZero_Nm { get; } Property Value List<Vec3d> MomentsToToolAboutToolTipOnToolRunningZero_Nm Moments on tool running coordinate in N*m. The fulcrum is at the coordinate zero. The moment is taken by tool. The size is RotationDivisionNum. public List<Vec3d> MomentsToToolAboutToolTipOnToolRunningZero_Nm { get; } Property Value List<Vec3d> ObservationPositionFromToolTip Specific fulcrum position relative coordinate zero on tool running coordinate. public Vec3d ObservationPositionFromToolTip { get; } Property Value Vec3d PloughForcesOnTr plough force on tool running coordinate. The force is taken by tool. In sequence of time. public List<Vec3d> PloughForcesOnTr { get; } Property Value List<Vec3d> PowerWithoutFriction_W Gets the power without friction in watts, calculated as axial power taken by workpiece minus friction power. public double PowerWithoutFriction_W { get; } Property Value double RotationAngleInterval Gets the rotation angle interval in radians between divisions. The value is 2 * pi / RotationDivisionNum. public double RotationAngleInterval { get; } Property Value double RotationDivisionNum Gets the number of divisions for one complete rotation. public int RotationDivisionNum { get; } Property Value int ShearForcesOnTr shear forces on tool running coordinate. The force is taken by tool. In sequence of time. public List<Vec3d> ShearForcesOnTr { get; } Property Value List<Vec3d> SpindleSpeed_radds Gets the spindle speed in radians per second. public double SpindleSpeed_radds { get; } Property Value double SpindleSpeed_rpm Gets the spindle speed in revolutions per minute. public double SpindleSpeed_rpm { get; } Property Value double StepIndex Step index. For database saving. [Key] [DatabaseGenerated(DatabaseGeneratedOption.None)] public int StepIndex { get; set; } Property Value int ToothArcDuration_s Gets the duration of one tooth arc pass in seconds, calculated as CyclePeriod_s / FluteNum. public double ToothArcDuration_s { get; } Property Value double TransformFromWorkpieceGeomToObservationPoint Gets the transformation matrix from workpiece geometric coordinate system to the observation point. public Mat4d TransformFromWorkpieceGeomToObservationPoint { get; } Property Value Mat4d Methods DynamicBuildExtension() Internal use. Build extended data. In single thread, no need to use the function. In multi thread, call it before going to un-safe area. public void DynamicBuildExtension() GetCsvDictionary() Get row dictionary. It suits for CSV output. public Dictionary<string, string> GetCsvDictionary() Returns Dictionary<string, string> csv row dictionary GetFeedrate_mmds() Gets the program feedrate in millimeters per second. public double GetFeedrate_mmds() Returns double Feedrate in mm/s GetForceBriefDictionary(bool) Gets a dictionary containing force-related quantities. public Dictionary<string, double> GetForceBriefDictionary(bool isIncludingWave = false) Parameters isIncludingWave bool If true, includes wave-related force data. Returns Dictionary<string, double> A dictionary mapping quantity names to their values. GetForceToToolOnToolRunningCoordinateCsvString() Gets the force to tool on tool running coordinate as a CSV string. public string GetForceToToolOnToolRunningCoordinateCsvString() Returns string A CSV string representation of the forces. GetForceToWorkpieceOnWorkpieceCoordinateCsvString() Gets the force to workpiece on workpiece coordinate as a CSV string. public string GetForceToWorkpieceOnWorkpieceCoordinateCsvString() Returns string A CSV string representation of the forces. GetMillingForce() Get MillingForce. public MillingForce GetMillingForce() Returns MillingForce MillingForce GetMomentsAboutObservationPointOnToolRunningCoordinate_Nm(double) Gets moments about observation point on tool running coordinate in Newton-meters for a specific observation height. public List<Vec3d> GetMomentsAboutObservationPointOnToolRunningCoordinate_Nm(double observationHeightFromToolTip) Parameters observationHeightFromToolTip double The height from tool tip to observation point in millimeters Returns List<Vec3d> List of moment vectors in Newton-meters GetMomentsAboutObservationPointOnToolRunningZero_Nm(Vec3d) Gets moments about observation point on tool running zero coordinate system in Newton-meters. public List<Vec3d> GetMomentsAboutObservationPointOnToolRunningZero_Nm(Vec3d observationPosFromToolTip) Parameters observationPosFromToolTip Vec3d The position vector from tool tip to observation point Returns List<Vec3d> List of moment vectors in Newton-meters GetMomentsToToolAboutObservationPointOnSpindleRotationZeroCsvString() Gets the moments to tool about observation point on spindle rotation zero as a CSV string. public string GetMomentsToToolAboutObservationPointOnSpindleRotationZeroCsvString() Returns string A CSV string representation of the moments. GetQuantityByKey(string) Gets a quantity value associated with the specified key. public double GetQuantityByKey(string key) Parameters key string The key to look up Returns double The quantity value associated with the key GetSpindleDirection() Gets the spindle rotation direction. public SpindleDirection GetSpindleDirection() Returns SpindleDirection The spindle direction (clockwise, counterclockwise, or stopped) GetSpindleSpeed_radds() Gets the spindle speed in radians per second. public double GetSpindleSpeed_radds() Returns double Spindle speed in rad/s ToCuttingForcesString() Converts the cutting forces to a string representation. public string ToCuttingForcesString() Returns string A string representation of the cutting forces. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. WriteBin(BinaryWriter) Writes the object's data to a binary stream. public void WriteBin(BinaryWriter writer) Parameters writer BinaryWriter The binary writer to write to"
  },
  "api/Hi.MillingForces.MillingForceLicense.html": {
    "href": "api/Hi.MillingForces.MillingForceLicense.html",
    "title": "Class MillingForceLicense | HiAPI-C# 2025",
    "summary": "Class MillingForceLicense Namespace Hi.MillingForces Assembly HiMech.dll Provides license information and management for the milling force calculation functionality. public static class MillingForceLicense Inheritance object MillingForceLicense Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Properties LicenseType Gets the current license type for milling force calculations. public static LicenseType LicenseType { get; } Property Value LicenseType RemainedStep Gets the number of remaining steps available in the current license. public static int RemainedStep { get; } Property Value int"
  },
  "api/Hi.MillingForces.MillingForceLuggage.html": {
    "href": "api/Hi.MillingForces.MillingForceLuggage.html",
    "title": "Class MillingForceLuggage | HiAPI-C# 2025",
    "summary": "Class MillingForceLuggage Namespace Hi.MillingForces Assembly HiMech.dll Represents a container for milling force data and calculations. public class MillingForceLuggage Inheritance object MillingForceLuggage Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MillingForceLuggage() Initializes a new instance of the MillingForceLuggage class. public MillingForceLuggage() MillingForceLuggage(BinaryReader) Initializes a new instance of the MillingForceLuggage class from a binary reader. public MillingForceLuggage(BinaryReader reader) Parameters reader BinaryReader The binary reader containing the milling force data. Properties CuttingForcesToToolOnToolRunningCoordinate_N Cutting forces on tool running coordinate. The forced item is tool. public List<Vec3d> CuttingForcesToToolOnToolRunningCoordinate_N { get; } Property Value List<Vec3d> MomentsToToolAboutToolTipOnToolRunningCoordinate_Nm Moments on tool running coordinate in N*m. The fulcrum is at the coordinate zero. The moment is taken by tool. The size is RotationDivisionNum. public List<Vec3d> MomentsToToolAboutToolTipOnToolRunningCoordinate_Nm { get; } Property Value List<Vec3d> PloughForcesOnTr plough force on tool running coordinate. The force is taken by tool. In sequence of time. public List<Vec3d> PloughForcesOnTr { get; } Property Value List<Vec3d> RotationDivisionNum Gets the number of divisions for one complete rotation. public int RotationDivisionNum { get; } Property Value int ShearForcesOnTr shear forces on tool running coordinate. The force is taken by tool. In sequence of time. public List<Vec3d> ShearForcesOnTr { get; } Property Value List<Vec3d> StepIndex Step index. For database saving. [Key] [DatabaseGenerated(DatabaseGeneratedOption.None)] public int StepIndex { get; set; } Property Value int Methods GetCuttingForcesToToolOnWorkpieceCoodinate_N(Mat4d) Cutting forces on workpiece coordinate. The forced item is tool. public List<Vec3d> GetCuttingForcesToToolOnWorkpieceCoodinate_N(Mat4d CdnTransformFromToolRunningZeroToWorkpieceGeom) Parameters CdnTransformFromToolRunningZeroToWorkpieceGeom Mat4d Returns List<Vec3d> GetCuttingForcesToWorkpieceOnProgramCoordinate_N(Mat4d) Cutting forces on workpiece coordinate. The forced item is workpiece. public List<Vec3d> GetCuttingForcesToWorkpieceOnProgramCoordinate_N(Mat4d cdnTransformFromToolRunningToProgram) Parameters cdnTransformFromToolRunningToProgram Mat4d Returns List<Vec3d> GetCuttingForcesToWorkpieceOnProgramCoordinate_N(MachineMotionStep) Gets the cutting forces to workpiece on program coordinate in Newtons. public List<Vec3d> GetCuttingForcesToWorkpieceOnProgramCoordinate_N(MachineMotionStep machineStep) Parameters machineStep MachineMotionStep The machining step to get forces for Returns List<Vec3d> List of force vectors in Newtons GetForceToToolOnToolRunningCoordinateCsvString(MachineMotionStep) Gets the force to tool on tool running coordinate as a CSV string. public string GetForceToToolOnToolRunningCoordinateCsvString(MachineMotionStep machineStep) Parameters machineStep MachineMotionStep The machining step to get forces for. Returns string A CSV string representation of the forces. GetForceToWorkpieceOnProgramCoordinateCsvString(MachineMotionStep) Gets the force to workpiece on program coordinate as a CSV string. public string GetForceToWorkpieceOnProgramCoordinateCsvString(MachineMotionStep machineStep) Parameters machineStep MachineMotionStep The machining step to get forces for. Returns string A CSV string representation of the forces. GetMomentsAboutAnchorOnToolRunningCoordinate_Nm(IMachiningTool, MillingToolPhysicsPack) Gets the moments about anchor on tool running coordinate in Newton-meters. public List<Vec3d> GetMomentsAboutAnchorOnToolRunningCoordinate_Nm(IMachiningTool millingTool, MillingToolPhysicsPack physicsPack = null) Parameters millingTool IMachiningTool The machining tool to calculate moments for. physicsPack MillingToolPhysicsPack The frozen per-session physics pack of millingTool; null computes the observation height from the tool on use. Returns List<Vec3d> A list of moment vectors. GetMomentsAboutToolTipOnSpindleRotationCoordinate_Nm() Gets the moments about tool tip on spindle rotation coordinate in Newton-meters. public List<Vec3d> GetMomentsAboutToolTipOnSpindleRotationCoordinate_Nm() Returns List<Vec3d> A list of moment vectors. GetMomentsOnToolRunningCoordinate_Nm(Vec3d) Get moments to tool. public List<Vec3d> GetMomentsOnToolRunningCoordinate_Nm(Vec3d observationPosFromToolTip) Parameters observationPosFromToolTip Vec3d Returns List<Vec3d> GetMomentsOnToolRunningCoordinate_Nm(double) Gets the moments on the tool running coordinate system at a specified height from the tool tip. public List<Vec3d> GetMomentsOnToolRunningCoordinate_Nm(double observationHeightFromToolTip) Parameters observationHeightFromToolTip double The height from the tool tip where moments are calculated. Returns List<Vec3d> A list of moment vectors in the tool running coordinate system. GetMomentsToToolAboutObservationPointOnSpindleRotationCoordinate_Nm(IMachiningTool, MillingToolPhysicsPack) Get Moments To Tool About Observation Point On Spindle Rotation Coordinate. Unit is Newton-meter. public List<Vec3d> GetMomentsToToolAboutObservationPointOnSpindleRotationCoordinate_Nm(IMachiningTool millingTool, MillingToolPhysicsPack physicsPack = null) Parameters millingTool IMachiningTool The machining tool to calculate moments for. physicsPack MillingToolPhysicsPack The frozen per-session physics pack of millingTool; null computes the observation height from the tool on use. Returns List<Vec3d> GetMomentsToToolAboutObservationPointOnSpindleRotationCoordinate_Nm(double) Get Moments To Tool About Observation Point On Spindle Rotation Coordinate, with the observation height supplied directly — for a caller that resolved the height once and reads many luggage instances. Unit is Newton-meter. public List<Vec3d> GetMomentsToToolAboutObservationPointOnSpindleRotationCoordinate_Nm(double observationHeightFromToolTip) Parameters observationHeightFromToolTip double The observation height from the tool tip in millimeters. Returns List<Vec3d> GetMomentsToToolOnSpindleRotationZeroCsvString(IMachiningTool, MachineMotionStep, MillingPhysicsBrief) Gets the moments to tool on spindle rotation zero as a CSV string. public string GetMomentsToToolOnSpindleRotationZeroCsvString(IMachiningTool machiningTool, MachineMotionStep machineStep, MillingPhysicsBrief brief) Parameters machiningTool IMachiningTool The machining tool. machineStep MachineMotionStep The machining step to get moments for. brief MillingPhysicsBrief The rake face physics brief. Returns string A CSV string representation of the moments. GetTipDeflectionOnToolRunningCoordinateList_mm(IMachiningTool, MillingToolPhysicsPack) Gets the tool tip deflection on the tool running coordinate system. public List<Vec3d> GetTipDeflectionOnToolRunningCoordinateList_mm(IMachiningTool millingTool, MillingToolPhysicsPack physicsPack = null) Parameters millingTool IMachiningTool The milling tool for which to calculate deflections. physicsPack MillingToolPhysicsPack The frozen per-session physics pack of millingTool; null computes the deflection parameters from the tool on use. Returns List<Vec3d> A list of deflection vectors in millimeters in the tool running coordinate system. GetYieldingStressRatio(IMachiningTool) Gets the yielding stress ratio for the given machining tool. public double GetYieldingStressRatio(IMachiningTool millingTool) Parameters millingTool IMachiningTool The machining tool to calculate the stress ratio for. Returns double The yielding stress ratio, or NaN when it cannot be evaluated — non-milling cutter, missing flute material, or no beam section outside the tip zone. Never a fake-safe 0. NoCut(int) Builds a luggage representing a physically-computed “no cut” state (paired with NoCut(int)): the three per-rotation force lists are each filled with Zero of length rotationDivisionNum. StepIndex is left at default; the caller assigns it. public static MillingForceLuggage NoCut(int rotationDivisionNum) Parameters rotationDivisionNum int Length of each per-rotation list. Returns MillingForceLuggage ToCuttingForcesString() Converts the cutting forces to a string representation. public string ToCuttingForcesString() Returns string A string representation of the cutting forces. WriteBin(BinaryWriter) public void WriteBin(BinaryWriter writer) Parameters writer BinaryWriter"
  },
  "api/Hi.MillingForces.MillingForceUtil.html": {
    "href": "api/Hi.MillingForces.MillingForceUtil.html",
    "title": "Class MillingForceUtil | HiAPI-C# 2025",
    "summary": "Class MillingForceUtil Namespace Hi.MillingForces Assembly HiMech.dll Utility class for milling force calculations and related operations. public static class MillingForceUtil Inheritance object MillingForceUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Properties EnableNativeMillingPhysics Whether the physics runs on the native (core.dll) kernels. Default is true, and in shipping builds the native kernel is the only physics implementation: setting this to false requires the managed reference implementation (not shipped; registered at startup by dev/test hosts) and throws InvalidOperationException without it — failing at configuration time rather than on every step of a play. Both implementations produce the same results. Process-global like RotationDivisionNum. public static bool EnableNativeMillingPhysics { get; set; } Property Value bool PressureEvaluationDepth_mm For avoid unstable form floating error. public static double PressureEvaluationDepth_mm { get; set; } Property Value double RotationDivisionNum Division number of a spindle cycle. public static int RotationDivisionNum { get; set; } Property Value int Methods GetMillingFoce(ICuttingPara, IMachiningTool, MachineMotionStep, LayerMillingEngagement, out MillingPhysicsBrief, out MillingForceLuggage, double, bool, MillingToolPhysicsPack) Calculates the milling forces for a given machining operation public static void GetMillingFoce(ICuttingPara millingPara, IMachiningTool millingTool, MachineMotionStep machineStep, LayerMillingEngagement engagement, out MillingPhysicsBrief brief, out MillingForceLuggage luggage, double trialClippingHeight_mm, bool enableCalculatingReliefColliding, MillingToolPhysicsPack physicsPack = null) Parameters millingPara ICuttingPara The cutting parameters for the milling operation millingTool IMachiningTool The machining tool used for the operation machineStep MachineMotionStep The machining step information engagement LayerMillingEngagement Layer milling engagement parameters brief MillingPhysicsBrief Output parameter for brief physics information luggage MillingForceLuggage Output parameter for milling force data trialClippingHeight_mm double The available height for cutting height optimization search in millimeters. The value should be always equal or smaller than the cutting depth from the engagement enableCalculatingReliefColliding bool enable calculating effect of relief colliding physicsPack MillingToolPhysicsPack The frozen per-session physics pack of millingTool and millingPara; null (or a pack keyed to a different para) computes the gate values from the tool on use."
  },
  "api/Hi.MillingForces.MillingPhysicsBrief.html": {
    "href": "api/Hi.MillingForces.MillingPhysicsBrief.html",
    "title": "Class MillingPhysicsBrief | HiAPI-C# 2025",
    "summary": "Class MillingPhysicsBrief Namespace Hi.MillingForces Assembly HiMech.dll Instant Physics brief on rake face for milling. public class MillingPhysicsBrief Inheritance object MillingPhysicsBrief Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MillingPhysicsBrief() Ctor. public MillingPhysicsBrief() MillingPhysicsBrief(int) Initializes a new instance of the MillingPhysicsBrief class with a specified rotation division number. public MillingPhysicsBrief(int rotationDivisionNum) Parameters rotationDivisionNum int The number of divisions for rotation calculations. Properties AvgAbsForce_N Gets the average absolute force in Newtons. public double AvgAbsForce_N { get; } Property Value double AvgAbsMomentAboutSensorVec3d_Nm Gets the average absolute moment about the sensor as a 3D vector in Newton-meters. public Vec3d AvgAbsMomentAboutSensorVec3d_Nm { get; } Property Value Vec3d AvgAbsMomentXAboutSensorOnSpindleRotationCoordinate_Nm Gets the average absolute moment about the sensor on spindle rotation coordinate in Newton-meters. public double AvgAbsMomentXAboutSensorOnSpindleRotationCoordinate_Nm { get; } Property Value double AvgAbsMomentXAboutToolTipOnSpindleRotationCoordinate_Nm Gets the average absolute moment about the tool tip on spindle rotation coordinate in Newton-meters. public double AvgAbsMomentXAboutToolTipOnSpindleRotationCoordinate_Nm { get; } Property Value double AvgAbsTorqueOnSpindleRotationCoordinate_Nm Gets the average of abs spindle axial torque on Spindle rotation coordinate. public double AvgAbsTorqueOnSpindleRotationCoordinate_Nm { get; } Property Value double AvgContactEdgeLengthPerFlute_mm Gets the average contact edge length per flute in millimeters. public double AvgContactEdgeLengthPerFlute_mm { get; } Property Value double AvgForceToToolOnToolRunningCoordinate_N Avg cutting force to tool on tool running coordinate. public Vec3d AvgForceToToolOnToolRunningCoordinate_N { get; } Property Value Vec3d AvgMomentAboutSensor_Nm Gets the average moment about the sensor in Newton-meters. public double AvgMomentAboutSensor_Nm { get; } Property Value double AvgMomentAboutToolTipOnProgramCoordinate_Nm Gets the average moment about the tool tip on program coordinate in Newton-meters. public Vec3d AvgMomentAboutToolTipOnProgramCoordinate_Nm { get; } Property Value Vec3d AvgMomentAboutToolTipOnToolRunningCoordinate_Nm Gets the average moment about the tool tip on tool running coordinate in Newton-meters. public Vec3d AvgMomentAboutToolTipOnToolRunningCoordinate_Nm { get; } Property Value Vec3d AvgMomentAboutToolTip_Nm Gets the average moment about the tool tip in the program coordinate system, measured in Newton-meters. public double AvgMomentAboutToolTip_Nm { get; } Property Value double AvgMomentXyAboutObservationPoint Gets the average moment about the tool tip in the program coordinate system, measured in Newton-meters. public double AvgMomentXyAboutObservationPoint { get; } Property Value double AvgRadialForcePerFluteToTool_N Gets the average radial force per flute applied to the tool in Newtons. public double AvgRadialForcePerFluteToTool_N { get; } Property Value double ChipMass_g Gets or sets the chip mass in grams. public double ChipMass_g { get; } Property Value double ChipThickness_mm Gets or sets the actual chip thickness in millimeters after cutting. public double ChipThickness_mm { get; } Property Value double ChipVolume_mm3 ChipVolume_mm3 per flute. public double ChipVolume_mm3 { get; } Property Value double ContinueSpindlePowerRatio Spindle Torque Ratio from spindle power capability on infinite insistency boundary. public double ContinueSpindlePowerRatio { get; } Property Value double ContinueSpindleTorqueRatio Spindle Torque Ratio from spindle torque capability on infinite insistency boundary. public double ContinueSpindleTorqueRatio { get; } Property Value double DeltaTipDeflectionOnToolRunningCoordinate_mm Gets the delta tip deflection on tool running coordinate in millimeters. public Vec3d DeltaTipDeflectionOnToolRunningCoordinate_mm { get; } Property Value Vec3d FrictionPower_W friction power takes by workpiece per cycle. the unit is watt. public double FrictionPower_W { get; } Property Value double IsReliefFaceCollided Gets a value indicating whether the relief face is collided. public bool? IsReliefFaceCollided { get; } Property Value bool? MaxAbsForce_N Gets the maximum absolute force in Newtons. public double MaxAbsForce_N { get; } Property Value double MaxAxialTorqueOnToolRunningCoordinateZero_Nm Gets the maximum axial torque at the tool running coordinate origin in Newton-meters. public double MaxAxialTorqueOnToolRunningCoordinateZero_Nm { get; } Property Value double MaxCompetingCuttingForceOnToolRunningCoordinate_N Gets the maximum competing cutting force on tool running coordinate in Newtons. This represents the second-strongest force during the cutting cycle. public Vec3d MaxCompetingCuttingForceOnToolRunningCoordinate_N { get; } Property Value Vec3d MaxForceOnToolRunningCoordinate_N Gets the maximum force on the tool running coordinate in Newtons. public Vec3d MaxForceOnToolRunningCoordinate_N { get; } Property Value Vec3d MaxMomentAboutSensor_Nm Gets the maximum moment about the sensor in Newton-meters. public double MaxMomentAboutSensor_Nm { get; } Property Value double MaxMomentAboutToolTip_Nm Gets the maximum moment about the tool tip in Newton-meters. public double MaxMomentAboutToolTip_Nm { get; } Property Value double MaxSpindlePowerRatio Spindle Torque Ratio from max spindle power capability. public double MaxSpindlePowerRatio { get; } Property Value double MaxSpindleTorqueRatio Spindle Torque Ratio from max spindle torque capability. public double MaxSpindleTorqueRatio { get; } Property Value double RakeFaceCycleAvgContactArea_mm2 contact area along cutter outside contact point to circle center direction. The average is for each rotation angle. This property is for computing heat transfer. public double RakeFaceCycleAvgContactArea_mm2 { get; } Property Value double ReliefFaceCollidingSpeed_mmds The negative value means there is no relief face collision. public double? ReliefFaceCollidingSpeed_mmds { get; } Property Value double? RotationAngleInterval_deg Delta angle in degree. The value is 360 / RotationDivisionNum. public double RotationAngleInterval_deg { get; } Property Value double RotationAngleInterval_rad Delta angle in radian. The value is 2 * pi / RotationDivisionNum. public double RotationAngleInterval_rad { get; } Property Value double RotationDivisionNum Gets the number of divisions used for rotation calculations. public int RotationDivisionNum { get; } Property Value int UncutChipThickness_mm Gets or sets the uncut chip thickness in millimeters. public double UncutChipThickness_mm { get; } Property Value double WorkpiecePlasticDepth_mm Positive value for compression. Negative value for tension. public double WorkpiecePlasticDepth_mm { get; } Property Value double YieldingStressRatio Gets the yielding stress ratio. public double YieldingStressRatio { get; } Property Value double Methods BuildNonSeqExtension(IMachiningTool, WorkpieceMaterial, SpindleCapability, SpindleSpeedCache, MachineMotionStep, MillingForceLuggage, MillingToolPhysicsPack) Internal use. Build extended data. In single thread, no need to use the function. In multi thread, call it before going to un-safe area. public void BuildNonSeqExtension(IMachiningTool millingTool, WorkpieceMaterial workpieceMaterial, SpindleCapability spindleCapability, SpindleSpeedCache spindleSpeedCache, MachineMotionStep machineStep, MillingForceLuggage luggage, MillingToolPhysicsPack physicsPack = null) Parameters millingTool IMachiningTool workpieceMaterial WorkpieceMaterial spindleCapability SpindleCapability spindleSpeedCache SpindleSpeedCache machineStep MachineMotionStep luggage MillingForceLuggage physicsPack MillingToolPhysicsPack GetAbsAxialPower_W() Gets the absolute axial power in Watts. public double GetAbsAxialPower_W() Returns double Absolute axial power in Watts. GetAvgForceToWorkpieceOnProgramCoordinate(MachineMotionStep) Avg cutting force on workpiece coordinate. public Vec3d GetAvgForceToWorkpieceOnProgramCoordinate(MachineMotionStep machineStep) Parameters machineStep MachineMotionStep Returns Vec3d GetAxialPowerTakenByWorkpiece_W() Gets the axial power taken by workpiece in Watts. public double GetAxialPowerTakenByWorkpiece_W() Returns double Axial power taken by workpiece in Watts. GetDeflectionTransformOnWorkpieceGeomCoordinate(IMachiningTool, WorkpieceMaterial, MachineMotionStep, Func<MillingForceLuggage>, MillingToolPhysicsPack) Gets the deflection transformation matrix in the workpiece geometric coordinate system. public Mat4d GetDeflectionTransformOnWorkpieceGeomCoordinate(IMachiningTool millingTool, WorkpieceMaterial workpieceMaterial, MachineMotionStep machineStep, Func<MillingForceLuggage> luggageFunc, MillingToolPhysicsPack physicsPack = null) Parameters millingTool IMachiningTool The milling tool. workpieceMaterial WorkpieceMaterial The workpiece material. machineStep MachineMotionStep The machining step. luggageFunc Func<MillingForceLuggage> Function to get the milling force luggage. physicsPack MillingToolPhysicsPack The frozen per-session physics pack of millingTool; null computes the tool's scalar derivations on use. Returns Mat4d The deflection transformation matrix. GetIndexAtMaxCuttingForce() Gets the index at which the maximum cutting force occurs. public int GetIndexAtMaxCuttingForce() Returns int The index of the maximum cutting force. GetInputSpindlePower_W(SpindleCapability) Gets the input spindle power in Watts. public double GetInputSpindlePower_W(SpindleCapability spindleCapability) Parameters spindleCapability SpindleCapability The spindle capability information. Returns double Input spindle power in Watts. GetMaxAbsForceSlope_NdDeg(MachiningToolHouse, WorkpieceMaterial, MachineMotionStep, Func<MillingForceLuggage>) Absolute max force changed per degree. public double GetMaxAbsForceSlope_NdDeg(MachiningToolHouse toolHouse, WorkpieceMaterial workpieceMaterial, MachineMotionStep machineStep, Func<MillingForceLuggage> luggageFunc) Parameters toolHouse MachiningToolHouse workpieceMaterial WorkpieceMaterial machineStep MachineMotionStep luggageFunc Func<MillingForceLuggage> Returns double GetMaxBottomEdgeDeflectionOnToolRunningCoordinate_mm(IMachiningTool, WorkpieceMaterial, MachineMotionStep, Func<MillingForceLuggage>, MillingToolPhysicsPack) Gets the maximum deflection of the bottom edge in the tool running coordinate system. public Vec3d GetMaxBottomEdgeDeflectionOnToolRunningCoordinate_mm(IMachiningTool millingTool, WorkpieceMaterial workpieceMaterial, MachineMotionStep machineStep, Func<MillingForceLuggage> luggageFunc, MillingToolPhysicsPack physicsPack = null) Parameters millingTool IMachiningTool The milling tool to get the deflection for. workpieceMaterial WorkpieceMaterial The workpiece material. machineStep MachineMotionStep The machining step. luggageFunc Func<MillingForceLuggage> Function to get the milling force luggage. physicsPack MillingToolPhysicsPack The frozen per-session physics pack of millingTool; null computes the tool's scalar derivations on use. Returns Vec3d The maximum deflection vector in millimeters. GetMaxDeflectionTransformOnToolRunningCoordinate(IMachiningTool, WorkpieceMaterial, MachineMotionStep, Func<MillingForceLuggage>, MillingToolPhysicsPack) GetDeflectionTransformationByTipMovementOnToolRunningCoordinate public Mat4d GetMaxDeflectionTransformOnToolRunningCoordinate(IMachiningTool millingTool_, WorkpieceMaterial workpieceMaterial, MachineMotionStep machineStep, Func<MillingForceLuggage> luggageFunc, MillingToolPhysicsPack physicsPack = null) Parameters millingTool_ IMachiningTool workpieceMaterial WorkpieceMaterial machineStep MachineMotionStep luggageFunc Func<MillingForceLuggage> physicsPack MillingToolPhysicsPack The frozen per-session physics pack of millingTool_; null computes the tool's scalar derivations on use. Returns Mat4d GetMaxTipDeflectionOnToolRunningCoordinate_mm(IMachiningTool, MillingToolPhysicsPack) Gets the maximum deflection of the tool tip in the tool running coordinate system. public Vec3d GetMaxTipDeflectionOnToolRunningCoordinate_mm(IMachiningTool millingTool, MillingToolPhysicsPack physicsPack = null) Parameters millingTool IMachiningTool The milling tool to get the deflection for. physicsPack MillingToolPhysicsPack The frozen per-session physics pack of millingTool; null computes the tool's scalar derivations on use. Returns Vec3d The maximum deflection vector in millimeters, or null when it cannot be computed: no tool, or no maximum tool force resolved yet — the force is filled lazily by the force pass, so a brief handed back before (or without) that pass carries none. Callers treat null as “no deflection known” (e.g. StepFeedSolver.BuildCompensation falls back to Zero, i.e. no compensation). NoCut(int) Builds a brief representing a physically-computed “no cut” state — i.e. EnablePhysics=true but the step has no engagement (IsTouched=false). This is semantically distinct from a null brief which means “physics was not computed at all”. All forces, moments, ratios, chip dimensions and deflections are zero; relief-face colliding speed is set to a negative sentinel so IsReliefFaceCollided returns false rather than null. public static MillingPhysicsBrief NoCut(int rotationDivisionNum) Parameters rotationDivisionNum int The rotation division count this brief reports. Returns MillingPhysicsBrief PowerWithoutFriction_W() Gets the power without friction in watts, calculated as axial power taken by workpiece minus friction power. public double PowerWithoutFriction_W() Returns double"
  },
  "api/Hi.MillingForces.PhysicsUtil.html": {
    "href": "api/Hi.MillingForces.PhysicsUtil.html",
    "title": "Class PhysicsUtil | HiAPI-C# 2025",
    "summary": "Class PhysicsUtil Namespace Hi.MillingForces Assembly HiMech.dll Provides utility methods for physics calculations in milling operations. public static class PhysicsUtil Inheritance object PhysicsUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString()"
  },
  "api/Hi.MillingForces.ProfileMillingParas.IGetLocalProfileMillingPara.html": {
    "href": "api/Hi.MillingForces.ProfileMillingParas.IGetLocalProfileMillingPara.html",
    "title": "Interface IGetLocalProfileMillingPara | HiAPI-C# 2025",
    "summary": "Interface IGetLocalProfileMillingPara Namespace Hi.MillingForces.ProfileMillingParas Assembly HiMech.dll Interface of getting LocalProfileMillingPara. public interface IGetLocalProfileMillingPara Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetMillingPara() Get LocalProfileMillingPara. LocalProfileMillingPara GetMillingPara() Returns LocalProfileMillingPara LocalProfileMillingPara"
  },
  "api/Hi.MillingForces.ProfileMillingParas.LocalProfileMillingPara.html": {
    "href": "api/Hi.MillingForces.ProfileMillingParas.LocalProfileMillingPara.html",
    "title": "Class LocalProfileMillingPara | HiAPI-C# 2025",
    "summary": "Class LocalProfileMillingPara Namespace Hi.MillingForces.ProfileMillingParas Assembly HiMech.dll Milling parameter of altintas model. public class LocalProfileMillingPara : IEquatable<LocalProfileMillingPara>, IMakeXmlSource, IGetLocalProfileMillingPara, ICsvRowIo Inheritance object LocalProfileMillingPara Implements IEquatable<LocalProfileMillingPara> IMakeXmlSource IGetLocalProfileMillingPara ICsvRowIo Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors LocalProfileMillingPara() Ctor. public LocalProfileMillingPara() LocalProfileMillingPara(Vec3d, Vec3d) Ctor. public LocalProfileMillingPara(Vec3d shearPara, Vec3d ploughPara) Parameters shearPara Vec3d shear milling parameter. (x,y,z)=(Ksr,Kst,Ksa) — the Ks convention ploughPara Vec3d plough milling parameter. (x,y,z)=(Kpr,Kpt,Kpa) — the Kp convention LocalProfileMillingPara(LocalProfileMillingPara) Copy constructor. public LocalProfileMillingPara(LocalProfileMillingPara srcPara) Parameters srcPara LocalProfileMillingPara Source parameter to copy from. LocalProfileMillingPara(double, double, double, double, double, double) Constructor with specific milling parameters. public LocalProfileMillingPara(double Krc, double Ktc, double Kac, double Kre, double Kte, double Kae) Parameters Krc double Radial shear coefficient. Ktc double Tangential shear coefficient. Kac double Axial shear coefficient. Kre double Radial plough coefficient. Kte double Tangential plough coefficient. Kae double Axial plough coefficient. LocalProfileMillingPara(XElement) Ctor by XML. public LocalProfileMillingPara(XElement src) Parameters src XElement XML Fields Zero Gets a LocalProfileMillingPara instance with all parameters set to zero. public static LocalProfileMillingPara Zero Field Value LocalProfileMillingPara Properties AA7075 Gets milling parameters for AA7075 aluminum alloy. public static LocalProfileMillingPara AA7075 { get; } Property Value LocalProfileMillingPara Al6061T6 Milling parameters for Al6061T6 material. public static LocalProfileMillingPara Al6061T6 { get; } Property Value LocalProfileMillingPara Al6061T6_ Milling parameters for Al6061T6 material (older calibration set, superseded by Al6061T6). public static LocalProfileMillingPara Al6061T6_ { get; } Property Value LocalProfileMillingPara Al6061T6_R0p5 Milling parameters for Al6061T6 material with 0.5mm radius. public static LocalProfileMillingPara Al6061T6_R0p5 { get; } Property Value LocalProfileMillingPara CsvText Csv text. public string CsvText { get; set; } Property Value string CsvTitleText Csv titles text. public string CsvTitleText { get; } Property Value string Inconel718 Gets milling parameters for Inconel 718 material. public static LocalProfileMillingPara Inconel718 { get; } Property Value LocalProfileMillingPara Kp Coefficient of (Kpr,Kpt,Kpa). public Vec3d Kp { get; set; } Property Value Vec3d Kpa Coefficient of axial plough force. public double Kpa { get; set; } Property Value double Kpr Coefficient of radial plough force. public double Kpr { get; set; } Property Value double Kpt Coefficient of tangential plough force. public double Kpt { get; set; } Property Value double Ks Coefficient of (Ksr,Kst,Ksa). public Vec3d Ks { get; set; } Property Value Vec3d Ksa Coefficient of axial shear force. public double Ksa { get; set; } Property Value double Ksr Coefficient of radial shear force. public double Ksr { get; set; } Property Value double Kst Coefficient of tangential shear force. public double Kst { get; set; } Property Value double NaN Gets a LocalProfileMillingPara instance with all parameters set to NaN (Not a Number). public static LocalProfileMillingPara NaN { get; } Property Value LocalProfileMillingPara S45C_ColumnEnd Gets milling parameters for S45C material with column end configuration. public static LocalProfileMillingPara S45C_ColumnEnd { get; } Property Value LocalProfileMillingPara SS304 Milling parameters for SS304 stainless steel. public static LocalProfileMillingPara SS304 { get; } Property Value LocalProfileMillingPara SS304_R0 Gets milling parameters for SS304 stainless steel with no radius (R0). public static LocalProfileMillingPara SS304_R0 { get; } Property Value LocalProfileMillingPara SS304_R0p5 Gets milling parameters for SS304 stainless steel with 0.5mm radius (R0.5) and 4 flutes. public static LocalProfileMillingPara SS304_R0p5 { get; } Property Value LocalProfileMillingPara SS304_R3 Gets milling parameters for SS304 stainless steel with 3mm radius (R3) and 4 flutes. public static LocalProfileMillingPara SS304_R3 { get; } Property Value LocalProfileMillingPara Steel17_4PH Milling parameters for Steel 17-4PH material. public static LocalProfileMillingPara Steel17_4PH { get; } Property Value LocalProfileMillingPara Ti6Al4V Gets milling parameters for Ti6Al4V material. public static LocalProfileMillingPara Ti6Al4V { get; } Property Value LocalProfileMillingPara Ti6Al4V_Altintas2001 Gets milling parameters for Ti6Al4V material based on Altintas 2001 research. public static LocalProfileMillingPara Ti6Al4V_Altintas2001 { get; } Property Value LocalProfileMillingPara XName Name for XML IO. public static string XName { get; } Property Value string Methods Equals(LocalProfileMillingPara) Indicates whether the current object is equal to another object of the same type. public bool Equals(LocalProfileMillingPara other) Parameters other LocalProfileMillingPara An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. GetElementByIndex(RtaMillingParaKey) Gets the parameter value by the specified key. public double GetElementByIndex(RtaMillingParaKey key) Parameters key RtaMillingParaKey The parameter key to retrieve. Returns double The parameter value corresponding to the key. GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. GetMillingPara() Get LocalProfileMillingPara. public LocalProfileMillingPara GetMillingPara() Returns LocalProfileMillingPara LocalProfileMillingPara MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetElementByIndex(RtaMillingParaKey, double) Sets the parameter value for the specified key. public void SetElementByIndex(RtaMillingParaKey key, double v) Parameters key RtaMillingParaKey The parameter key to set. v double The value to set. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.MillingForces.ProfileMillingParas.ProfileMillingParaMap.html": {
    "href": "api/Hi.MillingForces.ProfileMillingParas.ProfileMillingParaMap.html",
    "title": "Class ProfileMillingParaMap | HiAPI-C# 2025",
    "summary": "Class ProfileMillingParaMap Namespace Hi.MillingForces.ProfileMillingParas Assembly HiMech.dll Represents a mapping of milling parameters for profile milling operations. This class manages cutting parameters for both side and bottom milling operations. public class ProfileMillingParaMap : ICuttingPara, IGetCuttingPara, IMakeXmlSource, INameNote Inheritance object ProfileMillingParaMap Implements ICuttingPara IGetCuttingPara IMakeXmlSource INameNote Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods CuttingParaUtil.ToRakeFaceCuttingPara(ICuttingPara) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ProfileMillingParaMap(LocalProfileMillingPara, LocalProfileMillingPara, bool) Ctor for single LocalProfileMillingPara. public ProfileMillingParaMap(LocalProfileMillingPara sidePara, LocalProfileMillingPara bottomPara = null, bool containUpperSide = false) Parameters sidePara LocalProfileMillingPara milling parameter on side bottomPara LocalProfileMillingPara milling parameter on bottom containUpperSide bool Whether to include upper side parameters ProfileMillingParaMap(ProfileMillingParaMap) Copy ctor. public ProfileMillingParaMap(ProfileMillingParaMap src) Parameters src ProfileMillingParaMap src ProfileMillingParaMap(int, int, int, bool) Initializes a new instance of the ProfileMillingParaMap class with specified dimensions. public ProfileMillingParaMap(int fluteNum, int yDivisionNum, int zDivisionNum, bool isUpperSideContained = false) Parameters fluteNum int The number of flutes. yDivisionNum int The number of divisions in Y direction. zDivisionNum int The number of divisions in Z direction. isUpperSideContained bool Whether to include the upper side of the milling profile. ProfileMillingParaMap(XElement, string, bool) Initializes a new instance of the ProfileMillingParaMap class from XML data. public ProfileMillingParaMap(XElement src, string baseDirectory, bool isRtaVersion) Parameters src XElement The XML element containing the parameter data. baseDirectory string The base directory for resolving relative paths. isRtaVersion bool Whether the data is in RTA format. Properties BottomShearParas Gets the bottom shear parameters array. Each element contains cutting coefficients for each flute. public Vec3d[] BottomShearParas { get; } Property Value Vec3d[] ElementNum Gets the total number of elements in the parameter map. public int ElementNum { get; } Property Value int FluteFormNum Gets the number of flute forms in the parameter map. The number should be 1 or be equal to the flute number of the cutter. public int FluteFormNum { get; } Property Value int IsUpperSideContained Gets a value indicating whether the upper side of the milling profile is included in calculations. public bool IsUpperSideContained { get; } Property Value bool Name Gets or sets the name of the parameter map. public string Name { get; set; } Property Value string Note Gets or sets additional notes or descriptions for the parameter map. public string Note { get; set; } Property Value string PloughPara Gets the ploughing force coefficients (Kpr, Kpt, Kpa) for the entire tool. public Vec3d PloughPara { get; } Property Value Vec3d SideShearParas Gets the side shear parameters array. The dimensions represent [flute form, Y division, Z division]. Each element contains cutting coefficients (Ksr, Kst, Ksa) for the corresponding position. public Vec3d[,,] SideShearParas { get; } Property Value Vec3d[,,] SideYParaNum Gets the number of divisions in the Y direction for side milling parameters. public int SideYParaNum { get; } Property Value int SideZParaNum Gets the number of divisions in the Z direction for side milling parameters. public int SideZParaNum { get; } Property Value int XName Name for XML IO. public static string XName { get; } Property Value string XmlSourceFile public string XmlSourceFile { get; set; } Property Value string Methods CloneTemplate() Creates a template clone of this parameter map. public ICuttingPara CloneTemplate() Returns ICuttingPara A new instance with the same dimensions but zero values. GenUnitParas() Generates a list of unit cutting parameters. public List<ICuttingPara> GenUnitParas() Returns List<ICuttingPara> A list of unit cutting parameters. GetBottomMillingPara(int) Gets the milling parameters for the bottom of a specific flute. public LocalProfileMillingPara GetBottomMillingPara(int fluteIndex) Parameters fluteIndex int The index of the flute. Returns LocalProfileMillingPara The local milling parameters for the bottom of the specified flute. GetCuttingPara() Gets the cutting parameter interface for this instance. public ICuttingPara GetCuttingPara() Returns ICuttingPara The cutting parameter interface. GetElementByIndex(int) Gets a parameter value by its element index. public double GetElementByIndex(int elementIndex) Parameters elementIndex int The index of the element to get. Returns double The value at the specified index. GetElements() Gets the elements as an array of values. public double[] GetElements() Returns double[] An array containing all parameter values. GetSideMillingPara(int, double, double) Gets the milling parameters for a specific side position. public LocalProfileMillingPara GetSideMillingPara(int fluteIndex, double atanYX_rad, double atanZX_rad) Parameters fluteIndex int The index of the flute. atanYX_rad double The YX angle in radians. atanZX_rad double The ZX angle in radians. Returns LocalProfileMillingPara The local milling parameters for the specified position. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetElementByIndex(int, double) Sets a parameter value by its element index. public void SetElementByIndex(int elementIndex, double v) Parameters elementIndex int The index of the element to set. v double The value to set. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. ToTemplateXElement() Creates a template XML element for the parameter map. public XElement ToTemplateXElement() Returns XElement A template XML element."
  },
  "api/Hi.MillingForces.ProfileMillingParas.RtaMillingParaKey.html": {
    "href": "api/Hi.MillingForces.ProfileMillingParas.RtaMillingParaKey.html",
    "title": "Enum RtaMillingParaKey | HiAPI-C# 2025",
    "summary": "Enum RtaMillingParaKey Namespace Hi.MillingForces.ProfileMillingParas Assembly HiMech.dll Keys for milling parameters in radial-tangential-axial (RTA) coordinate system public enum RtaMillingParaKey Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Kpa = 5 Ploughing force coefficient in axial direction Kpr = 3 Ploughing force coefficient in radial direction Kpt = 4 Ploughing force coefficient in tangential direction Ksa = 2 Shear force coefficient in axial direction Ksr = 0 Shear force coefficient in radial direction Kst = 1 Shear force coefficient in tangential direction"
  },
  "api/Hi.MillingForces.ProfileMillingParas.html": {
    "href": "api/Hi.MillingForces.ProfileMillingParas.html",
    "title": "Namespace Hi.MillingForces.ProfileMillingParas | HiAPI-C# 2025",
    "summary": "Namespace Hi.MillingForces.ProfileMillingParas Classes LocalProfileMillingPara Milling parameter of altintas model. ProfileMillingParaMap Represents a mapping of milling parameters for profile milling operations. This class manages cutting parameters for both side and bottom milling operations. Interfaces IGetLocalProfileMillingPara Interface of getting LocalProfileMillingPara. Enums RtaMillingParaKey Keys for milling parameters in radial-tangential-axial (RTA) coordinate system"
  },
  "api/Hi.MillingForces.RakeFaceCuttingParas.IRakeFaceCuttingPara.html": {
    "href": "api/Hi.MillingForces.RakeFaceCuttingParas.IRakeFaceCuttingPara.html",
    "title": "Interface IRakeFaceCuttingPara | HiAPI-C# 2025",
    "summary": "Interface IRakeFaceCuttingPara Namespace Hi.MillingForces.RakeFaceCuttingParas Assembly HiMech.dll Defines cutting parameters on the rake face for force modeling, supporting XML IO and duplication. public interface IRakeFaceCuttingPara : ICuttingPara, IGetCuttingPara, IMakeXmlSource, INameNote, IDuplicate Inherited Members ICuttingPara.FluteFormNum ICuttingPara.ElementNum ICuttingPara.ToTemplateXElement() ICuttingPara.GenUnitParas() ICuttingPara.SetElementByIndex(int, double) ICuttingPara.GetElementByIndex(int) ICuttingPara.CloneTemplate() IGetCuttingPara.GetCuttingPara() IMakeXmlSource.MakeXmlSource(string, string, bool) INameNote.Name INameNote.Note IDuplicate.Duplicate(params object[]) Extension Methods CuttingParaUtil.ToRakeFaceCuttingPara(ICuttingPara) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties AnchorRakeAngle_deg Gets or sets the anchor rake angle in degrees. double AnchorRakeAngle_deg { get; set; } Property Value double AnchorRakeAngle_rad Gets or sets the anchor rake angle in radians — the rake angle this parameter set was calibrated at. double AnchorRakeAngle_rad { get; set; } Property Value double Kpc Gets or sets the ploughing coefficient along the rake face cross line (c). Unit: N/mm. double Kpc { get; set; } Property Value double Kpn Gets or sets the ploughing coefficient along the rake face normal direction (n). Unit: N/mm. double Kpn { get; set; } Property Value double Ksc Gets or sets the shear coefficient along the rake face cross line (c). Direction is from outer to center on side cutting. Unit: N/mm². double Ksc { get; set; } Property Value double Ksn Gets or sets the shear coefficient along the rake face normal direction (n). Unit: N/mm². double Ksn { get; set; } Property Value double"
  },
  "api/Hi.MillingForces.RakeFaceCuttingParas.MillingPhysicsUtil.html": {
    "href": "api/Hi.MillingForces.RakeFaceCuttingParas.MillingPhysicsUtil.html",
    "title": "Class MillingPhysicsUtil | HiAPI-C# 2025",
    "summary": "Class MillingPhysicsUtil Namespace Hi.MillingForces.RakeFaceCuttingParas Assembly HiMech.dll Utility class for milling physics calculations. public static class MillingPhysicsUtil Inheritance object MillingPhysicsUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetShearAngle_rad(double, double, double, double) Calculates the shear angle in radians based on the given rake angles and friction parameters. public static double GetShearAngle_rad(double radialRakeAngle_rad, double axialRakeAngle_rad, double frictionAngle_rad, double chipFlowAngle_rad) Parameters radialRakeAngle_rad double The radial rake angle in radians. axialRakeAngle_rad double The axial rake angle (helix angle) in radians. frictionAngle_rad double The friction angle in radians. chipFlowAngle_rad double The chip flow angle in radians. Returns double The calculated shear angle in radians, normalized to [0, π]."
  },
  "api/Hi.MillingForces.RakeFaceCuttingParas.MultiFormRakeFaceCuttingPara.html": {
    "href": "api/Hi.MillingForces.RakeFaceCuttingParas.MultiFormRakeFaceCuttingPara.html",
    "title": "Class MultiFormRakeFaceCuttingPara | HiAPI-C# 2025",
    "summary": "Class MultiFormRakeFaceCuttingPara Namespace Hi.MillingForces.RakeFaceCuttingParas Assembly HiMech.dll Represents a multi-form rake face cutting parameter set that can handle multiple flute forms. Internal Use Only. public class MultiFormRakeFaceCuttingPara : ICuttingPara, IGetCuttingPara, IMakeXmlSource, INameNote Inheritance object MultiFormRakeFaceCuttingPara Implements ICuttingPara IGetCuttingPara IMakeXmlSource INameNote Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods CuttingParaUtil.ToRakeFaceCuttingPara(ICuttingPara) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MultiFormRakeFaceCuttingPara(int) Initializes a new instance of the MultiFormRakeFaceCuttingPara class with the specified number of flute forms. public MultiFormRakeFaceCuttingPara(int fluteFormNum) Parameters fluteFormNum int The number of flute forms to initialize. MultiFormRakeFaceCuttingPara(XElement, string) Initializes a new instance of the MultiFormRakeFaceCuttingPara class from XML data. public MultiFormRakeFaceCuttingPara(XElement src, string baseDirectory) Parameters src XElement The source XML element. baseDirectory string The base directory for resolving relative paths. Properties ElementNum Gets the total number of elements in this parameter set. public int ElementNum { get; } Property Value int FluteFormNum Gets the number of flute forms in this parameter set. public int FluteFormNum { get; } Property Value int LocalRakeFaceCuttingParas Gets or sets the array of local rake face cutting parameters for each flute form. public RakeFaceCuttingPara3d[] LocalRakeFaceCuttingParas { get; set; } Property Value RakeFaceCuttingPara3d[] Name Gets or sets the name of this parameter set. public string Name { get; set; } Property Value string Note Gets or sets additional notes about this parameter set. public string Note { get; set; } Property Value string XName Gets the XML element name for this type. public static string XName { get; } Property Value string XmlSourceFile Gets or sets the XML source file path. public string XmlSourceFile { get; set; } Property Value string Methods CloneTemplate() Creates a clone of this parameter set as a template. public ICuttingPara CloneTemplate() Returns ICuttingPara A cloned instance of this parameter set. GenUnitParas() Generates a list of unit cutting parameters. public List<ICuttingPara> GenUnitParas() Returns List<ICuttingPara> A list of unit cutting parameters. GetCuttingPara() Gets this instance as an ICuttingPara. public ICuttingPara GetCuttingPara() Returns ICuttingPara This instance. GetElementByIndex(int) Gets the value of an element at the specified index. public double GetElementByIndex(int elementIndex) Parameters elementIndex int The index of the element to get. Returns double The value of the element at the specified index. GetLocalRakeFaceCuttingPara(int) Gets the local rake face cutting parameters for the specified flute index. public RakeFaceCuttingPara3d GetLocalRakeFaceCuttingPara(int fluteIndex) Parameters fluteIndex int The zero-based index of the flute. Returns RakeFaceCuttingPara3d The rake face cutting parameters for the specified flute. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetElementByIndex(int, double) Sets the value of an element at the specified index. public void SetElementByIndex(int elementIndex, double v) Parameters elementIndex int The index of the element to set. v double The value to set. ToString() Returns a string representation of this parameter set. public override string ToString() Returns string A string containing the name and note of this parameter set. ToTemplateXElement() Get XElement for templating. public XElement ToTemplateXElement() Returns XElement"
  },
  "api/Hi.MillingForces.RakeFaceCuttingParas.RakeFaceCuttingPara2d.html": {
    "href": "api/Hi.MillingForces.RakeFaceCuttingParas.RakeFaceCuttingPara2d.html",
    "title": "Class RakeFaceCuttingPara2d | HiAPI-C# 2025",
    "summary": "Class RakeFaceCuttingPara2d Namespace Hi.MillingForces.RakeFaceCuttingParas Assembly HiMech.dll Represents a 2D cutting parameter for rake face cutting operations. public class RakeFaceCuttingPara2d : IRakeFaceCuttingPara, ICuttingPara, IGetCuttingPara, IMakeXmlSource, INameNote, IDuplicate Inheritance object RakeFaceCuttingPara2d Implements IRakeFaceCuttingPara ICuttingPara IGetCuttingPara IMakeXmlSource INameNote IDuplicate Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods CuttingParaUtil.ToRakeFaceCuttingPara(ICuttingPara) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors RakeFaceCuttingPara2d() Initializes a new instance of the RakeFaceCuttingPara2d class. public RakeFaceCuttingPara2d() RakeFaceCuttingPara2d(RakeFaceCuttingPara2d) Initializes a new instance of the RakeFaceCuttingPara2d class by copying from another instance. public RakeFaceCuttingPara2d(RakeFaceCuttingPara2d src) Parameters src RakeFaceCuttingPara2d The source instance to copy from. RakeFaceCuttingPara2d(XElement, string) Initializes a new instance of the RakeFaceCuttingPara2d class from XML. public RakeFaceCuttingPara2d(XElement src, string baseDirectory) Parameters src XElement The XML source element. baseDirectory string The base directory for resolving relative paths. Fields element_num Gets the number of elements in the cutting parameter. public const int element_num = 4 Field Value int Properties AnchorRakeAngle_deg Gets or sets the anchor rake angle in degrees. public double AnchorRakeAngle_deg { get; set; } Property Value double AnchorRakeAngle_rad Gets or sets the anchor rake angle in radians — the rake angle this parameter set was calibrated at. public double AnchorRakeAngle_rad { get; set; } Property Value double ElementNum Element number. public int ElementNum { get; } Property Value int FluteFormNum Flute form number. public int FluteFormNum { get; } Property Value int Kp Gets the ploughing coefficient vector in ECN coordinates. public Vec2d Kp { get; set; } Property Value Vec2d Kpc Gets or sets the ploughing coefficient along the rake face cross line (c). Unit: N/mm. public double Kpc { get; set; } Property Value double Kpn Gets or sets the ploughing coefficient along the rake face normal direction (n). Unit: N/mm. public double Kpn { get; set; } Property Value double Ks Gets the shear coefficient vector in ECN coordinates. public Vec2d Ks { get; set; } Property Value Vec2d Ksc Gets or sets the shear coefficient along the rake face cross line (c). Direction is from outer to center on side cutting. Unit: N/mm�. public double Ksc { get; set; } Property Value double Ksn Gets or sets the shear coefficient along the rake face normal direction (n). Unit: N/mm�. public double Ksn { get; set; } Property Value double Name Gets or sets the name of the cutting parameter. public string Name { get; set; } Property Value string Note Gets or sets additional notes about the cutting parameter. public string Note { get; set; } Property Value string XName Name for XML IO. public static string XName { get; } Property Value string XmlSourceFile public string XmlSourceFile { get; set; } Property Value string Methods CloneTemplate() Clone template. public ICuttingPara CloneTemplate() Returns ICuttingPara clone template Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object GenUnitParas() Generate the ICuttingPara set used by parameter training. The list length equals ElementNum; entry i corresponds to the element of index i (see SetElementByIndex). public List<ICuttingPara> GenUnitParas() Returns List<ICuttingPara> training parameters. GetCuttingPara() Get ICuttingPara. public ICuttingPara GetCuttingPara() Returns ICuttingPara ICuttingPara GetElementByIndex(int) Gets the cutting parameter element at the specified index. public double GetElementByIndex(int index) Parameters index int The index of the element to retrieve. Returns double The cutting parameter element at the specified index. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetElementByIndex(int, double) Sets the value of an element at the specified index. public void SetElementByIndex(int elementIndex, double v) Parameters elementIndex int The index of the element to set (0-3; see element_num). v double The value to set. Remarks Index mapping: 0 - Ksc (N/mm^2) 1 - Ksn (N/mm^2) 2 - Kpc (N/mm) 3 - Kpn (N/mm) ToTemplateXElement() Get XElement for templating. public XElement ToTemplateXElement() Returns XElement"
  },
  "api/Hi.MillingForces.RakeFaceCuttingParas.RakeFaceCuttingPara3d.html": {
    "href": "api/Hi.MillingForces.RakeFaceCuttingParas.RakeFaceCuttingPara3d.html",
    "title": "Class RakeFaceCuttingPara3d | HiAPI-C# 2025",
    "summary": "Class RakeFaceCuttingPara3d Namespace Hi.MillingForces.RakeFaceCuttingParas Assembly HiMech.dll Represents local ECN (Edge-Cross-Normal) cutting parameters for rake face cutting. E: cutting edge direction C: Cross vector, along the rake face cross line, perpendicular to cutting edge N: rake face normal direction Internal Use Only. public class RakeFaceCuttingPara3d : IRakeFaceCuttingPara, ICuttingPara, IGetCuttingPara, IMakeXmlSource, INameNote, IDuplicate Inheritance object RakeFaceCuttingPara3d Implements IRakeFaceCuttingPara ICuttingPara IGetCuttingPara IMakeXmlSource INameNote IDuplicate Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods CuttingParaUtil.ToRakeFaceCuttingPara(ICuttingPara) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks Velocity is measured relative to the cutter Resulting force is applied to the cutter Constructors RakeFaceCuttingPara3d() Initializes a new instance of the RakeFaceCuttingPara class. public RakeFaceCuttingPara3d() RakeFaceCuttingPara3d(Vec3d, Vec3d, double) Initializes a new instance of the RakeFaceCuttingPara class with specified shear and plough vectors. public RakeFaceCuttingPara3d(Vec3d shearEcn, Vec3d ploughEcn, double anchorRakeAngle_rad = NaN) Parameters shearEcn Vec3d The shear coefficient vector in ECN coordinates (N/mm�). ploughEcn Vec3d The plough coefficient vector in ECN coordinates (N/mm). anchorRakeAngle_rad double The anchor rake angle in radians. RakeFaceCuttingPara3d(RakeFaceCuttingPara3d) Initializes a new instance of the RakeFaceCuttingPara class by copying from another instance. public RakeFaceCuttingPara3d(RakeFaceCuttingPara3d src) Parameters src RakeFaceCuttingPara3d The source instance to copy from. RakeFaceCuttingPara3d(double, double, double, double, double, double, double) Initializes a new instance of the RakeFaceCuttingPara class with individual coefficient values. public RakeFaceCuttingPara3d(double kse, double ksc, double ksn, double kpe, double kpc, double kpn, double anchorRakeAngle_rad) Parameters kse double The shear coefficient along the cutting edge direction (N/mm�). ksc double The shear coefficient along the rake face cross line (N/mm�). ksn double The shear coefficient along the rake face normal direction (N/mm�). kpe double The plough coefficient along the cutting edge direction (N/mm). kpc double The plough coefficient along the rake face cross line (N/mm). kpn double The plough coefficient along the rake face normal direction (N/mm). anchorRakeAngle_rad double The anchor rake angle in radians. RakeFaceCuttingPara3d(XElement, string) Ctor by XML. public RakeFaceCuttingPara3d(XElement src, string baseDirectory) Parameters src XElement XML baseDirectory string Base directory path for resolving relative paths Properties AnchorRakeAngle_deg Gets or sets the anchor rake angle in degrees. public double AnchorRakeAngle_deg { get; set; } Property Value double AnchorRakeAngle_rad Gets or sets the anchor rake angle in radians — the rake angle this parameter set was calibrated at. public double AnchorRakeAngle_rad { get; set; } Property Value double ChipFlowAngle_deg Gets the chip flow angle in degrees. public double ChipFlowAngle_deg { get; } Property Value double ChipFlowAngle_rad Gets or sets the chip flow angle in radians. public double ChipFlowAngle_rad { get; } Property Value double CsvText Gets or sets the cutting parameters as a comma-separated value string. Format: Kse,Ksc,Ksn,Kpe,Kpc,Kpn,AnchorRakeAngle_deg public string CsvText { get; set; } Property Value string ElementNum Element number: 6 for (Shear(e,c,n),Plough(e,c,n)). public int ElementNum { get; } Property Value int FluteFormNum Gets the number of flute forms in this parameter set. Always returns 1 as this class represents a single form. public int FluteFormNum { get; } Property Value int FrictionAngle_deg Gets the friction angle in degrees. public double FrictionAngle_deg { get; } Property Value double FrictionAngle_rad Gets the friction angle in radians. public double FrictionAngle_rad { get; } Property Value double Kp Gets the ploughing coefficient vector in ECN coordinates. public Vec3d Kp { get; set; } Property Value Vec3d KpOnZeroRakeAngleCoordinate Gets Kp expressed on the zero-rake-angle coordinate (a NaN AnchorRakeAngle_rad is treated as zero). public Vec3d KpOnZeroRakeAngleCoordinate { get; } Property Value Vec3d Kpc Gets or sets the ploughing coefficient along the rake face cross line (c). Unit: N/mm. public double Kpc { get; set; } Property Value double Kpe Gets or sets the ploughing coefficient along the cutting edge direction (e). Unit: N/mm. public double Kpe { get; set; } Property Value double Kpn Gets or sets the ploughing coefficient along the rake face normal direction (n). Unit: N/mm. public double Kpn { get; set; } Property Value double Ks Gets the shear coefficient vector in ECN coordinates. public Vec3d Ks { get; set; } Property Value Vec3d Ksc Gets or sets the shear coefficient along the rake face cross line (c). Direction is from outer to center on side cutting. Unit: N/mm�. public double Ksc { get; set; } Property Value double Kse Gets or sets the shear coefficient along the cutting edge direction (e). Direction is from lower to upper on side cutting. Unit: N/mm�. public double Kse { get; set; } Property Value double Ksn Gets or sets the shear coefficient along the rake face normal direction (n). Unit: N/mm�. public double Ksn { get; set; } Property Value double Name Gets or sets the name of this parameter set. public string Name { get; set; } Property Value string Note Gets or sets additional notes about this parameter set. public string Note { get; set; } Property Value string XName Gets the XML element name for this type. public static string XName { get; } Property Value string Methods CloneTemplate() Creates a clone of this parameter set as a template. public ICuttingPara CloneTemplate() Returns ICuttingPara A new instance with the same anchor rake angle. Duplicate(params object[]) Creates a deep copy of this instance. public object Duplicate(params object[] res) Parameters res object[] Optional parameters (not used). Returns object A new instance with the same values. GenUnitParas() Generate the ICuttingPara set used by parameter training. The list length equals ElementNum; entry i corresponds to the element of index i (see SetElementByIndex). public List<ICuttingPara> GenUnitParas() Returns List<ICuttingPara> training parameters. GetCuttingPara() Gets this instance as an ICuttingPara. public ICuttingPara GetCuttingPara() Returns ICuttingPara This instance. GetElementByIndex(int) value of (Shear(e,c,n),Plough(e,c,n)) by index. public double GetElementByIndex(int index) Parameters index int The index of the element to get (0-5). Returns double The value at the specified index. Remarks Index mapping: 0 - Kse (N/mm�) 1 - Ksc (N/mm�) 2 - Ksn (N/mm�) 3 - Kpe (N/mm) 4 - Kpc (N/mm) 5 - Kpn (N/mm) MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetElementByIndex(int, double) Sets the value of an element at the specified index. public void SetElementByIndex(int elementIndex, double v) Parameters elementIndex int The index of the element to set (0-5). v double The value to set. Remarks Index mapping: 0 - Kse (N/mm�) 1 - Ksc (N/mm�) 2 - Ksn (N/mm�) 3 - Kpe (N/mm) 4 - Kpc (N/mm) 5 - Kpn (N/mm) ToTemplateXElement() Get XElement for templating. public XElement ToTemplateXElement() Returns XElement"
  },
  "api/Hi.MillingForces.RakeFaceCuttingParas.RakeFaceCuttingParaMap.html": {
    "href": "api/Hi.MillingForces.RakeFaceCuttingParas.RakeFaceCuttingParaMap.html",
    "title": "Class RakeFaceCuttingParaMap | HiAPI-C# 2025",
    "summary": "Class RakeFaceCuttingParaMap Namespace Hi.MillingForces.RakeFaceCuttingParas Assembly HiMech.dll Represents a map of rake face cutting parameters. public class RakeFaceCuttingParaMap : ICuttingPara, IGetCuttingPara, IMakeXmlSource, INameNote, ICloneable Inheritance object RakeFaceCuttingParaMap Implements ICuttingPara IGetCuttingPara IMakeXmlSource INameNote ICloneable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods CuttingParaUtil.ToRakeFaceCuttingPara(ICuttingPara) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors RakeFaceCuttingParaMap(RakeFaceCuttingParaMap) Creates a copy of this parameter map. public RakeFaceCuttingParaMap(RakeFaceCuttingParaMap source) Parameters source RakeFaceCuttingParaMap The source parameter map to copy from. RakeFaceCuttingParaMap(int, int, int) Initializes a new instance of the RakeFaceCuttingParaMap class. public RakeFaceCuttingParaMap(int fluteFormNum, int nAngleDivisionNum, int ecAngleDivisionNum) Parameters fluteFormNum int The number of flute forms. nAngleDivisionNum int The number of normal angle divisions. ecAngleDivisionNum int The number of eccentric angle divisions. RakeFaceCuttingParaMap(XElement, string) Ctor by XML. public RakeFaceCuttingParaMap(XElement src, string baseDirectory) Parameters src XElement XML baseDirectory string Base directory path for resolving relative paths Properties CircleParas CircleParas[FluteFormIndex,NAngleIndex,EcAngleIndex]. public Vec3d[,,] CircleParas { get; } Property Value Vec3d[,,] EcAngleDivisionNum Angle division number from +E axis on EC plane. Note that range of EcAngle is -pi~pi. public int EcAngleDivisionNum { get; } Property Value int EcAngleInterval_deg Gets or sets the eccentric angle interval in degrees. public double EcAngleInterval_deg { get; } Property Value double EcAngleInterval_rad Gets or sets the eccentric angle interval in radians. public double EcAngleInterval_rad { get; } Property Value double ElementNum Element number. public int ElementNum { get; } Property Value int FluteFormNum Gets or sets the number of flute forms. public int FluteFormNum { get; } Property Value int NAngleDivisionNum Angle division number from N axis. Like R on polar coordinate, but it expresses by angle. Note that range of NAngle is 0~pi/2. public int NAngleDivisionNum { get; } Property Value int NAngleInterval_deg Gets or sets the normal angle interval in degrees. public double NAngleInterval_deg { get; } Property Value double NAngleInterval_rad Gets or sets the normal angle interval in radians. public double NAngleInterval_rad { get; } Property Value double Name Gets or sets the name of the parameter map. public string Name { get; set; } Property Value string Note Gets or sets the note for the parameter map. public string Note { get; set; } Property Value string PloughParas Gets or sets the ploughing parameters. public Vec3d[] PloughParas { get; } Property Value Vec3d[] TipParas TipParas[FluteFormIndex]. tip shear para. public Vec3d[] TipParas { get; } Property Value Vec3d[] XName Name for XML IO. public static string XName { get; } Property Value string XmlSourceFile public string XmlSourceFile { get; set; } Property Value string Methods Clone() Creates a new object that is a copy of the current instance. public object Clone() Returns object A new object that is a copy of this instance. CloneTemplate() Clone template. public ICuttingPara CloneTemplate() Returns ICuttingPara clone template GenUnitParas() Generate the ICuttingPara set used by parameter training. The list length equals ElementNum; entry i corresponds to the element of index i (see SetElementByIndex). public List<ICuttingPara> GenUnitParas() Returns List<ICuttingPara> training parameters. GetCuttingPara() Get ICuttingPara. public ICuttingPara GetCuttingPara() Returns ICuttingPara ICuttingPara GetElementByIndex(int) Get element by index. For parameter training. public double GetElementByIndex(int elementIndex) Parameters elementIndex int element index Returns double value GetLocalRakeFaceCuttingPara(int, double, double) Gets the local rake face cutting parameters for the specified conditions. public RakeFaceCuttingPara3d GetLocalRakeFaceCuttingPara(int fluteIndex, double nAngle_rad, double ecAngle_rad) Parameters fluteIndex int The index of the flute. nAngle_rad double The normal angle in radians. ecAngle_rad double The effective cutting angle in radians. Returns RakeFaceCuttingPara3d A rake face cutting parameter object. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetElementByIndex(int, double) Set element by index. For parameter training. public void SetElementByIndex(int elementIndex, double v) Parameters elementIndex int element index v double value Test() Test method for validating the interpolation functionality of the RakeFaceCuttingParaMap. Creates a sample map and outputs interpolated values at various angles. public static void Test() ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. ToTemplateXElement() Get XElement for templating. public XElement ToTemplateXElement() Returns XElement"
  },
  "api/Hi.MillingForces.RakeFaceCuttingParas.html": {
    "href": "api/Hi.MillingForces.RakeFaceCuttingParas.html",
    "title": "Namespace Hi.MillingForces.RakeFaceCuttingParas | HiAPI-C# 2025",
    "summary": "Namespace Hi.MillingForces.RakeFaceCuttingParas Classes MillingPhysicsUtil Utility class for milling physics calculations. MultiFormRakeFaceCuttingPara Represents a multi-form rake face cutting parameter set that can handle multiple flute forms. Internal Use Only. RakeFaceCuttingPara2d Represents a 2D cutting parameter for rake face cutting operations. RakeFaceCuttingPara3d Represents local ECN (Edge-Cross-Normal) cutting parameters for rake face cutting. E: cutting edge direction C: Cross vector, along the rake face cross line, perpendicular to cutting edge N: rake face normal direction Internal Use Only. RakeFaceCuttingParaMap Represents a map of rake face cutting parameters. Interfaces IRakeFaceCuttingPara Defines cutting parameters on the rake face for force modeling, supporting XML IO and duplication."
  },
  "api/Hi.MillingForces.ToolObservationReference.html": {
    "href": "api/Hi.MillingForces.ToolObservationReference.html",
    "title": "Enum ToolObservationReference | HiAPI-C# 2025",
    "summary": "Enum ToolObservationReference Namespace Hi.MillingForces Assembly HiMech.dll Defines reference points for tool observation measurements. [Flags] public enum ToolObservationReference Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields HolderShankBuckle = 18 The holder shank buckle reference point combined with tool side. ProgramZero = 8 The program zero reference point. SpindleHolderBuckle = 20 The spindle holder buckle reference point combined with tool side. ToolSide = 16 The tool side reference point. ToolTip = 17 The tool tip reference point combined with tool side."
  },
  "api/Hi.MillingForces.Training.MillingParaTrainResult.html": {
    "href": "api/Hi.MillingForces.Training.MillingParaTrainResult.html",
    "title": "Class MillingParaTrainResult | HiAPI-C# 2025",
    "summary": "Class MillingParaTrainResult Namespace Hi.MillingForces.Training Assembly HiNc.dll Snapshot of the most recent milling-parameter training call (LocalProjectService.TrainMillingPara / ReTrainMillingPara) — the queryable training outcome that otherwise only lands in the output .mp file's Note. Held by LocalProjectService.LastMillingParaTrainResult (service lifetime, last-wins) so callers such as the webservice can read it after a run without touching the file system. public class MillingParaTrainResult Inheritance object MillingParaTrainResult Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties CorrelationR Correlation coefficient R of the built parameter against the filtered samples (0..1); null when unavailable. public double? CorrelationR { get; set; } Property Value double? DstRelFile Destination file the built parameter was saved to (relative to the project base directory); null when not saved. public string DstRelFile { get; set; } Property Value string FilteredSampleNum Number of training samples that survived outlier filtering. public int FilteredSampleNum { get; set; } Property Value int Kind Which call produced the snapshot: “Train” or “ReTrain”. public string Kind { get; set; } Property Value string Note The built parameter's Note — the human-readable summary also written into the .mp file. public string Note { get; set; } Property Value string OutlierRatio The outlier exclusion ratio the training used. public double OutlierRatio { get; set; } Property Value double ParaName The built parameter's Name (the destination file name). public string ParaName { get; set; } Property Value string ParaTypeName The built parameter's concrete type name (e.g. RakeFaceCuttingPara2d). public string ParaTypeName { get; set; } Property Value string ParaXml The built parameter's full XML source — carries every trained coefficient in the same form as the saved .mp file. public string ParaXml { get; set; } Property Value string SampleFlags The SampleFlag combination the training used (enum text, e.g. “Mx, My, Mz”). public string SampleFlags { get; set; } Property Value string Succeeded False when the training aborted without a built parameter (no mapped data / no samples); the run's messages explain why. public bool Succeeded { get; set; } Property Value bool TrainedAtUtc UTC instant the training call completed. public DateTime TrainedAtUtc { get; set; } Property Value DateTime"
  },
  "api/Hi.MillingForces.Training.MillingTraining.html": {
    "href": "api/Hi.MillingForces.Training.MillingTraining.html",
    "title": "Class MillingTraining | HiAPI-C# 2025",
    "summary": "Class MillingTraining Namespace Hi.MillingForces.Training Assembly HiNc.dll Provides utilities for milling force training and parameter identification. public static class MillingTraining Inheritance object MillingTraining Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields DesignMatrixSvdRelativeTol Relative singular-value cutoff (σ_i/σ_max on σ(M)) for the truncated pseudo-inverse of the lead-para fit when EnableDesignMatrixSolver is on. Replaces the legacy absolute gap (1e-7) applied to σ(MᵀM) = σ(M)², whose effective cut depends on the data scale. public static double DesignMatrixSvdRelativeTol Field Value double EnableCwePhasePairing When enabled, GatherAndBuild(ICuttingPara, ConcurrentDictionary<int, List<ITimeShot>>, ClStrip, SampleFlag, bool, double, IProgress<IMessage>, CancellationToken, out double, out int) determines each step's rotation phase by the CWE block-pairing detector (Hi.MillingForces.Training.MillingPhasePairing) instead of the self-bootstrapped averaged-basis lead parameter, and replaces the averaged-basis outlier pre-filter by a residual-based pass. Applies to one-flute and symmetric two-flute cutters in light radial side cuts (contact arc smaller than the flute pitch); when its preconditions do not hold the training falls back to the legacy lead path with a warning. public static bool EnableCwePhasePairing Field Value bool EnableDesignMatrixSolver When enabled, the least-squares fits are solved directly on the N-by-p design matrix M (thin QR, plus SVD of its R factor for the lead-para truncated pseudo-inverse) instead of forming the normal-equation matrix MᵀM first. Forming MᵀM squares the condition number (κ(MᵀM) = κ(M)²), which halves the usable precision and blurs the rank structure; the direct path keeps σ(M) intact at the same p-by-p solve size. Experimental flag for the QR-vs-MᵀM solver comparison. public static bool EnableDesignMatrixSolver Field Value bool EnableMzLeverWeighting Gets or sets whether Mz lever weighting is enabled during training sample gathering. public static bool EnableMzLeverWeighting Field Value bool EnableSampleNormalization [Obsolete] public static bool EnableSampleNormalization Field Value bool Remarks The input normalization deminish the quantity effect. The R-value decreases from 99% to 70% in an observed moment-training case. Don't apply this option. MissingEngagementAbortRatio Abort threshold on the fraction of touched, force-bearing steps whose milling-step engagement could not be used during sample gathering — either the luggage row was unreadable, or the row was present but the engagement was never built (physics inactive at simulation time). At or below the threshold the misses are reported as a summary warning and training continues on the remaining steps; above it the training aborts with a ConfigurationError instead of silently building a model from a fraction of the play (one such degraded sweep cell once produced outlier coefficients that were nearly read as a resolution effect). Set to 1 to never abort. public static double MissingEngagementAbortRatio Field Value double ReTrainAnchorOutputScale Weight scale of the virtual anchor samples that pull a GatherAndGetUpdate(ConcurrentDictionary<int, List<ITimeShot>>, ClStrip, ICuttingPara, SampleFlag, double, IProgress<IMessage>, CancellationToken) (ReTrain) result back toward its seed parameter. The anchors are generated at scale * Σoutput / ElementNum per coefficient, so their curvature grows as N² against the data's N — at large sample counts they dominate and the result reproduces the seed. Set to 0 to make ReTrain purely data-driven: the seed then only supplies the phase alignment and the outlier scoring, which turns ReTrain into an external-lead identifiability instrument (\"with a known-good lead but no prior, what do the data actually say?\"). The default 0.1 keeps the historical seed-anchored ridge behaviour. public static double ReTrainAnchorOutputScale Field Value double Properties CycleDivisionNum Division number of a spindle cycle. public static int CycleDivisionNum { get; } Property Value int DefaultParaTemplate Gets or sets the parameter template for cutting operations. public static ICuttingPara DefaultParaTemplate { get; set; } Property Value ICuttingPara StepQuantityNames Gets the names of step quantities used in training. public static string[] StepQuantityNames { get; } Property Value string[] TextAngleOffset_deg Gets the text key for angle offset in degrees. public static string TextAngleOffset_deg { get; } Property Value string TextTrainingErrRatio Gets the text key for training error ratio. public static string TextTrainingErrRatio { get; } Property Value string Methods Convert(ICuttingPara, ICuttingPara, GeneralApt, double, double, IProgress<IMessage>, CancellationToken) Converts one cutting parameter model to another based on the provided parameters. public static ICuttingPara Convert(ICuttingPara src, ICuttingPara resultParaTemplate, GeneralApt apt, double helixAngle_rad, double radialRakeAngle_rad, IProgress<IMessage> messageProgress, CancellationToken cancellationToken) Parameters src ICuttingPara Source cutting parameter model resultParaTemplate ICuttingPara Destination template for the converted model apt GeneralApt General apt parameters helixAngle_rad double Helix angle in radians radialRakeAngle_rad double Radial rake angle in radians messageProgress IProgress<IMessage> Message host for logging cancellationToken CancellationToken Cancellation token Returns ICuttingPara The converted cutting parameter model Convert(LocalProfileMillingPara, double, double, IProgress<IMessage>, CancellationToken) Converts a LocalProfileMillingPara to a RakeFaceCuttingPara. public static RakeFaceCuttingPara2d Convert(LocalProfileMillingPara src, double helixAngle_rad, double radialRakeAngle_rad, IProgress<IMessage> messageProgress, CancellationToken cancellationToken) Parameters src LocalProfileMillingPara Source LocalProfileMillingPara helixAngle_rad double Helix angle in radians radialRakeAngle_rad double Radial rake angle in radians messageProgress IProgress<IMessage> Message host for logging cancellationToken CancellationToken Cancellation token Returns RakeFaceCuttingPara2d The converted RakeFaceCuttingPara GatherAndGetUpdate(ConcurrentDictionary<int, List<ITimeShot>>, ClStrip, ICuttingPara, SampleFlag, double, IProgress<IMessage>, CancellationToken) Gathers training samples and updates an existing cutting parameter model. public static ICuttingPara GatherAndGetUpdate(ConcurrentDictionary<int, List<ITimeShot>> stepToTimeShotListDictionary, ClStrip clStrip, ICuttingPara anchorPara, SampleFlag sampleFlags, double outlierRatio, IProgress<IMessage> messageProgress, CancellationToken cancellationToken) Parameters stepToTimeShotListDictionary ConcurrentDictionary<int, List<ITimeShot>> Dictionary mapping step indices to time shot lists clStrip ClStrip The cutter location strip anchorPara ICuttingPara The anchor cutting parameter model to update sampleFlags SampleFlag Sample flags indicating which forces to use outlierRatio double Ratio of outliers to exclude messageProgress IProgress<IMessage> Message host for logging cancellationToken CancellationToken Cancellation token Returns ICuttingPara The updated cutting parameter model"
  },
  "api/Hi.MillingForces.Training.html": {
    "href": "api/Hi.MillingForces.Training.html",
    "title": "Namespace Hi.MillingForces.Training | HiAPI-C# 2025",
    "summary": "Namespace Hi.MillingForces.Training Classes MillingParaTrainResult Snapshot of the most recent milling-parameter training call (LocalProjectService.TrainMillingPara / ReTrainMillingPara) — the queryable training outcome that otherwise only lands in the output .mp file's Note. Held by LocalProjectService.LastMillingParaTrainResult (service lifetime, last-wins) so callers such as the webservice can read it after a run without touching the file system. MillingTraining Provides utilities for milling force training and parameter identification."
  },
  "api/Hi.MillingForces.html": {
    "href": "api/Hi.MillingForces.html",
    "title": "Namespace Hi.MillingForces | HiAPI-C# 2025",
    "summary": "Namespace Hi.MillingForces Classes MillingForce Milling force. MillingForceLicense Provides license information and management for the milling force calculation functionality. MillingForceLuggage Represents a container for milling force data and calculations. MillingForceUtil Utility class for milling force calculations and related operations. MillingPhysicsBrief Instant Physics brief on rake face for milling. PhysicsUtil Provides utility methods for physics calculations in milling operations. Interfaces IGetMillingForce Interface of GetMillingForce(). IMillingForceAccessor Interface of MillingForce. Enums ToolObservationReference Defines reference points for tool observation measurements."
  },
  "api/Hi.MillingProcs.MillingGuide.html": {
    "href": "api/Hi.MillingProcs.MillingGuide.html",
    "title": "Class MillingGuide | HiAPI-C# 2025",
    "summary": "Class MillingGuide Namespace Hi.MillingProcs Assembly HiNc.dll Provides guidance and configuration for milling visualization and analysis. public class MillingGuide : IMakeXmlSource Inheritance object MillingGuide Implements IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MillingGuide() Initializes a new instance of the MillingGuide class with default configurations. public MillingGuide() MillingGuide(XElement, string, IProgress<IMessage>) Initializes a new instance of the MillingGuide class from XML data. public MillingGuide(XElement src, string baseDirectory, IProgress<IMessage> progress) Parameters src XElement XML element containing configuration data baseDirectory string Base directory for resolving relative paths progress IProgress<IMessage> Progress reporter for XML deserialization. Properties ClStripChartConfig Gets or sets the configuration for cutter location strip charts. public ClStripChartConfig ClStripChartConfig { get; set; } Property Value ClStripChartConfig DictionaryColorGuide Gets or sets the dictionary of color guides for visualizing different properties. public DictionaryColorGuide DictionaryColorGuide { get; set; } Property Value DictionaryColorGuide ForceWCycleLineDivConfig Gets or sets the configuration for force cycle line division. public ForceCycleLineDivConfig ForceWCycleLineDivConfig { get; set; } Property Value ForceCycleLineDivConfig SensorSpindleMomentCycleLineDivConfig Gets or sets the configuration for sensor spindle moment cycle line division. public SpindleMomentCycleLineDivConfig SensorSpindleMomentCycleLineDivConfig { get; set; } Property Value SpindleMomentCycleLineDivConfig SimSpindleMomentCycleLineDivConfig Gets or sets the configuration for simulation spindle moment cycle line division. public SpindleMomentCycleLineDivConfig SimSpindleMomentCycleLineDivConfig { get; set; } Property Value SpindleMomentCycleLineDivConfig XName Name for XML IO. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.MillingProcs.html": {
    "href": "api/Hi.MillingProcs.html",
    "title": "Namespace Hi.MillingProcs | HiAPI-C# 2025",
    "summary": "Namespace Hi.MillingProcs Classes MillingGuide Provides guidance and configuration for milling visualization and analysis."
  },
  "api/Hi.MillingStepUtils.ClStripChartConfig.html": {
    "href": "api/Hi.MillingStepUtils.ClStripChartConfig.html",
    "title": "Class ClStripChartConfig | HiAPI-C# 2025",
    "summary": "Class ClStripChartConfig Namespace Hi.MillingStepUtils Assembly HiNc.dll Configuration for ClStrip charts. public class ClStripChartConfig : IMakeXmlSource Inheritance object ClStripChartConfig Implements IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ClStripChartConfig() Initializes a new instance of the ClStripChartConfig class. public ClStripChartConfig() ClStripChartConfig(XElement) Ctor. public ClStripChartConfig(XElement src) Parameters src XElement XML Properties ItemConfigDictionary Dictionary of chart item configurations, indexed by key. public Dictionary<string, ClStripChartItemConfig> ItemConfigDictionary { get; set; } Property Value Dictionary<string, ClStripChartItemConfig> XName Name for XML IO. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.MillingStepUtils.ClStripChartItemConfig.html": {
    "href": "api/Hi.MillingStepUtils.ClStripChartItemConfig.html",
    "title": "Class ClStripChartItemConfig | HiAPI-C# 2025",
    "summary": "Class ClStripChartItemConfig Namespace Hi.MillingStepUtils Assembly HiNc.dll Configuration for an individual ClStrip chart item. public class ClStripChartItemConfig : IMakeXmlSource Inheritance object ClStripChartItemConfig Implements IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ClStripChartItemConfig() Ctor. public ClStripChartItemConfig() ClStripChartItemConfig(XElement) Ctor. public ClStripChartItemConfig(XElement src) Parameters src XElement XML Properties TimeChartYConfig Gets or sets the Y-axis configuration for time charts. public TimeChartYConfig TimeChartYConfig { get; set; } Property Value TimeChartYConfig XName Name for XML IO. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.MillingStepUtils.ForceCycleFlag.html": {
    "href": "api/Hi.MillingStepUtils.ForceCycleFlag.html",
    "title": "Enum ForceCycleFlag | HiAPI-C# 2025",
    "summary": "Enum ForceCycleFlag Namespace Hi.MillingStepUtils Assembly HiNc.dll Flags representing different force cycle types. public enum ForceCycleFlag Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields ForceToToolOnToolRunningCoordinate = 2 Force applied to tool on tool running coordinate. ForceToWorkpieceOnProgramCoordinate = 1 Force applied to workpiece on program coordinate."
  },
  "api/Hi.MillingStepUtils.ForceCycleLineDivConfig.html": {
    "href": "api/Hi.MillingStepUtils.ForceCycleLineDivConfig.html",
    "title": "Class ForceCycleLineDivConfig | HiAPI-C# 2025",
    "summary": "Class ForceCycleLineDivConfig Namespace Hi.MillingStepUtils Assembly HiNc.dll Configuration for force cycle line division display and analysis. public class ForceCycleLineDivConfig : TimeChartYConfig, IMakeXmlSource Inheritance object TimeChartYConfig ForceCycleLineDivConfig Implements IMakeXmlSource Inherited Members TimeChartYConfig.VRangeMode TimeChartYConfig.VRange TimeChartYConfig.ToString() object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ForceCycleLineDivConfig() Default constructor with initial range settings. public ForceCycleLineDivConfig() ForceCycleLineDivConfig(XElement) Ctor. public ForceCycleLineDivConfig(XElement src) Parameters src XElement XML Properties MainForceCycleFlag Gets or sets the main force cycle flag determining how forces are represented. public ForceCycleFlag MainForceCycleFlag { get; set; } Property Value ForceCycleFlag XName Name for XML IO. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.MillingStepUtils.LineChartVRangeMode.html": {
    "href": "api/Hi.MillingStepUtils.LineChartVRangeMode.html",
    "title": "Enum LineChartVRangeMode | HiAPI-C# 2025",
    "summary": "Enum LineChartVRangeMode Namespace Hi.MillingStepUtils Assembly HiNc.dll Specifies the mode for vertical range in line charts. public enum LineChartVRangeMode Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Fit = 0 Automatically fit the vertical range to data. Lock = 1 Lock the vertical range to specified values."
  },
  "api/Hi.MillingStepUtils.SpindleMomentCycleLineDivConfig.html": {
    "href": "api/Hi.MillingStepUtils.SpindleMomentCycleLineDivConfig.html",
    "title": "Class SpindleMomentCycleLineDivConfig | HiAPI-C# 2025",
    "summary": "Class SpindleMomentCycleLineDivConfig Namespace Hi.MillingStepUtils Assembly HiNc.dll Configuration for spindle moment cycle line division display and analysis. public class SpindleMomentCycleLineDivConfig : IMakeXmlSource Inheritance object SpindleMomentCycleLineDivConfig Implements IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SpindleMomentCycleLineDivConfig() Ctor. public SpindleMomentCycleLineDivConfig() SpindleMomentCycleLineDivConfig(XElement) Ctor. public SpindleMomentCycleLineDivConfig(XElement src) Parameters src XElement XML Properties TimeChartYConfig Gets or sets the Y-axis configuration for the time chart display. public TimeChartYConfig TimeChartYConfig { get; set; } Property Value TimeChartYConfig XName Name for XML IO. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.MillingStepUtils.TimeChartYConfig.html": {
    "href": "api/Hi.MillingStepUtils.TimeChartYConfig.html",
    "title": "Class TimeChartYConfig | HiAPI-C# 2025",
    "summary": "Class TimeChartYConfig Namespace Hi.MillingStepUtils Assembly HiNc.dll Configuration for Y-axis settings in time charts. public class TimeChartYConfig : IMakeXmlSource Inheritance object TimeChartYConfig Implements IMakeXmlSource Derived ForceCycleLineDivConfig Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors TimeChartYConfig() Ctor. public TimeChartYConfig() TimeChartYConfig(XElement) Ctor. public TimeChartYConfig(XElement src) Parameters src XElement XML Properties VRange Minimum and maximum values for the vertical range. public Range<double> VRange { get; set; } Property Value Range<double> VRangeMode Vertical range mode. public LineChartVRangeMode VRangeMode { get; set; } Property Value LineChartVRangeMode XName Name for XML IO. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.MillingStepUtils.html": {
    "href": "api/Hi.MillingStepUtils.html",
    "title": "Namespace Hi.MillingStepUtils | HiAPI-C# 2025",
    "summary": "Namespace Hi.MillingStepUtils Classes ClStripChartConfig Configuration for ClStrip charts. ClStripChartItemConfig Configuration for an individual ClStrip chart item. ForceCycleLineDivConfig Configuration for force cycle line division display and analysis. SpindleMomentCycleLineDivConfig Configuration for spindle moment cycle line division display and analysis. TimeChartYConfig Configuration for Y-axis settings in time charts. Enums ForceCycleFlag Flags representing different force cycle types. LineChartVRangeMode Specifies the mode for vertical range in line charts."
  },
  "api/Hi.MillingSteps.MillingInstance.html": {
    "href": "api/Hi.MillingSteps.MillingInstance.html",
    "title": "Class MillingInstance | HiAPI-C# 2025",
    "summary": "Class MillingInstance Namespace Hi.MillingSteps Assembly HiMech.dll Instance of milling in a MachiningStep. public class MillingInstance : ISuccessivePhysicsBriefAccessor Inheritance object MillingInstance Implements ISuccessivePhysicsBriefAccessor Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks The name is not MillingStep since it conflicts with the MachiningStep. The object is part of data in the MachiningStep but not the same level object. Properties BoundingBoxOnToolRunningCoordinate Gets or sets the bounding box of the cutting area on the tool running coordinate system. public Box3d BoundingBoxOnToolRunningCoordinate { get; } Property Value Box3d CuttingDepth_mm Axial Depth. public double CuttingDepth_mm { get; } Property Value double CuttingWidth_mm Radial Width. The value may not equal to the bounding box. It has filtered by plural method. The value is for human viewing. public double CuttingWidth_mm { get; } Property Value double IsTouched Gets a value indicating whether the tool is touching the workpiece. public bool IsTouched { get; } Property Value bool MillingPhysicsBrief Gets the rake face physics brief containing force and other physical calculations. Tri-state contract: null — physics not computed (EnablePhysics=false, or no tool, or spindle not rotating). non-null with computed forces — physics computed on an engaged step (IsTouched=true). non-null with all-zero forces / ratios — physics computed on a no-engagement step (EnablePhysics=true, IsTouched=false); produced via NoCut(int). Use IsTouched to distinguish this from a real cut whose forces happen to be near zero. public MillingPhysicsBrief MillingPhysicsBrief { get; } Property Value MillingPhysicsBrief Mrr_mm3ds Gets or sets the material removal rate in cubic millimeters per second. public double Mrr_mm3ds { get; } Property Value double SeqPhysicsBrief Gets or sets the sequential physics brief for this step. public SeqPhysicsBrief SeqPhysicsBrief { get; set; } Property Value SeqPhysicsBrief StepIndex Gets the index of this step. [Key] [DatabaseGenerated(DatabaseGeneratedOption.None)] public int StepIndex { get; } Property Value int"
  },
  "api/Hi.MillingSteps.MillingStepLuggage.html": {
    "href": "api/Hi.MillingSteps.MillingStepLuggage.html",
    "title": "Class MillingStepLuggage | HiAPI-C# 2025",
    "summary": "Class MillingStepLuggage Namespace Hi.MillingSteps Assembly HiMech.dll Represents additional data associated with a milling step. public class MillingStepLuggage Inheritance object MillingStepLuggage Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MillingStepLuggage() Initializes a new instance of the MillingStepLuggage class. public MillingStepLuggage() MillingStepLuggage(int, Substraction, LayerMillingEngagement, MillingForceLuggage) Initializes a new instance of the MillingStepLuggage class with specified parameters. public MillingStepLuggage(int stepIndex, Substraction substraction, LayerMillingEngagement layerMillingEngagement, MillingForceLuggage millingForceLuggage) Parameters stepIndex int The index of the associated milling step. substraction Substraction The substraction information. layerMillingEngagement LayerMillingEngagement The layer milling engagement information. millingForceLuggage MillingForceLuggage The milling force luggage information. Properties LayerMillingEngagement Gets or sets the layer milling engagement information. public LayerMillingEngagement LayerMillingEngagement { get; set; } Property Value LayerMillingEngagement MillingForceLuggage Gets or sets the milling force luggage information. public MillingForceLuggage MillingForceLuggage { get; set; } Property Value MillingForceLuggage StepIndex Gets or sets the index of the associated milling step. [Key] [DatabaseGenerated(DatabaseGeneratedOption.None)] public int StepIndex { get; set; } Property Value int Substraction Gets or sets the substraction information for the milling step. public Substraction Substraction { get; set; } Property Value Substraction"
  },
  "api/Hi.MillingSteps.html": {
    "href": "api/Hi.MillingSteps.html",
    "title": "Namespace Hi.MillingSteps | HiAPI-C# 2025",
    "summary": "Namespace Hi.MillingSteps Classes MillingInstance Instance of milling in a MachiningStep. MillingStepLuggage Represents additional data associated with a milling step."
  },
  "api/Hi.Motion.MatValves.ClMachiningValve.html": {
    "href": "api/Hi.Motion.MatValves.ClMachiningValve.html",
    "title": "Class ClMachiningValve | HiAPI-C# 2025",
    "summary": "Class ClMachiningValve Namespace Hi.Motion.MatValves Assembly HiMech.dll Optimize the sequential transformation matrixes step by step for machining. Filtering the unnecessary transformation matrixes. Accept milling mode by IsSpinMachining. public class ClMachiningValve : IMotionValve Inheritance object ClMachiningValve Implements IMotionValve Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ClMachiningValve() Ctor. public ClMachiningValve() Properties IsSpinMachining Gets or sets a value indicating whether the machining is in spin mode. When true, the valve optimizes for milling operations with tool rotation. public bool IsSpinMachining { get; set; } Property Value bool MotionValve Motion valve. The default value is StepMotionValve. public IMotionValve MotionValve { get; set; } Property Value IMotionValve Methods ClearState() Clear state. public void ClearState() Finish() Finish. public SeqPair<Mat4d> Finish() Returns SeqPair<Mat4d> The end of the optimized sequence transformation matrixes. return pair.first: one of the previous mat; pair.second: current mat. Step(DVec3d) Output optimized sequence transformation matrixes. public SeqPair<Mat4d> Step(DVec3d cl) Parameters cl DVec3d cutter location Returns SeqPair<Mat4d> optimized sequence transformation matrixes. return pair.first: one of the previous mat; pair.second: current mat Step(Mat4d) Output optimized sequence transformation matrixes. public SeqPair<Mat4d> Step(Mat4d at) Parameters at Mat4d Input matrix Returns SeqPair<Mat4d> optimized sequence transformation matrixes. return pair.first: one of the previous mat; pair.second: current mat. Remarks return null if the transformation has been returned before."
  },
  "api/Hi.Motion.MatValves.IMotionValve.html": {
    "href": "api/Hi.Motion.MatValves.IMotionValve.html",
    "title": "Interface IMotionValve | HiAPI-C# 2025",
    "summary": "Interface IMotionValve Namespace Hi.Motion.MatValves Assembly HiMech.dll Optimize the sequential transformation matrixes step by step by filtering the unnecessary transformation matrixes. public interface IMotionValve Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods ClearState() Clear state. void ClearState() Finish() Finish. SeqPair<Mat4d> Finish() Returns SeqPair<Mat4d> The end of the optimized sequence transformation matrixes. return pair.first: one of the previous mat; pair.second: current mat. Step(Mat4d) Output optimized sequence transformation matrixes. SeqPair<Mat4d> Step(Mat4d at) Parameters at Mat4d Input matrix Returns SeqPair<Mat4d> optimized sequence transformation matrixes. return pair.first: one of the previous mat; pair.second: current mat."
  },
  "api/Hi.Motion.MatValves.MacroMotionValve.html": {
    "href": "api/Hi.Motion.MatValves.MacroMotionValve.html",
    "title": "Class MacroMotionValve | HiAPI-C# 2025",
    "summary": "Class MacroMotionValve Namespace Hi.Motion.MatValves Assembly HiMech.dll Optimize the sequential transformation matrixes step by step by filtering the unnecessary transformation matrixes. The steps in the middle of each linear cut are filtered. public class MacroMotionValve : IMotionValve Inheritance object MacroMotionValve Implements IMotionValve Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MacroMotionValve() Initializes a new instance of the MacroMotionValve class. public MacroMotionValve() Methods ClearState() Clear state. public void ClearState() Finish() Finish. public SeqPair<Mat4d> Finish() Returns SeqPair<Mat4d> The end of the optimized sequence transformation matrixes. return pair.first: one of the previous mat; pair.second: current mat. Step(Mat4d) Output optimized sequence transformation matrixes. public SeqPair<Mat4d> Step(Mat4d at) Parameters at Mat4d Input matrix Returns SeqPair<Mat4d> optimized sequence transformation matrixes. return pair.first: one of the previous mat; pair.second: current mat."
  },
  "api/Hi.Motion.MatValves.StepMotionValve.html": {
    "href": "api/Hi.Motion.MatValves.StepMotionValve.html",
    "title": "Class StepMotionValve | HiAPI-C# 2025",
    "summary": "Class StepMotionValve Namespace Hi.Motion.MatValves Assembly HiMech.dll Optimize the sequential transformation matrixes step by step by filtering the unnecessary transformation matrixes. All step will be pumped. public class StepMotionValve : IMotionValve Inheritance object StepMotionValve Implements IMotionValve Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors StepMotionValve() Initializes a new instance of the StepMotionValve class. public StepMotionValve() Methods ClearState() Clear state. public void ClearState() Finish() Finish. public SeqPair<Mat4d> Finish() Returns SeqPair<Mat4d> The end of the optimized sequence transformation matrixes. return pair.first: one of the previous mat; pair.second: current mat. Step(Mat4d) Output optimized sequence transformation matrixes. public SeqPair<Mat4d> Step(Mat4d at) Parameters at Mat4d Input matrix Returns SeqPair<Mat4d> optimized sequence transformation matrixes. return pair.first: one of the previous mat; pair.second: current mat."
  },
  "api/Hi.Motion.MatValves.html": {
    "href": "api/Hi.Motion.MatValves.html",
    "title": "Namespace Hi.Motion.MatValves | HiAPI-C# 2025",
    "summary": "Namespace Hi.Motion.MatValves Classes ClMachiningValve Optimize the sequential transformation matrixes step by step for machining. Filtering the unnecessary transformation matrixes. Accept milling mode by IsSpinMachining. MacroMotionValve Optimize the sequential transformation matrixes step by step by filtering the unnecessary transformation matrixes. The steps in the middle of each linear cut are filtered. StepMotionValve Optimize the sequential transformation matrixes step by step by filtering the unnecessary transformation matrixes. All step will be pumped. Interfaces IMotionValve Optimize the sequential transformation matrixes step by step by filtering the unnecessary transformation matrixes."
  },
  "api/Hi.Motion.MotionUtil.html": {
    "href": "api/Hi.Motion.MotionUtil.html",
    "title": "Class MotionUtil | HiAPI-C# 2025",
    "summary": "Class MotionUtil Namespace Hi.Motion Assembly HiMech.dll Cutter location utility. public static class MotionUtil Inheritance object MotionUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetLinearRatio(Vec3d, Vec3d, Vec3d) Get linear ratio, which is cos(theta) square. Theta is the clamping angle between (v1-v0) and (v2-v1). public static double GetLinearRatio(Vec3d v0, Vec3d v1, Vec3d v2) Parameters v0 Vec3d v1 Vec3d v2 Vec3d Returns double InterpolateClMat(Mat4d, DVec3d) Interpolates the cutter location mat by cutter location and orientation. public static IEnumerable<Mat4d> InterpolateClMat(Mat4d clMat0, DVec3d targetCl) Parameters clMat0 Mat4d current cutter location mat, at begining position targetCl DVec3d The target cl, at end position Returns IEnumerable<Mat4d> InterpolateClRotMatByClNormal(Mat4d, Vec3d) Interpolates the cutter location mat by cutter orientation. public static IEnumerable<Mat4d> InterpolateClRotMatByClNormal(Mat4d clMat0, Vec3d targetClNormal) Parameters clMat0 Mat4d current cutter location mat, at begining position targetClNormal Vec3d The target cl.n, at end position Returns IEnumerable<Mat4d> Interpolation(Mat4d, Mat4d, double) Interpolate by rotation and translation. public static Mat4d Interpolation(Mat4d m0, Mat4d m1, double alpha) Parameters m0 Mat4d m0 m1 Mat4d m1 alpha double ratio between m0 and m1. Returns Mat4d interpolated matrix IsMcLinear(DVec3d, DVec3d, DVec3d, double) Determines if three machine coordinate points form a linear path. public static bool IsMcLinear(DVec3d mc0, DVec3d mc1, DVec3d mc2, double linearGap = 0.9999999) Parameters mc0 DVec3d The first machine coordinate point. mc1 DVec3d The second machine coordinate point. mc2 DVec3d The third machine coordinate point. linearGap double The threshold for linearity determination. Default is (1 - 1e-7). Returns bool True if the points form a linear path; otherwise, false."
  },
  "api/Hi.Motion.html": {
    "href": "api/Hi.Motion.html",
    "title": "Namespace Hi.Motion | HiAPI-C# 2025",
    "summary": "Namespace Hi.Motion Classes MotionUtil Cutter location utility."
  },
  "api/Hi.Native.StopSource.html": {
    "href": "api/Hi.Native.StopSource.html",
    "title": "Class StopSource | HiAPI-C# 2025",
    "summary": "Class StopSource Namespace Hi.Native Assembly HiDisp.dll Represents a source that can be used to create and control stop tokens. public class StopSource : IDisposable Inheritance object StopSource Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors StopSource() Initializes a new instance of the StopSource class. public StopSource() Properties StopSourcePtr Gets the pointer to the native stop source. public nint StopSourcePtr { get; } Property Value nint Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ~StopSource() Finalizer for the StopSource class. protected ~StopSource() GetStopToken() Gets a stop token from this source. public StopToken GetStopToken() Returns StopToken A new StopToken instance. IsStopPossible() Checks if stopping is possible for this source. public bool IsStopPossible() Returns bool True if stopping is possible; otherwise, false. IsStopRequested() Checks if stopping has been requested for this source. public bool IsStopRequested() Returns bool True if stopping has been requested; otherwise, false. RequestStop() Requests stopping of operations associated with this source. public bool RequestStop() Returns bool True if the stop request was successful; otherwise, false."
  },
  "api/Hi.Native.StopToken.html": {
    "href": "api/Hi.Native.StopToken.html",
    "title": "Class StopToken | HiAPI-C# 2025",
    "summary": "Class StopToken Namespace Hi.Native Assembly HiDisp.dll Represents a token that can be used to request cancellation of operations. public class StopToken : IDisposable Inheritance object StopToken Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors StopToken(nint, bool) Initializes a new instance of the StopToken class. public StopToken(nint stopTokenPtr, bool isDisposable) Parameters stopTokenPtr nint Pointer to the native stop token isDisposable bool Specifies whether this token should be disposed by managed code: Set to false if the pointer is created by C++ (disposal handled by native code) Set to true if the pointer is created by StopSource.GetStopToken() (disposal handled by managed code) Properties StopTokenPtr Gets the pointer to the native stop token. public nint StopTokenPtr { get; } Property Value nint Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ~StopToken() Finalizer for the StopToken class. protected ~StopToken() IsStopPossible() Checks if stopping is possible for this token. public bool IsStopPossible() Returns bool True if stopping is possible; otherwise, false. IsStopRequested() Checks if stopping has been requested for this token. public bool IsStopRequested() Returns bool True if stopping has been requested; otherwise, false."
  },
  "api/Hi.Native.StopTokenKit.html": {
    "href": "api/Hi.Native.StopTokenKit.html",
    "title": "Class StopTokenKit | HiAPI-C# 2025",
    "summary": "Class StopTokenKit Namespace Hi.Native Assembly HiDisp.dll A kit that manages the lifecycle of a StopToken and its associated resources. public class StopTokenKit : IDisposable Inheritance object StopTokenKit Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors StopTokenKit(CancellationToken) Initializes a new instance of the StopTokenKit class. public StopTokenKit(CancellationToken token) Parameters token CancellationToken The cancellation token to register with. Properties StopTokenPtr Gets the pointer to the native stop token. public nint StopTokenPtr { get; } Property Value nint Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool"
  },
  "api/Hi.Native.StopTokenUtil.html": {
    "href": "api/Hi.Native.StopTokenUtil.html",
    "title": "Class StopTokenUtil | HiAPI-C# 2025",
    "summary": "Class StopTokenUtil Namespace Hi.Native Assembly HiDisp.dll Utility class for working with stop tokens. public static class StopTokenUtil Inheritance object StopTokenUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GenStopTokenKit(CancellationToken) Generates a StopTokenKit from a CancellationToken. public static StopTokenKit GenStopTokenKit(this CancellationToken token) Parameters token CancellationToken The cancellation token to convert. Returns StopTokenKit A new StopTokenKit instance."
  },
  "api/Hi.Native.bind_t.html": {
    "href": "api/Hi.Native.bind_t.html",
    "title": "Struct bind_t | HiAPI-C# 2025",
    "summary": "Struct bind_t Namespace Hi.Native Assembly HiDisp.dll Runtime rendering data for each iteration in rendering loop. It manipulates geometry transformation, such as moving, rotatingand scaling. It also deal with color and picking. A bind_t object is generated by rendering in the every beginning of each rendering iteration. public struct bind_t Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields height Canvas height. public int height Field Value int is_picking_mode Is picking mode. public int is_picking_mode Field Value int models Model matrixes in MVP convention. public mat_stack_t models Field Value mat_stack_t picking_id Current picking id. public int picking_id Field Value int pixelProj Pixel mapping part of the projection matrix in MVP convention. public mat4d pixelProj Field Value mat4d See Also projMat pixel_width_on_model Pixel width on model layer. public double pixel_width_on_model Field Value double projMat Projection matrix in MVP convention. Equal to scaleProj * pixelProj. public mat4d projMat Field Value mat4d rgb Current color (rgb). public vec3f rgb Field Value vec3f scaleProj Scale part of the projection matrix in MVP convention. public mat4d scaleProj Field Value mat4d See Also projMat sparkle_rate Sparkle rate of specular light. The rate only effects on the Drawing which contains N(normal) value. public float sparkle_rate Field Value float view View matrix in MVP convention. public mat4d view Field Value mat4d vpMat view * projMat. public mat4d vpMat Field Value mat4d width Canvas width. public int width Field Value int"
  },
  "api/Hi.Native.box2d.html": {
    "href": "api/Hi.Native.box2d.html",
    "title": "Struct box2d | HiAPI-C# 2025",
    "summary": "Struct box2d Namespace Hi.Native Assembly HiGeom.dll Native box3d. public struct box2d Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors box2d(Box2d) Ctor. public box2d(Box2d src) Parameters src Box2d src Fields max max. public vec2d max Field Value vec2d min min. public vec2d min Field Value vec2d Methods ExpandToBox2d(Box2d) public void ExpandToBox2d(Box2d dst) Parameters dst Box2d"
  },
  "api/Hi.Native.box3d.html": {
    "href": "api/Hi.Native.box3d.html",
    "title": "Struct box3d | HiAPI-C# 2025",
    "summary": "Struct box3d Namespace Hi.Native Assembly HiGeom.dll Native implementation of a 3D bounding box structure for interop scenarios. public struct box3d : IExpandToBox3d Implements IExpandToBox3d Inherited Members ValueType.Equals(object) ValueType.GetHashCode() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods GeomUtil.ExpandToBox3d(IExpandToBox3d, Mat4d, Box3d) GeomUtil.GetBox3d(IExpandToBox3d) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors box3d(Box3d) Initializes a new instance of the box3d struct from a Box3d object. public box3d(Box3d src) Parameters src Box3d The source Box3d object to convert from. Fields max The maximum point of the box (upper-right-front corner). public vec3d max Field Value vec3d min The minimum point of the box (lower-left-back corner). public vec3d min Field Value vec3d Methods ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box ToString() Returns the fully qualified type name of this instance. public override string ToString() Returns string The fully qualified type name."
  },
  "api/Hi.Native.expand_to_box3d_func_t.html": {
    "href": "api/Hi.Native.expand_to_box3d_func_t.html",
    "title": "Delegate expand_to_box3d_func_t | HiAPI-C# 2025",
    "summary": "Delegate expand_to_box3d_func_t Namespace Hi.Native Assembly HiDisp.dll Delegate for expanding a bounding box. public delegate void expand_to_box3d_func_t(void* para, box3d* dst) Parameters para void* User parameter. dst box3d* Destination box to expand. Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Native.html": {
    "href": "api/Hi.Native.html",
    "title": "Namespace Hi.Native | HiAPI-C# 2025",
    "summary": "Namespace Hi.Native Classes StopSource Represents a source that can be used to create and control stop tokens. StopToken Represents a token that can be used to request cancellation of operations. StopTokenKit A kit that manages the lifecycle of a StopToken and its associated resources. StopTokenUtil Utility class for working with stop tokens. Structs bind_t Runtime rendering data for each iteration in rendering loop. It manipulates geometry transformation, such as moving, rotatingand scaling. It also deal with color and picking. A bind_t object is generated by rendering in the every beginning of each rendering iteration. box2d Native box3d. box3d Native implementation of a 3D bounding box structure for interop scenarios. key_event_t Native key event. key_table__transform_view_by_key_pressing_t Native key table for native function transform_view_by_key_pressing. Key values follow W3C KeyboardEvent.key standard (e.g. “Home”, “ArrowLeft”, “Shift”). mat4d Native mat4d. mat_stack_t Native mat_stack_t. mouse_button_event_t Native mouse button event. mouse_button_table__transform_view_by_mouse_drag_t Mouse button table for native function of transform_view_by_mouse_drag. mouse_move_event_t Native mouse move event. mouse_wheel_event_t Native mouse wheel event. panel_state_t Native panel state. picking_event_t Internal Use Only. picking_mark_t Internal Use Only. tri3d Native tri3d. vec2d Native vec2d. vec3d Native vec3d. vec3f Native vec3f. Enums ui_event_type Native ui event. Delegates expand_to_box3d_func_t Delegate for expanding a bounding box."
  },
  "api/Hi.Native.key_event_t.html": {
    "href": "api/Hi.Native.key_event_t.html",
    "title": "Struct key_event_t | HiAPI-C# 2025",
    "summary": "Struct key_event_t Namespace Hi.Native Assembly HiDisp.dll Native key event. public struct key_event_t Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields type Event type. public ui_event_type type Field Value ui_event_type Properties Key Key string (W3C KeyboardEvent.key value, e.g. “Alt”, “ArrowLeft”, “a”). public string Key { get; } Property Value string"
  },
  "api/Hi.Native.key_table__transform_view_by_key_pressing_t.html": {
    "href": "api/Hi.Native.key_table__transform_view_by_key_pressing_t.html",
    "title": "Struct key_table__transform_view_by_key_pressing_t | HiAPI-C# 2025",
    "summary": "Struct key_table__transform_view_by_key_pressing_t Namespace Hi.Native Assembly HiDisp.dll Native key table for native function transform_view_by_key_pressing. Key values follow W3C KeyboardEvent.key standard (e.g. “Home”, “ArrowLeft”, “Shift”). public struct key_table__transform_view_by_key_pressing_t Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields ARROW_DOWN ARROW_DOWN. W3C key: “ArrowDown” public string ARROW_DOWN Field Value string ARROW_LEFT ARROW_LEFT. W3C key: “ArrowLeft” public string ARROW_LEFT Field Value string ARROW_RIGHT ARROW_RIGHT. W3C key: “ArrowRight” public string ARROW_RIGHT Field Value string ARROW_UP ARROW_UP. W3C key: “ArrowUp” public string ARROW_UP Field Value string F1 F1. W3C key: “F1” public string F1 Field Value string F2 F2. W3C key: “F2” public string F2 Field Value string F3 F3. W3C key: “F3” public string F3 Field Value string F4 F4. W3C key: “F4” public string F4 Field Value string HOME HOME. W3C key: “Home” public string HOME Field Value string PAGE_DOWN PAGE_DOWN. W3C key: “PageDown” public string PAGE_DOWN Field Value string PAGE_UP PAGE_UP. W3C key: “PageUp” public string PAGE_UP Field Value string SHIFT SHIFT. W3C key: “Shift” public string SHIFT Field Value string"
  },
  "api/Hi.Native.mat4d.html": {
    "href": "api/Hi.Native.mat4d.html",
    "title": "Struct mat4d | HiAPI-C# 2025",
    "summary": "Struct mat4d Namespace Hi.Native Assembly HiGeom.dll Native mat4d. public struct mat4d : IEquatable<mat4d> Implements IEquatable<mat4d> Inherited Members ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors mat4d(Mat4d) Ctor. public mat4d(Mat4d mat) Parameters mat Mat4d managed matrix mat4d(double[]) Ctor. public mat4d(double[] m) Parameters m double[] array that has 4x4=16 elements Fields m value array. public double* m Field Value double* Methods Equals(mat4d) Indicates whether the current object is equal to another object of the same type. public bool Equals(mat4d other) Parameters other mat4d An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Indicates whether this instance and a specified object are equal. public override bool Equals(object obj) Parameters obj object The object to compare with the current instance. Returns bool true if obj and this instance are the same type and represent the same value; otherwise, false. GetHashCode() Returns the hash code for this instance. public override int GetHashCode() Returns int A 32-bit signed integer that is the hash code for this instance. Operators operator ==(mat4d, mat4d) public static bool operator ==(mat4d left, mat4d right) Parameters left mat4d right mat4d Returns bool operator !=(mat4d, mat4d) public static bool operator !=(mat4d left, mat4d right) Parameters left mat4d right mat4d Returns bool"
  },
  "api/Hi.Native.mat_stack_t.html": {
    "href": "api/Hi.Native.mat_stack_t.html",
    "title": "Struct mat_stack_t | HiAPI-C# 2025",
    "summary": "Struct mat_stack_t Namespace Hi.Native Assembly HiDisp.dll Native mat_stack_t. public struct mat_stack_t Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Native.mouse_button_event_t.html": {
    "href": "api/Hi.Native.mouse_button_event_t.html",
    "title": "Struct mouse_button_event_t | HiAPI-C# 2025",
    "summary": "Struct mouse_button_event_t Namespace Hi.Native Assembly HiDisp.dll Native mouse button event. public struct mouse_button_event_t Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields mouse_button Mouse button code. public long mouse_button Field Value long type Event type. public ui_event_type type Field Value ui_event_type"
  },
  "api/Hi.Native.mouse_button_table__transform_view_by_mouse_drag_t.html": {
    "href": "api/Hi.Native.mouse_button_table__transform_view_by_mouse_drag_t.html",
    "title": "Struct mouse_button_table__transform_view_by_mouse_drag_t | HiAPI-C# 2025",
    "summary": "Struct mouse_button_table__transform_view_by_mouse_drag_t Namespace Hi.Native Assembly HiDisp.dll Mouse button table for native function of transform_view_by_mouse_drag. public struct mouse_button_table__transform_view_by_mouse_drag_t Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields LEFT_BUTTON Left button. public long LEFT_BUTTON Field Value long RIGHT_BUTTON Right button. public long RIGHT_BUTTON Field Value long"
  },
  "api/Hi.Native.mouse_move_event_t.html": {
    "href": "api/Hi.Native.mouse_move_event_t.html",
    "title": "Struct mouse_move_event_t | HiAPI-C# 2025",
    "summary": "Struct mouse_move_event_t Namespace Hi.Native Assembly HiDisp.dll Native mouse move event. public struct mouse_move_event_t Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields cursor_x Cursor position x. public int cursor_x Field Value int cursor_y Cursor position y. public int cursor_y Field Value int type Event type. public ui_event_type type Field Value ui_event_type"
  },
  "api/Hi.Native.mouse_wheel_event_t.html": {
    "href": "api/Hi.Native.mouse_wheel_event_t.html",
    "title": "Struct mouse_wheel_event_t | HiAPI-C# 2025",
    "summary": "Struct mouse_wheel_event_t Namespace Hi.Native Assembly HiDisp.dll Native mouse wheel event. public struct mouse_wheel_event_t Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields type Event type. public ui_event_type type Field Value ui_event_type wheel_offset_x Wheel offset X. public int wheel_offset_x Field Value int wheel_offset_y Wheel offset Y. public int wheel_offset_y Field Value int"
  },
  "api/Hi.Native.panel_state_t.html": {
    "href": "api/Hi.Native.panel_state_t.html",
    "title": "Struct panel_state_t | HiAPI-C# 2025",
    "summary": "Struct panel_state_t Namespace Hi.Native Assembly HiDisp.dll Native panel state. public struct panel_state_t Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields cursor_pre_x Previous cursor X position. public int cursor_pre_x Field Value int cursor_pre_y Previous cursor Y position. public int cursor_pre_y Field Value int cursor_x Current cursor X position. public int cursor_x Field Value int cursor_y Current cursor Y position. public int cursor_y Field Value int is_visible Is panel visible. public int is_visible Field Value int panel_h Panel height. public int panel_h Field Value int panel_w Panel width. public int panel_w Field Value int panel_x X position of the panel from the system desktop. public int panel_x Field Value int panel_y Y position of the panel from the system desktop. public int panel_y Field Value int Methods IsKeyPressed(string) Checks if a keyboard key is currently pressed. public bool IsKeyPressed(string key) Parameters key string Key string (W3C KeyboardEvent.key value, e.g. “Alt”, “ArrowLeft”). Returns bool IsMouseButtonPressed(long) Checks if a mouse button is currently pressed. public bool IsMouseButtonPressed(long mouse_button) Parameters mouse_button long Mouse button code. Returns bool"
  },
  "api/Hi.Native.picking_event_t.html": {
    "href": "api/Hi.Native.picking_event_t.html",
    "title": "Struct picking_event_t | HiAPI-C# 2025",
    "summary": "Struct picking_event_t Namespace Hi.Native Assembly HiDisp.dll Internal Use Only. public struct picking_event_t Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Native.picking_mark_t.html": {
    "href": "api/Hi.Native.picking_mark_t.html",
    "title": "Struct picking_mark_t | HiAPI-C# 2025",
    "summary": "Struct picking_mark_t Namespace Hi.Native Assembly HiDisp.dll Internal Use Only. public struct picking_mark_t Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields picked Internal Use Only. Pointer to the picked object. public void* picked Field Value void* picking_func Internal Use Only. Function pointer to the picking function. public nint picking_func Field Value nint"
  },
  "api/Hi.Native.tri3d.html": {
    "href": "api/Hi.Native.tri3d.html",
    "title": "Struct tri3d | HiAPI-C# 2025",
    "summary": "Struct tri3d Namespace Hi.Native Assembly HiGeom.dll Native tri3d. public struct tri3d Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors tri3d(Tri3d) Ctor. public tri3d(Tri3d src) Parameters src Tri3d src tri3d(vec3d, vec3d, vec3d, vec3d) Ctor. public tri3d(vec3d p0, vec3d p1, vec3d p2, vec3d n) Parameters p0 vec3d p0 p1 vec3d p1 p2 vec3d p2 n vec3d n Fields n Normal. public vec3d n Field Value vec3d p0 Apex 0. public vec3d p0 Field Value vec3d p1 Apex 1. public vec3d p1 Field Value vec3d p2 Apex 2. public vec3d p2 Field Value vec3d"
  },
  "api/Hi.Native.ui_event_type.html": {
    "href": "api/Hi.Native.ui_event_type.html",
    "title": "Enum ui_event_type | HiAPI-C# 2025",
    "summary": "Enum ui_event_type Namespace Hi.Native Assembly HiDisp.dll Native ui event. public enum ui_event_type Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Key_Pressed = 1 Key pressed. Key_Released = 2 Key released. Mouse_Entered = 5 Mouse entered. Mouse_Exited = 6 Mouse exited. Mouse_Moved = 7 Mouse moved. Mouse_Pressed = 3 Mouse pressed. Mouse_Released = 4 Mouse released. Mouse_Wheel_Moved = 8 Mouse wheel moved. No_Event = 0 No event. Not_Defined = 9 Not defined."
  },
  "api/Hi.Native.vec2d.html": {
    "href": "api/Hi.Native.vec2d.html",
    "title": "Struct vec2d | HiAPI-C# 2025",
    "summary": "Struct vec2d Namespace Hi.Native Assembly HiGeom.dll Native vec2d. public struct vec2d : IEquatable<vec2d> Implements IEquatable<vec2d> Inherited Members ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors vec2d(Vec2d) Ctor. public vec2d(Vec2d src) Parameters src Vec2d src vec2d(double, double) Ctor.x public vec2d(double x, double y) Parameters x double x y double y Fields x x. public double x Field Value double y y. public double y Field Value double Methods Equals(vec2d) Indicates whether the current object is equal to another object of the same type. public bool Equals(vec2d other) Parameters other vec2d An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Indicates whether this instance and a specified object are equal. public override bool Equals(object obj) Parameters obj object The object to compare with the current instance. Returns bool true if obj and this instance are the same type and represent the same value; otherwise, false. GetHashCode() Returns the hash code for this instance. public override int GetHashCode() Returns int A 32-bit signed integer that is the hash code for this instance. Operators operator ==(vec2d, vec2d) public static bool operator ==(vec2d left, vec2d right) Parameters left vec2d right vec2d Returns bool operator !=(vec2d, vec2d) public static bool operator !=(vec2d left, vec2d right) Parameters left vec2d right vec2d Returns bool"
  },
  "api/Hi.Native.vec3d.html": {
    "href": "api/Hi.Native.vec3d.html",
    "title": "Struct vec3d | HiAPI-C# 2025",
    "summary": "Struct vec3d Namespace Hi.Native Assembly HiGeom.dll Native vec3d. public struct vec3d : IEquatable<vec3d> Implements IEquatable<vec3d> Inherited Members object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors vec3d(Vec3d) Ctor. public vec3d(Vec3d src) Parameters src Vec3d src vec3d(double, double, double) Ctor.x public vec3d(double x, double y, double z) Parameters x double x y double y z double z Fields x x. public double x Field Value double y y. public double y Field Value double z z. public double z Field Value double Methods Equals(vec3d) Indicates whether the current object is equal to another object of the same type. public bool Equals(vec3d other) Parameters other vec3d An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Indicates whether this instance and a specified object are equal. public override bool Equals(object obj) Parameters obj object The object to compare with the current instance. Returns bool true if obj and this instance are the same type and represent the same value; otherwise, false. GetHashCode() Returns the hash code for this instance. public override int GetHashCode() Returns int A 32-bit signed integer that is the hash code for this instance. ToString() To representative string with format:(x,y,z). public override string ToString() Returns string Representative string Operators operator ==(vec3d, vec3d) public static bool operator ==(vec3d left, vec3d right) Parameters left vec3d right vec3d Returns bool operator !=(vec3d, vec3d) public static bool operator !=(vec3d left, vec3d right) Parameters left vec3d right vec3d Returns bool"
  },
  "api/Hi.Native.vec3f.html": {
    "href": "api/Hi.Native.vec3f.html",
    "title": "Struct vec3f | HiAPI-C# 2025",
    "summary": "Struct vec3f Namespace Hi.Native Assembly HiGeom.dll Native vec3f. public struct vec3f : IEquatable<vec3f> Implements IEquatable<vec3f> Inherited Members ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors vec3f(Vec3d) Ctor. public vec3f(Vec3d src) Parameters src Vec3d src vec3f(float, float, float) Ctor. public vec3f(float x, float y, float z) Parameters x float x y float y z float z Fields x x. public float x Field Value float y y. public float y Field Value float z z. public float z Field Value float Methods Equals(vec3f) Indicates whether the current object is equal to another object of the same type. public bool Equals(vec3f other) Parameters other vec3f An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Indicates whether this instance and a specified object are equal. public override bool Equals(object obj) Parameters obj object The object to compare with the current instance. Returns bool true if obj and this instance are the same type and represent the same value; otherwise, false. GetHashCode() Returns the hash code for this instance. public override int GetHashCode() Returns int A 32-bit signed integer that is the hash code for this instance. Operators operator ==(vec3f, vec3f) public static bool operator ==(vec3f left, vec3f right) Parameters left vec3f right vec3f Returns bool operator !=(vec3f, vec3f) public static bool operator !=(vec3f left, vec3f right) Parameters left vec3f right vec3f Returns bool"
  },
  "api/Hi.NcMech.Fixtures.Fixture.html": {
    "href": "api/Hi.NcMech.Fixtures.Fixture.html",
    "title": "Class Fixture | HiAPI-C# 2025",
    "summary": "Class Fixture Namespace Hi.NcMech.Fixtures Assembly HiMech.dll Represents a fixture used to hold workpieces during machining operations. public class Fixture : IGetSolid, IMakeXmlSource, IDisplayee, IExpandToBox3d, IGetAnchoredDisplayeeList, IGetAsmb, IGetAnchor, IGetTopoIndex, IDisposable, IAnchoredCollidableLeaf, IAnchoredCollidableNode, IAnchoredCollidableBased, ICollidable Inheritance object Fixture Implements IGetSolid IMakeXmlSource IDisplayee IExpandToBox3d IGetAnchoredDisplayeeList IGetAsmb IGetAnchor IGetTopoIndex IDisposable IAnchoredCollidableLeaf IAnchoredCollidableNode IAnchoredCollidableBased ICollidable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods CollisionUtil.Detect(ICollidable, ICollidable, Mat4d, double, int) DispUtil.Display(IDisplayee, Bind, Mat4d) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Fixture() Initializes a new instance of the Fixture class. public Fixture() Fixture(XElement, string, string, IProgress<IMessage>) Initializes a new instance of the Fixture class from XML. public Fixture(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress) Parameters src XElement The XML element containing fixture data. baseDirectory string The base directory for resolving relative paths. relFile string The relative file path. progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. Fields XName Name for XML IO. public static string XName Field Value string Properties Asmb Gets the assembly that contains the fixture components. public Asmb Asmb { get; } Property Value Asmb CollidableName Gets the name of the collidable object. public string CollidableName { get; } Property Value string Geom Geometry. Delegate by Solid.Geom. public IGetStl Geom { get; set; } Property Value IGetStl GeomAnchor Anchor that represents the geometry origin of the fixture. public Anchor GeomAnchor { get; } Property Value Anchor GeomToTableBranch Branch that transforms from geometry origin to table origin. public Branch GeomToTableBranch { get; } Property Value Branch GeomToTableTransformer Transformer from Geometry origin to table (machine tool side) origin. public ITransformer GeomToTableTransformer { get; set; } Property Value ITransformer GeomToWorkpieceBranch Branch that transforms from geometry origin to workpiece origin. public Branch GeomToWorkpieceBranch { get; } Property Value Branch GeomToWorkpieceTransformer Transformer from Geometry origin to workpiece origin. public ITransformer GeomToWorkpieceTransformer { get; set; } Property Value ITransformer Solid Gets the solid representation of the fixture. public Solid Solid { get; } Property Value Solid TableBuckle Table buckle. Root. Solid anchor. public Anchor TableBuckle { get; } Property Value Anchor ThemeColor Default theme color used when rendering the fixture. public static Vec3d ThemeColor { get; } Property Value Vec3d WorkpieceBuckle Gets the workpiece buckle anchor point. public Anchor WorkpieceBuckle { get; } Property Value Anchor Methods ClearGeomCache() Update cache of Geom. The method is used after inner content of Geom is altered. public void ClearGeomCache() Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor GetAnchoredCollidableNode() Gets the anchored collidable node associated with this object. public IAnchoredCollidableNode GetAnchoredCollidableNode() Returns IAnchoredCollidableNode The anchored collidable node. GetAnchoredDisplayeeList() Gets a list of anchored displayable objects. public List<IAnchoredDisplayee> GetAnchoredDisplayeeList() Returns List<IAnchoredDisplayee> A list of IAnchoredDisplayee objects GetAsmb() Gets the key asmb. public Asmb GetAsmb() Returns Asmb The key asmb. GetCollidableAnchor() Gets the anchor associated with this collidable leaf. public Anchor GetCollidableAnchor() Returns Anchor The anchor for this collidable leaf. GetCollidee() Get ICollidee. public ICollidee GetCollidee() Returns ICollidee ICollidee GetSolid() Gets the solid geometry object. public Solid GetSolid() Returns Solid The solid geometry object. HostSharedSolid(Solid) Replaces Solid with an externally owned instance. The fixture does NOT dispose an injected solid: the provider keeps its lifecycle, so one solid can be shared by several hosts (e.g. the authored and the runtime topology entity displaying the same fixture). The fixture's own solid is disposed when it was self-created. public void HostSharedSolid(Solid shared) Parameters shared Solid The externally owned solid to host. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetWorkpieceTransformationToGeomTopCenter() Sets the workpiece transformation to position it at the top center of the fixture. public void SetWorkpieceTransformationToGeomTopCenter()"
  },
  "api/Hi.NcMech.Fixtures.FixtureEditorDisplayee.html": {
    "href": "api/Hi.NcMech.Fixtures.FixtureEditorDisplayee.html",
    "title": "Class FixtureEditorDisplayee | HiAPI-C# 2025",
    "summary": "Class FixtureEditorDisplayee Namespace Hi.NcMech.Fixtures Assembly HiMech.dll Displayee for fixture visualization and editor overlays. public class FixtureEditorDisplayee : IDisplayee, IExpandToBox3d, IGetAsmb, IGetAnchor, IGetTopoIndex Inheritance object FixtureEditorDisplayee Implements IDisplayee IExpandToBox3d IGetAsmb IGetAnchor IGetTopoIndex Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Config Gets or sets the visualization configuration. public FixtureEditorDisplayeeConfig Config { get; set; } Property Value FixtureEditorDisplayeeConfig Fixture Gets the current Fixture. public Fixture Fixture { get; } Property Value Fixture FixtureGetter Gets or sets the delegate that provides the current Fixture. public Func<Fixture> FixtureGetter { get; set; } Property Value Func<Fixture> RenderingMode Gets or sets the rendering mode for the underlying solid. public Solid.RenderingModeEnum RenderingMode { get; set; } Property Value Solid.RenderingModeEnum ShowGeomAnchor Gets or sets whether to show the geometry anchor. public bool ShowGeomAnchor { get; set; } Property Value bool ShowTableBuckle Gets or sets whether to show the table buckle anchor. public bool ShowTableBuckle { get; set; } Property Value bool ShowWorkpieceBuckle Gets or sets whether to show the workpiece buckle anchor. public bool ShowWorkpieceBuckle { get; set; } Property Value bool Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor GetAsmb() Gets the key asmb. public Asmb GetAsmb() Returns Asmb The key asmb."
  },
  "api/Hi.NcMech.Fixtures.FixtureEditorDisplayeeConfig.html": {
    "href": "api/Hi.NcMech.Fixtures.FixtureEditorDisplayeeConfig.html",
    "title": "Class FixtureEditorDisplayeeConfig | HiAPI-C# 2025",
    "summary": "Class FixtureEditorDisplayeeConfig Namespace Hi.NcMech.Fixtures Assembly HiMech.dll Configuration settings for fixture editor display features. public class FixtureEditorDisplayeeConfig : IMakeXmlSource Inheritance object FixtureEditorDisplayeeConfig Implements IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FixtureEditorDisplayeeConfig() Initializes a new instance of the FixtureEditorDisplayeeConfig class. public FixtureEditorDisplayeeConfig() FixtureEditorDisplayeeConfig(XElement) Initializes a new instance from XML. public FixtureEditorDisplayeeConfig(XElement element) Parameters element XElement Properties RenderingMode Gets or sets the rendering mode of the solid. public Solid.RenderingModeEnum RenderingMode { get; set; } Property Value Solid.RenderingModeEnum ShowGeomAnchor Gets or sets whether to show the geometry anchor. public bool ShowGeomAnchor { get; set; } Property Value bool ShowTableBuckle Gets or sets whether to show the table buckle. public bool ShowTableBuckle { get; set; } Property Value bool ShowWorkpieceBuckle Gets or sets whether to show the workpiece buckle. public bool ShowWorkpieceBuckle { get; set; } Property Value bool XName Name for XML IO. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcMech.Fixtures.html": {
    "href": "api/Hi.NcMech.Fixtures.html",
    "title": "Namespace Hi.NcMech.Fixtures | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcMech.Fixtures Classes Fixture Represents a fixture used to hold workpieces during machining operations. FixtureEditorDisplayee Displayee for fixture visualization and editor overlays. FixtureEditorDisplayeeConfig Configuration settings for fixture editor display features."
  },
  "api/Hi.NcMech.Holders.CylindroidHolder.html": {
    "href": "api/Hi.NcMech.Holders.CylindroidHolder.html",
    "title": "Class CylindroidHolder | HiAPI-C# 2025",
    "summary": "Class CylindroidHolder Namespace Hi.NcMech.Holders Assembly HiMech.dll Represents a cylindrical tool holder for machining operations. public class CylindroidHolder : IHolder, ITopo, IGetAsmb, IGetAnchoredDisplayeeList, IAnchoredDisplayee, IDisplayee, IExpandToBox3d, IMakeXmlSource, IAbstractNote, IGetFletchBuckle, IDuplicate, INameNote, IAnchoredCollidabled, IGetCollidable, IGetAnchor, IGetTopoIndex, IGetSolid, IDisposable, IAnchoredCollidableLeaf, IAnchoredCollidableNode, IAnchoredCollidableBased, ICollidable, IClearCache Inheritance object CylindroidHolder Implements IHolder ITopo IGetAsmb IGetAnchoredDisplayeeList IAnchoredDisplayee IDisplayee IExpandToBox3d IMakeXmlSource IAbstractNote IGetFletchBuckle IDuplicate INameNote IAnchoredCollidabled IGetCollidable IGetAnchor IGetTopoIndex IGetSolid IDisposable IAnchoredCollidableLeaf IAnchoredCollidableNode IAnchoredCollidableBased ICollidable IClearCache Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods CollisionUtil.Detect(ICollidable, ICollidable, Mat4d, double, int) DispUtil.Display(IDisplayee, Bind, Mat4d) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) TopoDisplayeeUtil.Display(ITopo, Bind) TopoDisplayeeUtil.ExpandToBox3d(ITopo, Box3d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CylindroidHolder() Ctor. public CylindroidHolder() CylindroidHolder(Cylindroid) Ctor. public CylindroidHolder(Cylindroid cylindroid) Parameters cylindroid Cylindroid The cylindroid geometry for this holder. CylindroidHolder(XElement, string, string, IProgress<IMessage>) Initializes a new instance of the CylindroidHolder class from XML. public CylindroidHolder(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress) Parameters src XElement The XML element containing holder data. baseDirectory string The base directory for resolving relative paths. relFile string The relative file path. progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. Fields XName XML Name. public static string XName Field Value string Properties AbstractNote Gets a descriptive note or abstract about the object. public string AbstractNote { get; } Property Value string Branch Gets the branch connecting the fletch buckle to the tail buckle. public Branch Branch { get; } Property Value Branch CollidableName Gets the name of the collidable object. public string CollidableName { get; } Property Value string CutterBuckle Gets the cutter buckle anchor. public Anchor CutterBuckle { get; } Property Value Anchor Cylindroid Gets or sets the cylindroid geometry that defines this holder. public Cylindroid Cylindroid { get; set; } Property Value Cylindroid GeomAnchor Equivalent of CutterBuckle. public Anchor GeomAnchor { get; } Property Value Anchor Name Gets or sets the name of the object. public string Name { get; set; } Property Value string Note Gets or sets the descriptive note for the object. public string Note { get; set; } Property Value string PolarResolution2d Gets or sets the polar resolution used for STL generation. Authored data. The resolution is part of a Solid's identity, so assigning this property swaps the holder's solid for one born with the new value (the old solid is disposed). public PolarResolution2d PolarResolution2d { get; set; } Property Value PolarResolution2d SpindleBuckle Gets the spindle buckle anchor. public Anchor SpindleBuckle { get; } Property Value Anchor Methods ClearCache() Clears any cached data held by the implementing object. public void ClearCache() Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor GetAnchoredCollidableNode() Gets the anchored collidable node associated with this object. public IAnchoredCollidableNode GetAnchoredCollidableNode() Returns IAnchoredCollidableNode The anchored collidable node. GetAnchoredDisplayeeList() Gets a list of anchored displayable objects. public List<IAnchoredDisplayee> GetAnchoredDisplayeeList() Returns List<IAnchoredDisplayee> A list of IAnchoredDisplayee objects GetAsmb() Gets the key asmb. public Asmb GetAsmb() Returns Asmb The key asmb. GetCollidable() Get ICollidable. public ICollidable GetCollidable() Returns ICollidable The collidable object. GetCollidableAnchor() Gets the anchor associated with the collidable object. public Anchor GetCollidableAnchor() Returns Anchor The Anchor instance. GetCollidee() Get ICollidee. public ICollidee GetCollidee() Returns ICollidee ICollidee GetFletchBuckle() Get fletch buckle anchor. the anchor that generally connect to fixed part such as ground and triggering(motor)-side. public Anchor GetFletchBuckle() Returns Anchor buckle anchor GetSolid() Gets the solid geometry object. public Solid GetSolid() Returns Solid The solid geometry object. GetTailBuckle() Gets the cutter buckle anchor, generally located on the free-end side. public Anchor GetTailBuckle() Returns Anchor MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory UpdateByCylindroid() Update Branch By Cylindroid. Call the function if the Cylindroid content changed. public void UpdateByCylindroid()"
  },
  "api/Hi.NcMech.Holders.FreeformHolder.html": {
    "href": "api/Hi.NcMech.Holders.FreeformHolder.html",
    "title": "Class FreeformHolder | HiAPI-C# 2025",
    "summary": "Class FreeformHolder Namespace Hi.NcMech.Holders Assembly HiMech.dll Represents a freeform tool holder with customizable geometry. public class FreeformHolder : IHolder, ITopo, IGetAsmb, IGetAnchoredDisplayeeList, IAnchoredDisplayee, IDisplayee, IExpandToBox3d, IMakeXmlSource, IAbstractNote, IGetFletchBuckle, IDuplicate, INameNote, IAnchoredCollidabled, IGetCollidable, IGetAnchor, IGetTopoIndex, IGetSolid, IDisposable, IAnchoredCollidableLeaf, IAnchoredCollidableNode, IAnchoredCollidableBased, ICollidable, IClearCache Inheritance object FreeformHolder Implements IHolder ITopo IGetAsmb IGetAnchoredDisplayeeList IAnchoredDisplayee IDisplayee IExpandToBox3d IMakeXmlSource IAbstractNote IGetFletchBuckle IDuplicate INameNote IAnchoredCollidabled IGetCollidable IGetAnchor IGetTopoIndex IGetSolid IDisposable IAnchoredCollidableLeaf IAnchoredCollidableNode IAnchoredCollidableBased ICollidable IClearCache Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods CollisionUtil.Detect(ICollidable, ICollidable, Mat4d, double, int) DispUtil.Display(IDisplayee, Bind, Mat4d) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) TopoDisplayeeUtil.Display(ITopo, Bind) TopoDisplayeeUtil.ExpandToBox3d(ITopo, Box3d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FreeformHolder() Ctor. public FreeformHolder() FreeformHolder(IStlSource) Initializes a new instance of the FreeformHolder class from STL geometry. public FreeformHolder(IStlSource geom) Parameters geom IStlSource The STL geometry provider. FreeformHolder(XElement, string, string, IProgress<IMessage>) Initializes a new instance of the FreeformHolder class from XML data. public FreeformHolder(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress) Parameters src XElement The XML element containing holder data baseDirectory string Base directory path for resolving relative paths relFile string Relative file path progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. Fields XName XML Name. public static string XName Field Value string Properties AbstractNote Gets a descriptive note or abstract about the object. public string AbstractNote { get; } Property Value string CollidableName Gets the name of the collidable object. public string CollidableName { get; } Property Value string CutterBuckle Gets the tail buckle (tool buckle) anchor point public Anchor CutterBuckle { get; } Property Value Anchor Geom Gets or sets the holder geometry. Internal Use Only. public IStlSource Geom { get; set; } Property Value IStlSource Remarks Delegates to Geom of Hi.NcMech.Holders.FreeformHolder.Solid (the same seam as Cylindroid), so the collidee and the display body always tessellate the geometry assigned here; a detached property would leave the solid on the empty geometry it was born with. Call UpdateByGeom() to keep state of Hi.NcMech.Holders.FreeformHolder.Solid if content modified in place. GeomAnchor Gets the geometry anchor point public Anchor GeomAnchor { get; } Property Value Anchor GeomAnchorToSpindleBuckleBranch Gets the branch from GeomAnchor to SpindleBuckle. public Branch GeomAnchorToSpindleBuckleBranch { get; } Property Value Branch GeomToCutterBranch Gets the branch from GeomAnchor to CutterBuckle. public Branch GeomToCutterBranch { get; } Property Value Branch GeomToCutterTransformer Gets or sets the transformer from geometry to tail (Cutter). public ITransformer GeomToCutterTransformer { get; set; } Property Value ITransformer GeomToSpindleTransformer Gets or sets the transformer from geometry to base (Spindle) public ITransformer GeomToSpindleTransformer { get; set; } Property Value ITransformer Name Gets or sets the name of the object. public string Name { get; set; } Property Value string Note Gets or sets the descriptive note for the object. public string Note { get; set; } Property Value string PolarResolution2d Gets or sets the polar resolution 2D settings. Authored data. The resolution is part of a Solid's identity, so assigning this property swaps the holder's solid for one born with the new value (the old solid is disposed). public PolarResolution2d PolarResolution2d { get; set; } Property Value PolarResolution2d SpindleBuckle Gets the base buckle (spindle buckle) anchor point public Anchor SpindleBuckle { get; } Property Value Anchor Methods ClearCache() Clears any cached data held by the implementing object. public void ClearCache() Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor GetAnchoredCollidableNode() Gets the anchored collidable node associated with this object. public IAnchoredCollidableNode GetAnchoredCollidableNode() Returns IAnchoredCollidableNode The anchored collidable node. GetAnchoredDisplayeeList() Gets a list of anchored displayable objects. public List<IAnchoredDisplayee> GetAnchoredDisplayeeList() Returns List<IAnchoredDisplayee> A list of IAnchoredDisplayee objects GetAsmb() Gets the key asmb. public Asmb GetAsmb() Returns Asmb The key asmb. GetCollidable() Get ICollidable. public ICollidable GetCollidable() Returns ICollidable The collidable object. GetCollidableAnchor() Gets the anchor associated with the collidable object. public Anchor GetCollidableAnchor() Returns Anchor The Anchor instance. GetCollidee() Get ICollidee. public ICollidee GetCollidee() Returns ICollidee ICollidee GetFletchBuckle() Get fletch buckle anchor. the anchor that generally connect to fixed part such as ground and triggering(motor)-side. public Anchor GetFletchBuckle() Returns Anchor buckle anchor GetSolid() Gets the solid geometry object. public Solid GetSolid() Returns Solid The solid geometry object. GetTailBuckle() Gets the cutter buckle anchor, generally located on the free-end side. public Anchor GetTailBuckle() Returns Anchor MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory UpdateByGeom() Call the function if the Geom content changed. public void UpdateByGeom()"
  },
  "api/Hi.NcMech.Holders.HolderEditorDisplayee.html": {
    "href": "api/Hi.NcMech.Holders.HolderEditorDisplayee.html",
    "title": "Class HolderEditorDisplayee | HiAPI-C# 2025",
    "summary": "Class HolderEditorDisplayee Namespace Hi.NcMech.Holders Assembly HiMech.dll Displayee for holder editor that provides visualization functionality. public class HolderEditorDisplayee : IAnchoredDisplayee, IGetAnchor, IDisplayee, IExpandToBox3d, IGetAsmb, IGetTopoIndex Inheritance object HolderEditorDisplayee Implements IAnchoredDisplayee IGetAnchor IDisplayee IExpandToBox3d IGetAsmb IGetTopoIndex Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HolderEditorDisplayee() Initializes a new instance of the HolderEditorDisplayee class public HolderEditorDisplayee() HolderEditorDisplayee(IHolder) Initializes a new instance of the HolderEditorDisplayee class with a specified holder public HolderEditorDisplayee(IHolder holder) Parameters holder IHolder The holder to display Properties Holder Gets or sets the holder to be displayed public IHolder Holder { get; set; } Property Value IHolder RenderingMode Gets or sets the rendering mode for the holder solid. public Solid.RenderingModeEnum RenderingMode { get; set; } Property Value Solid.RenderingModeEnum ShowCutterBuckle Gets or sets whether to show the cutter buckle anchor. public bool ShowCutterBuckle { get; set; } Property Value bool ShowGeomAnchor Gets or sets whether to show the geometry anchor. public bool ShowGeomAnchor { get; set; } Property Value bool ShowSpindleBuckle Gets or sets whether to show the spindle buckle anchor. public bool ShowSpindleBuckle { get; set; } Property Value bool Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor GetAsmb() Gets the key asmb. public Asmb GetAsmb() Returns Asmb The key asmb."
  },
  "api/Hi.NcMech.Holders.IHolder.html": {
    "href": "api/Hi.NcMech.Holders.IHolder.html",
    "title": "Interface IHolder | HiAPI-C# 2025",
    "summary": "Interface IHolder Namespace Hi.NcMech.Holders Assembly HiMech.dll Interface for tool holders in NC machining. public interface IHolder : ITopo, IGetAsmb, IGetAnchoredDisplayeeList, IAnchoredDisplayee, IDisplayee, IExpandToBox3d, IMakeXmlSource, IAbstractNote, IGetFletchBuckle, IAnchoredCollidableBased, IDuplicate, INameNote, IAnchoredCollidabled, IGetCollidable, IGetAnchor, IGetTopoIndex, IGetSolid Inherited Members IGetAsmb.GetAsmb() IGetAnchoredDisplayeeList.GetAnchoredDisplayeeList() IDisplayee.Display(Bind) IExpandToBox3d.ExpandToBox3d(Box3d) IMakeXmlSource.MakeXmlSource(string, string, bool) IAbstractNote.AbstractNote IGetFletchBuckle.GetFletchBuckle() IAnchoredCollidableBased.CollidableName IAnchoredCollidableBased.GetAnchoredCollidableNode() IDuplicate.Duplicate(params object[]) INameNote.Name INameNote.Note IAnchoredCollidabled.GetCollidableAnchor() IGetCollidable.GetCollidable() IGetAnchor.GetAnchor() IGetSolid.GetSolid() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) TopoDisplayeeUtil.Display(ITopo, Bind) TopoDisplayeeUtil.ExpandToBox3d(ITopo, Box3d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties CutterBuckle Gets the cutter buckle anchor. Anchor CutterBuckle { get; } Property Value Anchor GeomAnchor Gets the geometry anchor of the holder. Anchor GeomAnchor { get; } Property Value Anchor SpindleBuckle Gets the spindle buckle anchor. Anchor SpindleBuckle { get; } Property Value Anchor ThemeColor Default theme color for holder visualization. public static Vec3d ThemeColor { get; } Property Value Vec3d Methods GetTailBuckle() Gets the cutter buckle anchor, generally located on the free-end side. Anchor GetTailBuckle() Returns Anchor"
  },
  "api/Hi.NcMech.Holders.html": {
    "href": "api/Hi.NcMech.Holders.html",
    "title": "Namespace Hi.NcMech.Holders | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcMech.Holders Classes CylindroidHolder Represents a cylindrical tool holder for machining operations. FreeformHolder Represents a freeform tool holder with customizable geometry. HolderEditorDisplayee Displayee for holder editor that provides visualization functionality. Interfaces IHolder Interface for tool holders in NC machining."
  },
  "api/Hi.NcMech.ICollisionIndexPairsSource.html": {
    "href": "api/Hi.NcMech.ICollisionIndexPairsSource.html",
    "title": "Interface ICollisionIndexPairsSource | HiAPI-C# 2025",
    "summary": "Interface ICollisionIndexPairsSource Namespace Hi.NcMech Assembly HiMech.dll Interface that provides access to collision index pairs and XML serialization capabilities. Extends IGetCollisionIndexPairs with XML serialization support. public interface ICollisionIndexPairsSource : IGetCollisionIndexPairs, IMakeXmlSource Inherited Members IGetCollisionIndexPairs.GetCollisionIndexPairs() IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.NcMech.Solids.CollisionRedScope.Scope.html": {
    "href": "api/Hi.NcMech.Solids.CollisionRedScope.Scope.html",
    "title": "Struct CollisionRedScope.Scope | HiAPI-C# 2025",
    "summary": "Struct CollisionRedScope.Scope Namespace Hi.NcMech.Solids Assembly HiMech.dll Restores the previous scope on dispose. public readonly struct CollisionRedScope.Scope : IDisposable Implements IDisposable Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose()"
  },
  "api/Hi.NcMech.Solids.CollisionRedScope.html": {
    "href": "api/Hi.NcMech.Solids.CollisionRedScope.html",
    "title": "Class CollisionRedScope | HiAPI-C# 2025",
    "summary": "Class CollisionRedScope Namespace Hi.NcMech.Solids Assembly HiMech.dll Render-thread ambient scope telling Display(Bind) which items the current scene paints collision-red. Collision state is per-scenario and owned by the detecting equipment — never stored on the geometry, so one Solid hosted by several topology entities carries no cross-scenario red — and it is application state, so it does not travel on the display base layer (Bind) either: the scene object that owns the state opens the scope around its subtree. using var _ = CollisionRedScope.Enter(equipment.IsCollisionRed); asmb.Display(bind, root, displayees); public static class CollisionRedScope Inheritance object CollisionRedScope Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods Enter(Func<object, bool>) Opens a scope on the calling thread; dispose restores the previous one. isCollisionRed may be null (an empty scope). public static CollisionRedScope.Scope Enter(Func<object, bool> isCollisionRed) Parameters isCollisionRed Func<object, bool> The scene's per-item collision query. Returns CollisionRedScope.Scope Token that restores the previous scope on dispose. IsRed(object) Whether the ambient scene flags item collision-red. False outside any scope — a topology displayed without one (e.g. the authored setup face) never paints red. public static bool IsRed(object item) Parameters item object A displayed item (typically a Solid). Returns bool true if the item is currently collision-red."
  },
  "api/Hi.NcMech.Solids.IGetSolid.html": {
    "href": "api/Hi.NcMech.Solids.IGetSolid.html",
    "title": "Interface IGetSolid | HiAPI-C# 2025",
    "summary": "Interface IGetSolid Namespace Hi.NcMech.Solids Assembly HiMech.dll Interface for retrieving solid geometry objects. Provides a standardized way to access solid models. public interface IGetSolid Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetSolid() Gets the solid geometry object. Solid GetSolid() Returns Solid The solid geometry object."
  },
  "api/Hi.NcMech.Solids.Solid.RenderingModeEnum.html": {
    "href": "api/Hi.NcMech.Solids.Solid.RenderingModeEnum.html",
    "title": "Enum Solid.RenderingModeEnum | HiAPI-C# 2025",
    "summary": "Enum Solid.RenderingModeEnum Namespace Hi.NcMech.Solids Assembly HiMech.dll Rendering mode for solids. public enum Solid.RenderingModeEnum Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Edge = 1 Render only feature edges. Hide = 2 Hidden (do not render). Solid = 0 Render full solid surfaces."
  },
  "api/Hi.NcMech.Solids.Solid.html": {
    "href": "api/Hi.NcMech.Solids.Solid.html",
    "title": "Class Solid | HiAPI-C# 2025",
    "summary": "Class Solid Namespace Hi.NcMech.Solids Assembly HiMech.dll Represents a solid geometry object with display, collision detection, and STL capabilities. Provides thread-safe access to geometry data and caching mechanisms. public class Solid : IGetTriTree, ICollidable, IGetCollidable, IDisplayee, IExpandToBox3d, IStlSource, IGetStl, IDisposable, IMakeXmlSource, IGetSolid, IUpdateByContent, IClearCache Inheritance object Solid Implements IGetTriTree ICollidable IGetCollidable IDisplayee IExpandToBox3d IStlSource IGetStl IDisposable IMakeXmlSource IGetSolid IUpdateByContent IClearCache Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods CollisionUtil.Detect(ICollidable, ICollidable, Mat4d, double, int) DispUtil.Display(IDisplayee, Bind, Mat4d) StlUtil.ToFaceDrawing(IGetStl) StlUtil.ToLineDrawing(IGetStl) StlUtil.ToSparkleLineDrawing(IGetStl) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Solid() Initializes a new instance of the Solid class. public Solid() Solid(IGetStl) Initializes a new instance of the Solid class with the specified STL geometry source. public Solid(IGetStl geom) Parameters geom IGetStl The STL geometry source. Solid(IGetStl, PolarResolution2d) Initializes a new instance of the Solid class with the specified STL geometry source and the mesh resolution the solid is born with (see PolarResolution2d). public Solid(IGetStl geom, PolarResolution2d polarResolution2d) Parameters geom IGetStl The STL geometry source. polarResolution2d PolarResolution2d Mesh resolution snapshot; null lets the geometry apply its own default. Solid(XElement, string, IProgress<IMessage>) Initializes a new instance of the Solid class from XML. public Solid(XElement src, string baseDirectory, IProgress<IMessage> progress) Parameters src XElement The XML source element. baseDirectory string The base directory for resolving relative paths. progress IProgress<IMessage> The progress reporter. Fields XName Gets the XML element name for serialization. public static string XName Field Value string Properties Geom Gets or sets the STL geometry source. Setting this property will clear the cached data. public IGetStl Geom { get; set; } Property Value IGetStl NativeStl Gets the native STL representation. The data is created from the STL representation when first accessed, and is null once this solid is disposed — a disposed solid never rebuilds. public NativeStl NativeStl { get; } Property Value NativeStl PolarResolution2d The mesh resolution this solid's runtime products are generated with — part of the solid's identity, fixed at construction (a defensive copy, so later mutation of the caller's carrier cannot reach it). Null lets a parametric Geom apply its own default. To change the resolution, build a new Solid (and dispose the old one); there is no in-place mutation or invalidation protocol. Never serialized: resolution is runtime data, not authored content. public PolarResolution2d PolarResolution2d { get; } Property Value PolarResolution2d Prepared Gets or sets whether the solid geometry is prepared for use. Setting this to true will ensure all necessary data structures are initialized. Setting this to false will clear the cached data. public bool Prepared { get; set; } Property Value bool Rgb Optional authored display color (RGB, each channel 0~1). Null means not authored: display sites fall back to a color seeded from the hosting anchor's persisted Guid, and Display(Bind) pushes no color of its own. Collision red from the ambient scene scope (CollisionRedScope — stamped by the detecting equipment) always wins over the authored color. Serialized as the optional Rgb attribute of the <Solid> element; legacy readers ignore attributes, so the addition is backward and forward compatible. public Vec3d Rgb { get; set; } Property Value Vec3d SmoothTopoStl3d Gets the native smooth topology STL representation. The data is created from the STL representation when first accessed, and is null once this solid is disposed — a disposed solid never rebuilds. public NativeTopoStl3d SmoothTopoStl3d { get; } Property Value NativeTopoStl3d Stl Gets the STL representation of the solid geometry. The STL data is cached after first access, and null once this solid is disposed. Note this is normally the geometry model's own instance, not a private copy: a StlFile source hands back the very CacheStl it holds for its lifetime, so dropping this field frees nothing for file-backed geometry. Do not mutate the returned mesh. public Stl Stl { get; } Property Value Stl TriTree Gets the triangle tree representation for collision detection. The tree is built from the native STL data when first accessed, and is null once this solid is disposed — a disposed solid never rebuilds, and CollisionUtil reads a null collidee as “no collision” rather than raising, so a disposed solid silently stops participating in detection. public TriTree TriTree { get; } Property Value TriTree Methods ClearCache() Manually clears the cached data if the content of Geom has changed. The cache determines the behavior of the Solid. public void ClearCache() Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. Display(Bind, RenderingModeEnum) Displays the solid according to the specified rendering mode. public void Display(Bind bind, Solid.RenderingModeEnum renderingMode) Parameters bind Bind Display binding context. renderingMode Solid.RenderingModeEnum Rendering mode. DisplayFeatureEdges(Bind) Displays the feature edges of the solid. public void DisplayFeatureEdges(Bind bind) Parameters bind Bind Display binding context. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) Releases the unmanaged resources and optionally releases the managed resources. protected virtual void Dispose(bool disposing) Parameters disposing bool true to release both managed and unmanaged resources; false to release only unmanaged resources. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetCollidable() Get ICollidable. public ICollidable GetCollidable() Returns ICollidable The collidable object. GetCollidee() Get ICollidee. public ICollidee GetCollidee() Returns ICollidee ICollidee GetSolid() Gets the solid geometry object. public Solid GetSolid() Returns Solid The solid geometry object. GetSourceGeom() Gets the source geometry object. public IGetStl GetSourceGeom() Returns IGetStl The source geometry object. GetStl() Gets the STL geometry data. public Stl GetStl() Returns Stl The STL geometry object GetTriTree() Get TriTree. public TriTree GetTriTree() Returns TriTree TriTree MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. UpdateByContent() Updates the object based on its current content. public void UpdateByContent()"
  },
  "api/Hi.NcMech.Solids.SolidFuncSource.html": {
    "href": "api/Hi.NcMech.Solids.SolidFuncSource.html",
    "title": "Class SolidFuncSource | HiAPI-C# 2025",
    "summary": "Class SolidFuncSource Namespace Hi.NcMech.Solids Assembly HiMech.dll Provides a function-based source for solid geometry objects. Allows dynamic generation of solid models through a delegate function. public class SolidFuncSource : IGetSolid Inheritance object SolidFuncSource Implements IGetSolid Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SolidFuncSource(Func<Solid>) Initializes a new instance of the SolidFuncSource class with the specified solid getter function. public SolidFuncSource(Func<Solid> solidGetter) Parameters solidGetter Func<Solid> The function that generates the solid geometry object. Properties SolidGetter Gets or sets the function that generates the solid geometry object. public Func<Solid> SolidGetter { get; set; } Property Value Func<Solid> Methods GetSolid() Gets the solid geometry object. public Solid GetSolid() Returns Solid The solid geometry object."
  },
  "api/Hi.NcMech.Solids.html": {
    "href": "api/Hi.NcMech.Solids.html",
    "title": "Namespace Hi.NcMech.Solids | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcMech.Solids Classes CollisionRedScope Render-thread ambient scope telling Display(Bind) which items the current scene paints collision-red. Collision state is per-scenario and owned by the detecting equipment — never stored on the geometry, so one Solid hosted by several topology entities carries no cross-scenario red — and it is application state, so it does not travel on the display base layer (Bind) either: the scene object that owns the state opens the scope around its subtree. using var _ = CollisionRedScope.Enter(equipment.IsCollisionRed); asmb.Display(bind, root, displayees); Solid Represents a solid geometry object with display, collision detection, and STL capabilities. Provides thread-safe access to geometry data and caching mechanisms. SolidFuncSource Provides a function-based source for solid geometry objects. Allows dynamic generation of solid models through a delegate function. Structs CollisionRedScope.Scope Restores the previous scope on dispose. Interfaces IGetSolid Interface for retrieving solid geometry objects. Provides a standardized way to access solid models. Enums Solid.RenderingModeEnum Rendering mode for solids."
  },
  "api/Hi.NcMech.Topo.INcStroke.html": {
    "href": "api/Hi.NcMech.Topo.INcStroke.html",
    "title": "Interface INcStroke | HiAPI-C# 2025",
    "summary": "Interface INcStroke Namespace Hi.NcMech.Topo Assembly HiMech.dll Nc capability include key char, stroke and speed limit. public interface INcStroke Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetKeyCode() Get key code of the motion axis. string GetKeyCode() Returns string GetSpeedLimit() Get speed limit. double GetSpeedLimit() Returns double GetStrokeMax() Get positivest stroke. double GetStrokeMax() Returns double GetStrokeMin() Get negativest stroke. double GetStrokeMin() Returns double"
  },
  "api/Hi.NcMech.Topo.INcTransformer.html": {
    "href": "api/Hi.NcMech.Topo.INcTransformer.html",
    "title": "Interface INcTransformer | HiAPI-C# 2025",
    "summary": "Interface INcTransformer Namespace Hi.NcMech.Topo Assembly HiMech.dll Transformer for NC motion axis. public interface INcTransformer : IDynamicRegular, IDynamicTransformer, ITransformer, IMakeXmlSource, IToPresentDto, INcStroke Inherited Members IDynamicRegular.Step ITransformer.GetMat() ITransformer.GetMatInv() ITransformer.Clone() IMakeXmlSource.MakeXmlSource(string, string, bool) IToPresentDto.ToPresentDto() INcStroke.GetKeyCode() INcStroke.GetStrokeMin() INcStroke.GetStrokeMax() INcStroke.GetSpeedLimit() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.NcMech.Topo.ITopoBrick.html": {
    "href": "api/Hi.NcMech.Topo.ITopoBrick.html",
    "title": "Interface ITopoBrick | HiAPI-C# 2025",
    "summary": "Interface ITopoBrick Namespace Hi.NcMech.Topo Assembly HiMech.dll Interface that represents a topological brick in NC machining. Combines solid geometry, display capabilities, and collision detection functionality. public interface ITopoBrick : IGetSolid, IAnchoredDisplayee, IGetAnchor, IGetTopoIndex, IDisplayee, IExpandToBox3d, IAnchoredCollidableLeaf, IAnchoredCollidableNode, IAnchoredCollidableBased, ICollidable Inherited Members IGetSolid.GetSolid() IGetAnchor.GetAnchor() IDisplayee.Display(Bind) IExpandToBox3d.ExpandToBox3d(Box3d) IAnchoredCollidableLeaf.GetCollidableAnchor() IAnchoredCollidableBased.CollidableName IAnchoredCollidableBased.GetAnchoredCollidableNode() ICollidable.GetCollidee() Extension Methods CollisionUtil.Detect(ICollidable, ICollidable, Mat4d, double, int) DispUtil.Display(IDisplayee, Bind, Mat4d) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.NcMech.Topo.NcRotation.html": {
    "href": "api/Hi.NcMech.Topo.NcRotation.html",
    "title": "Class NcRotation | HiAPI-C# 2025",
    "summary": "Class NcRotation Namespace Hi.NcMech.Topo Assembly HiMech.dll Represents a rotational transformer for NC machine tool axes. Provides functionality for rotational motion with stroke and speed limits. public class NcRotation : DynamicRotation, IDynamicRotation, IGetInverseTransformer, INcTransformer, IDynamicRegular, IDynamicTransformer, ITransformer, IMakeXmlSource, IToPresentDto, INcStroke Inheritance object DynamicRotation NcRotation Implements IDynamicRotation IGetInverseTransformer INcTransformer IDynamicRegular IDynamicTransformer ITransformer IMakeXmlSource IToPresentDto INcStroke Inherited Members DynamicRotation.Set(DynamicRotation) DynamicRotation.Step DynamicRotation.GetMat() DynamicRotation.GetMatInv() DynamicRotation.GetInverseTransformer() DynamicRotation.Axis DynamicRotation.Angle_rad DynamicRotation.Angle_deg DynamicRotation.Pivot DynamicRotation.ToPresentDto() object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NcRotation() Initializes a new instance of the NcRotation class. public NcRotation() NcRotation(Vec3d, double) Initializes a new instance of the NcRotation class with the specified axis and angle. public NcRotation(Vec3d axis, double angle_rad = 0) Parameters axis Vec3d The rotation axis vector. angle_rad double The rotation angle in radians. NcRotation(Vec3d, double, Vec3d) Initializes a new instance of the NcRotation class with the specified axis, angle and pivot point. public NcRotation(Vec3d axis, double angle_rad, Vec3d pivot) Parameters axis Vec3d The rotation axis vector. angle_rad double The rotation angle in radians. pivot Vec3d The pivot point for rotation. NcRotation(XElement) Initializes a new instance of the NcRotation class from XML. public NcRotation(XElement src) Parameters src XElement The XML source element. Properties KeyCode Gets or sets the key code of the motion axis. public string KeyCode { get; set; } Property Value string SpeedLimit_radds Gets or sets the speed limit in radians per second. public double SpeedLimit_radds { get; set; } Property Value double SpeedLimit_rpm Gets or sets the speed limit in revolutions per minute. public double SpeedLimit_rpm { get; set; } Property Value double StrokeMax_deg Gets or sets the maximum stroke angle in degrees. public double StrokeMax_deg { get; set; } Property Value double StrokeMax_rad Gets or sets the maximum stroke angle in radians. public double StrokeMax_rad { get; set; } Property Value double StrokeMin_deg Gets or sets the minimum stroke angle in degrees. public double StrokeMin_deg { get; set; } Property Value double StrokeMin_rad Gets or sets the minimum stroke angle in radians. public double StrokeMin_rad { get; set; } Property Value double XName Gets the XML element name for serialization. public static string XName { get; } Property Value string Methods Clone() Clones this instance. public override ITransformer Clone() Returns ITransformer clone GetKeyCode() Get key code of the motion axis. public string GetKeyCode() Returns string GetSpeedLimit() Get speed limit. public double GetSpeedLimit() Returns double Remarks Gets the speed limit in radians per second. GetStrokeMax() Get positivest stroke. public double GetStrokeMax() Returns double Remarks Gets the maximum stroke angle in radians. GetStrokeMin() Get negativest stroke. public double GetStrokeMin() Returns double Remarks Gets the minimum stroke angle in radians. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public override XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcMech.Topo.NcTranslation.html": {
    "href": "api/Hi.NcMech.Topo.NcTranslation.html",
    "title": "Class NcTranslation | HiAPI-C# 2025",
    "summary": "Class NcTranslation Namespace Hi.NcMech.Topo Assembly HiMech.dll Represents a translational transformer for NC machine tool axes. Provides functionality for linear motion with stroke and speed limits. public class NcTranslation : DynamicTranslation, IGetInverseTransformer, INcTransformer, IDynamicRegular, IDynamicTransformer, ITransformer, IMakeXmlSource, IToPresentDto, INcStroke Inheritance object DynamicTranslation NcTranslation Implements IGetInverseTransformer INcTransformer IDynamicRegular IDynamicTransformer ITransformer IMakeXmlSource IToPresentDto INcStroke Inherited Members DynamicTranslation.Set(DynamicTranslation) DynamicTranslation.Step DynamicTranslation.GetMat() DynamicTranslation.GetMatInv() DynamicTranslation.GetInverseTransformer() DynamicTranslation.Axis DynamicTranslation.Len DynamicTranslation.ToPresentDto() object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NcTranslation() Initializes a new instance of the NcTranslation class. public NcTranslation() NcTranslation(Vec3d, double) Initializes a new instance of the NcTranslation class with the specified translation vector and length. public NcTranslation(Vec3d trans, double len = 0) Parameters trans Vec3d The translation vector. len double The translation length. NcTranslation(XElement) Initializes a new instance of the NcTranslation class from XML. public NcTranslation(XElement src) Parameters src XElement The XML source element. Properties KeyCode Gets or sets the key code of the motion axis. public string KeyCode { get; set; } Property Value string SpeedLimit_mmdmin Gets or sets the speed limit in millimeters per minute. public double SpeedLimit_mmdmin { get; set; } Property Value double SpeedLimit_mmds Gets or sets the speed limit in millimeters per second. public double SpeedLimit_mmds { get; set; } Property Value double StrokeMax_mm Gets or sets the maximum stroke distance in millimeters. public double StrokeMax_mm { get; set; } Property Value double StrokeMin_mm Gets or sets the minimum stroke distance in millimeters. public double StrokeMin_mm { get; set; } Property Value double XName Gets the XML element name for serialization. public static string XName { get; } Property Value string Methods Clone() Clones this instance. public override ITransformer Clone() Returns ITransformer clone GetKeyCode() Get key code of the motion axis. public string GetKeyCode() Returns string GetSpeedLimit() Get speed limit. public double GetSpeedLimit() Returns double Remarks Gets the speed limit in millimeters per second. GetStrokeMax() Get positivest stroke. public double GetStrokeMax() Returns double Remarks Gets the maximum stroke distance in millimeters. GetStrokeMin() Get negativest stroke. public double GetStrokeMin() Returns double Remarks Gets the minimum stroke distance in millimeters. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public override XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcMech.Topo.StlSourceTopoBrick.html": {
    "href": "api/Hi.NcMech.Topo.StlSourceTopoBrick.html",
    "title": "Class StlSourceTopoBrick | HiAPI-C# 2025",
    "summary": "Class StlSourceTopoBrick Namespace Hi.NcMech.Topo Assembly HiMech.dll Represents a topological brick that sources its geometry from an STL file. Implements display, collision detection, and content update capabilities. public class StlSourceTopoBrick : ITopoBrick, IGetSolid, IAnchoredDisplayee, IGetAnchor, IGetTopoIndex, IDisplayee, IExpandToBox3d, IAnchoredCollidableLeaf, IAnchoredCollidableNode, IAnchoredCollidableBased, ICollidable, IDisposable, IUpdateByContent, IClearCache Inheritance object StlSourceTopoBrick Implements ITopoBrick IGetSolid IAnchoredDisplayee IGetAnchor IGetTopoIndex IDisplayee IExpandToBox3d IAnchoredCollidableLeaf IAnchoredCollidableNode IAnchoredCollidableBased ICollidable IDisposable IUpdateByContent IClearCache Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods CollisionUtil.Detect(ICollidable, ICollidable, Mat4d, double, int) DispUtil.Display(IDisplayee, Bind, Mat4d) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors StlSourceTopoBrick() Initializes a new instance of the StlSourceTopoBrick class. public StlSourceTopoBrick() StlSourceTopoBrick(Anchor) Initializes a new instance of the StlSourceTopoBrick class with the specified anchor. public StlSourceTopoBrick(Anchor anchor) Parameters anchor Anchor The anchor point for this brick. StlSourceTopoBrick(Anchor, IGetStl) Initializes a new instance of the StlSourceTopoBrick class with the specified anchor and geometry. public StlSourceTopoBrick(Anchor anchor, IGetStl geom) Parameters anchor Anchor The anchor point for this brick. geom IGetStl The STL geometry source. StlSourceTopoBrick(Anchor, IGetStl, PolarResolution2d) Initializes a new instance of the StlSourceTopoBrick class whose solid is born with the given mesh resolution (see PolarResolution2d). public StlSourceTopoBrick(Anchor anchor, IGetStl geom, PolarResolution2d resolution) Parameters anchor Anchor The anchor point for this brick. geom IGetStl The STL geometry source. resolution PolarResolution2d Mesh resolution the solid is born with; null lets the geometry apply its own default. StlSourceTopoBrick(Anchor, Solid) Initializes a new instance of the StlSourceTopoBrick class hosting an externally owned Solid. The brick does NOT dispose an injected solid: the provider keeps its lifecycle, so one solid instance can be shared by several hosts (e.g. two topology entities displaying the same machine part). public StlSourceTopoBrick(Anchor anchor, Solid solid) Parameters anchor Anchor The anchor point for this brick. solid Solid The externally owned solid to host. Properties Anchor Gets the anchor point for this brick. public Anchor Anchor { get; } Property Value Anchor CollidableName Gets the name of the collidable object. public string CollidableName { get; } Property Value string Geom Gets or sets the STL geometry source. public IGetStl Geom { get; set; } Property Value IGetStl Solid Gets the solid geometry instance. The instance is swapped — not mutated — when the mesh resolution changes (see RebuildSolid(PolarResolution2d)), so consumers must re-read this property instead of caching the solid. public Solid Solid { get; } Property Value Solid Methods ClearCache() Clears any cached data held by the implementing object. public void ClearCache() Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) Releases the unmanaged resources and optionally releases the managed resources. protected virtual void Dispose(bool disposing) Parameters disposing bool true to release both managed and unmanaged resources; false to release only unmanaged resources. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor GetAnchoredCollidableNode() Gets the anchored collidable node associated with this object. public IAnchoredCollidableNode GetAnchoredCollidableNode() Returns IAnchoredCollidableNode The anchored collidable node. GetCollidableAnchor() Gets the anchor associated with this collidable leaf. public Anchor GetCollidableAnchor() Returns Anchor The anchor for this collidable leaf. GetCollidee() Get ICollidee. public ICollidee GetCollidee() Returns ICollidee ICollidee GetSolid() Gets the solid geometry object. public Solid GetSolid() Returns Solid The solid geometry object. RebuildSolid(PolarResolution2d) Swaps the hosted Solid for one born with resolution; the geometry and authored color carry over and the replaced solid is disposed. The resolution is part of a solid's identity, so a matching resolution keeps the current instance untouched. Only a brick that owns its solid may rebuild it. public bool RebuildSolid(PolarResolution2d resolution) Parameters resolution PolarResolution2d Target mesh resolution; null lets the geometry apply its own default. Returns bool true if the solid was swapped; false if the resolution already matches. UpdateByContent() Updates the object based on its current content. public void UpdateByContent()"
  },
  "api/Hi.NcMech.Topo.html": {
    "href": "api/Hi.NcMech.Topo.html",
    "title": "Namespace Hi.NcMech.Topo | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcMech.Topo Classes NcRotation Represents a rotational transformer for NC machine tool axes. Provides functionality for rotational motion with stroke and speed limits. NcTranslation Represents a translational transformer for NC machine tool axes. Provides functionality for linear motion with stroke and speed limits. StlSourceTopoBrick Represents a topological brick that sources its geometry from an STL file. Implements display, collision detection, and content update capabilities. Interfaces INcStroke Nc capability include key char, stroke and speed limit. INcTransformer Transformer for NC motion axis. ITopoBrick Interface that represents a topological brick in NC machining. Combines solid geometry, display capabilities, and collision detection functionality."
  },
  "api/Hi.NcMech.Workpieces.Workpiece.html": {
    "href": "api/Hi.NcMech.Workpieces.Workpiece.html",
    "title": "Class Workpiece | HiAPI-C# 2025",
    "summary": "Class Workpiece Namespace Hi.NcMech.Workpieces Assembly HiMech.dll Workpiece configuration data model. public class Workpiece : IGetAnchor, IGetTopoIndex, IGetCuttingPara, IMakeXmlSource Inheritance object Workpiece Implements IGetAnchor IGetTopoIndex IGetCuttingPara IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks Workpiece holds the persistent/serializable configuration. Meshed geometry, caching, diff calculation, defect scanning, display and collision are managed by WorkpieceService. Constructors Workpiece() Initializes a new instance of the Workpiece class. public Workpiece() Workpiece(XElement, string, string, IProgress<IMessage>) Initializes a new instance of the Workpiece class. public Workpiece(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress) Parameters src XElement XML element source. baseDirectory string Base directory. relFile string Relative file path. progress IProgress<IMessage> Progress reporter for diagnostic messages emitted during construction. Properties Asmb Asmb. public Asmb Asmb { get; } Property Value Asmb CollidableName Collidable name. public string CollidableName { get; } Property Value string CuttingPara Milling parameters. public ICuttingPara CuttingPara { get; set; } Property Value ICuttingPara CuttingParaFile File path for milling parameters. public string CuttingParaFile { get; set; } Property Value string FixtureBuckle Buckle anchor. public Anchor FixtureBuckle { get; } Property Value Anchor FixtureToProgramZeroMat4d Matrix transformation from fixture to program zero. public Mat4d FixtureToProgramZeroMat4d { get; } Property Value Mat4d GeomAnchor Anchor of workpiece geometry. public Anchor GeomAnchor { get; } Property Value Anchor IdealGeom Ideal geometry representation. public IGetStl IdealGeom { get; set; } Property Value IGetStl InitGeom Raw geometry for initiate. public IMakeXmlSource InitGeom { get; set; } Property Value IMakeXmlSource InitResolution Resolution for initialization. public double InitResolution { get; set; } Property Value double ProgramZeroAnchor Anchor of geometry zero and cutter location zero. public Anchor ProgramZeroAnchor { get; } Property Value Anchor WorkpieceGeomToFixtureBuckleBranch Branch connecting workpiece geometry to fixture buckle. public Branch WorkpieceGeomToFixtureBuckleBranch { get; } Property Value Branch WorkpieceGeomToFixtureBuckleTransformer Transformer connecting workpiece geometry to fixture buckle. public ITransformer WorkpieceGeomToFixtureBuckleTransformer { get; set; } Property Value ITransformer WorkpieceGeomToProgramZeroBranch Branch connecting workpiece geometry to program zero. public Branch WorkpieceGeomToProgramZeroBranch { get; } Property Value Branch WorkpieceGeomToProgramZeroTransformer Transformer connecting workpiece geometry to program zero. public ITransformer WorkpieceGeomToProgramZeroTransformer { get; set; } Property Value ITransformer WorkpieceMaterial Workpiece material. public WorkpieceMaterial WorkpieceMaterial { get; set; } Property Value WorkpieceMaterial WorkpieceMaterialFile File path for workpiece material. public string WorkpieceMaterialFile { get; set; } Property Value string XName Name for XML IO. public static string XName { get; } Property Value string Methods GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor GetCuttingPara() Get ICuttingPara. public ICuttingPara GetCuttingPara() Returns ICuttingPara ICuttingPara MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcMech.Workpieces.WorkpieceEditorDisplayee.html": {
    "href": "api/Hi.NcMech.Workpieces.WorkpieceEditorDisplayee.html",
    "title": "Class WorkpieceEditorDisplayee | HiAPI-C# 2025",
    "summary": "Class WorkpieceEditorDisplayee Namespace Hi.NcMech.Workpieces Assembly HiMech.dll Displayee for visualizing workpiece raw/ideal/meshed geometry and anchors. public class WorkpieceEditorDisplayee : IDisplayee, IExpandToBox3d Inheritance object WorkpieceEditorDisplayee Implements IDisplayee IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors WorkpieceEditorDisplayee(IProgress<object>) public WorkpieceEditorDisplayee(IProgress<object> progress = null) Parameters progress IProgress<object> Progress reporter for meshed geometry operations (e.g. defect warnings). Properties Config Gets or sets the configuration for visualization. public WorkpieceEditorDisplayeeConfig Config { get; set; } Property Value WorkpieceEditorDisplayeeConfig FixtureRenderingMode Gets or sets the rendering mode for fixture. public Solid.RenderingModeEnum FixtureRenderingMode { get; set; } Property Value Solid.RenderingModeEnum IdealGeomRenderingMode Gets or sets the rendering mode for ideal geometry. public Solid.RenderingModeEnum IdealGeomRenderingMode { get; set; } Property Value Solid.RenderingModeEnum MachiningEquipmentGetter Gets or sets the delegate that provides Hi.NcMech.Workpieces.WorkpieceEditorDisplayee.MachiningEquipment. public Func<MachiningEquipment> MachiningEquipmentGetter { get; set; } Property Value Func<MachiningEquipment> Progress Progress reporter for meshed geometry operations. public IProgress<object> Progress { get; } Property Value IProgress<object> RawGeomRenderingMode Gets or sets the rendering mode for raw geometry. public Solid.RenderingModeEnum RawGeomRenderingMode { get; set; } Property Value Solid.RenderingModeEnum ShowMeshedGeom Gets or sets whether to show meshed geometry. public bool ShowMeshedGeom { get; set; } Property Value bool WorkpieceServiceGetter Gets or sets the delegate that provides Hi.NcMech.Workpieces.WorkpieceEditorDisplayee.WorkpieceService. public Func<WorkpieceService> WorkpieceServiceGetter { get; set; } Property Value Func<WorkpieceService> Methods ClearIdealGeomCache() Clears the ideal geometry cache on workpiece service. public void ClearIdealGeomCache() ClearRawGeomCache() Clears the raw geometry cache on workpiece service. public void ClearRawGeomCache() Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box"
  },
  "api/Hi.NcMech.Workpieces.WorkpieceEditorDisplayeeConfig.html": {
    "href": "api/Hi.NcMech.Workpieces.WorkpieceEditorDisplayeeConfig.html",
    "title": "Class WorkpieceEditorDisplayeeConfig | HiAPI-C# 2025",
    "summary": "Class WorkpieceEditorDisplayeeConfig Namespace Hi.NcMech.Workpieces Assembly HiMech.dll Configuration settings for workpiece editor display. public class WorkpieceEditorDisplayeeConfig : IMakeXmlSource Inheritance object WorkpieceEditorDisplayeeConfig Implements IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors WorkpieceEditorDisplayeeConfig() Initializes a new instance of the WorkpieceEditorDisplayeeConfig class. public WorkpieceEditorDisplayeeConfig() WorkpieceEditorDisplayeeConfig(XElement) Initializes a new instance from XML. public WorkpieceEditorDisplayeeConfig(XElement element) Parameters element XElement Properties FixtureRenderingMode Rendering mode for fixture geometry. public Solid.RenderingModeEnum FixtureRenderingMode { get; set; } Property Value Solid.RenderingModeEnum IdealGeomRenderingMode Rendering mode for ideal geometry. public Solid.RenderingModeEnum IdealGeomRenderingMode { get; set; } Property Value Solid.RenderingModeEnum RawGeomRenderingMode Rendering mode for raw geometry. public Solid.RenderingModeEnum RawGeomRenderingMode { get; set; } Property Value Solid.RenderingModeEnum ShowFixtureBuckle Whether to show fixture buckle. public bool ShowFixtureBuckle { get; set; } Property Value bool ShowGeomAnchor Whether to show geometry anchor. public bool ShowGeomAnchor { get; set; } Property Value bool ShowMeshedGeom Whether to show meshed geometry. public bool ShowMeshedGeom { get; set; } Property Value bool ShowProgramZeroAnchor Whether to show program zero anchor. public bool ShowProgramZeroAnchor { get; set; } Property Value bool XName Name for XML IO. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcMech.Workpieces.WorkpieceService.html": {
    "href": "api/Hi.NcMech.Workpieces.WorkpieceService.html",
    "title": "Class WorkpieceService | HiAPI-C# 2025",
    "summary": "Class WorkpieceService Namespace Hi.NcMech.Workpieces Assembly HiMech.dll Runtime service for Workpiece. public class WorkpieceService : IDisplayee, IExpandToBox3d, IDisposable, IGetAnchoredDisplayeeList, IAnchoredCollidableLeaf, IAnchoredCollidableNode, IAnchoredCollidableBased, ICollidable Inheritance object WorkpieceService Implements IDisplayee IExpandToBox3d IDisposable IGetAnchoredDisplayeeList IAnchoredCollidableLeaf IAnchoredCollidableNode IAnchoredCollidableBased ICollidable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods CollisionUtil.Detect(ICollidable, ICollidable, Mat4d, double, int) DispUtil.Display(IDisplayee, Bind, Mat4d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks WorkpieceService handles meshed geometry, caching, diff calculation, defect scanning, display and collision — state that does not require configuration IO. Compare to Workpiece, which holds the persistent/serializable configuration. Constructors WorkpieceService(Func<Workpiece>, Func<string>) Ctor. public WorkpieceService(Func<Workpiece> workpieceGetter, Func<string> baseDirectoryGetter = null) Parameters workpieceGetter Func<Workpiece> baseDirectoryGetter Func<string> Properties BaseDirectoryGetter Provides the base directory that relative file paths in this service resolve against (injected by the owning project service); when null, paths are used as-is. public Func<string> BaseDirectoryGetter { get; } Property Value Func<string> BottomResolution Resolution. public double BottomResolution { get; } Property Value double CollidableName Gets the name of the collidable object. public string CollidableName { get; } Property Value string ConstructionDefectDisplayee Construction defect displayee. public ConstructionDefectDisplayee ConstructionDefectDisplayee { get; } Property Value ConstructionDefectDisplayee DetectionRadius_mm Detection radius in millimeters last used by Diff(double, CancellationToken, IProgress<IMessage>). It is set by that runtime call (e.g. from a session / mission command), not by display callers, and saved on the service so consumers (e.g. the web UI) can bound DiffVisualRadius_mm to it — the visual radius is meaningful only up to the detection radius. public double DetectionRadius_mm { get; set; } Property Value double DiffAttachmentBag transient object. For Internal Use. public ConcurrentBag<DiffAttachment> DiffAttachmentBag { get; } Property Value ConcurrentBag<DiffAttachment> DiffRangeColorRule Internal used. public RangeColorRule DiffRangeColorRule { get; set; } Property Value RangeColorRule DiffVisualRadius_mm Visual radius for difference visualization. public double DiffVisualRadius_mm { get; set; } Property Value double HasDiff Indicates whether there are differences between ideal and actual geometry. public bool HasDiff { get; } Property Value bool IdealGeom Delegate property for IdealGeom with cache cleanup. public IGetStl IdealGeom { get; set; } Property Value IGetStl IdealSolid Gets the drawing representing the ideal geometry faces of the workpiece. The derived solid from IdealGeom. public Solid IdealSolid { get; } Property Value Solid InitGeom Delegate property for InitGeom with runtime cleanup. public IMakeXmlSource InitGeom { get; set; } Property Value IMakeXmlSource InitSolid The derived solid from InitGeom. public Solid InitSolid { get; } Property Value Solid IsMeshedGeomInit Indicates whether the meshed geometry is initialized. public bool IsMeshedGeomInit { get; } Property Value bool Workpiece The underlying workpiece data model. public Workpiece Workpiece { get; } Property Value Workpiece WorkpieceGetter Lazy factory for the active Workpiece; invoked whenever consumers read Workpiece. public Func<Workpiece> WorkpieceGetter { get; } Property Value Func<Workpiece> Methods ClearCache() Drops the raw / ideal solid and defect display caches so the next access rebuilds from the current Workpiece. public void ClearCache() ClearDefectDisplayee() Clears all defect displayees. public void ClearDefectDisplayee() ClearIdealGeomCache() Clears the ideal geometry cache. public void ClearIdealGeomCache() ClearRawGeomCache() Clears the raw geometry cache. public void ClearRawGeomCache() Diff(double, CancellationToken, IProgress<IMessage>) Calculates the difference between ideal and actual geometry. public void Diff(double detectionRadius, CancellationToken token, IProgress<IMessage> messageProgress = null) Parameters detectionRadius double Detection radius; also saved to DetectionRadius_mm. token CancellationToken Cancellation token. messageProgress IProgress<IMessage> Progress reporting interface. Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetAnchoredCollidableNode() Gets the anchored collidable node associated with this object. public IAnchoredCollidableNode GetAnchoredCollidableNode() Returns IAnchoredCollidableNode The anchored collidable node. GetAnchoredDisplayeeList() Gets a list of anchored displayable objects. public List<IAnchoredDisplayee> GetAnchoredDisplayeeList() Returns List<IAnchoredDisplayee> A list of IAnchoredDisplayee objects GetCollidableAnchor() Gets the anchor associated with this collidable leaf. public Anchor GetCollidableAnchor() Returns Anchor The anchor for this collidable leaf. GetCollidee() Get ICollidee. public ICollidee GetCollidee() Returns ICollidee ICollidee GetOrBuildMeshedGeom(CancellationToken, IProgress<IMessage>) Returns the current meshed geometry, lazily building it from the workpiece's InitGeom (voxelize via NewWithDefectInfos(Stl, double, CancellationToken, IProgress<IMessage>), or load a CubeTreeFile) when not yet present. The first build can be slow — hence the cancellation token + progress sinks; once built, the tree is returned cheaply. public CubeTree GetOrBuildMeshedGeom(CancellationToken token, IProgress<IMessage> messageProgress = null) Parameters token CancellationToken Cancels an in-progress build (leaves the geometry unbuilt / null). messageProgress IProgress<IMessage> IMessage-channel sink (null = silent). Returns CubeTree The meshed cube tree; null when there is no workpiece / InitGeom, or the build was cancelled. ReadMeshedGeom(string, IProgress<IMessage>) Reads the meshed geometry from a file, relative to BaseDirectoryGetter. public bool ReadMeshedGeom(string relFile, IProgress<IMessage> messageProgress = null) Parameters relFile string Source file path, relative to the injected base directory. messageProgress IProgress<IMessage> IMessage-channel sink injected by the caller (null = silent). Returns bool True if the file existed and was read; false if it was not found. ResetMeshedGeom() Resets the meshed geometry. public void ResetMeshedGeom() RetireAttachments(IReadOnlyCollection<CbtrPickable>) Retires attachments OWNED BY A CALLER (e.g. ClStrip's ClStripPos) that are attached to the current meshed tree. If a tree is current it detaches them under its write-gate render barrier first; otherwise (tree already retired) it just frees them on the background chain. Targeted — never touches the base attachment or diff attachments. public void RetireAttachments(IReadOnlyCollection<CbtrPickable> attachments) Parameters attachments IReadOnlyCollection<CbtrPickable> ScanMeshedGeomInfDefect(IProgress<IMessage>, CancellationToken) Scans the meshed geometry for inf defects. public bool? ScanMeshedGeomInfDefect(IProgress<IMessage> messageProgress, CancellationToken cancellationToken) Parameters messageProgress IProgress<IMessage> cancellationToken CancellationToken Returns bool? SetMeshedGeom(CubeTree) Sets the meshed geometry instance and rebuilds its attachments. public void SetMeshedGeom(CubeTree meshedGeom_) Parameters meshedGeom_ CubeTree The meshed cube tree geometry. WriteMeshedGeom(string, CancellationToken, IProgress<IMessage>) Writes the meshed geometry to a file, relative to BaseDirectoryGetter. public void WriteMeshedGeom(string relFile, CancellationToken token, IProgress<IMessage> messageProgress = null) Parameters relFile string Target file path, relative to the injected base directory. token CancellationToken Cancellation token. messageProgress IProgress<IMessage> IMessage-channel progress sink (null = silent)."
  },
  "api/Hi.NcMech.Workpieces.html": {
    "href": "api/Hi.NcMech.Workpieces.html",
    "title": "Namespace Hi.NcMech.Workpieces | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcMech.Workpieces Classes Workpiece Workpiece configuration data model. WorkpieceEditorDisplayee Displayee for visualizing workpiece raw/ideal/meshed geometry and anchors. WorkpieceEditorDisplayeeConfig Configuration settings for workpiece editor display. WorkpieceService Runtime service for Workpiece."
  },
  "api/Hi.NcMech.Xyzabc.GeneralXyzabcMachineTool.html": {
    "href": "api/Hi.NcMech.Xyzabc.GeneralXyzabcMachineTool.html",
    "title": "Class GeneralXyzabcMachineTool | HiAPI-C# 2025",
    "summary": "Class GeneralXyzabcMachineTool Namespace Hi.NcMech.Xyzabc Assembly HiMech.dll General implementation of an XYZABC machine tool. public class GeneralXyzabcMachineTool : IXyzabcMachineTool, IDisplayee, IGetCollisionIndexPairs, IXyzabcChain, IGetXyzabcChain, IMachiningChain, IGetAsmb, IGetAnchor, IGetTopoIndex, IMakeXmlSource, IGetAnchorToSolidDictionary, IGetAnchoredDisplayeeList, IExpandToBox3d, INameNote Inheritance object GeneralXyzabcMachineTool Implements IXyzabcMachineTool IDisplayee IGetCollisionIndexPairs IXyzabcChain IGetXyzabcChain IMachiningChain IGetAsmb IGetAnchor IGetTopoIndex IMakeXmlSource IGetAnchorToSolidDictionary IGetAnchoredDisplayeeList IExpandToBox3d INameNote Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) MachiningChainUtil.GetMcCodeTransformerDictionary(IMachiningChain) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) XyzabcUtil.GenerateCollisionIndexPairs(IXyzabcChain) XyzabcUtil.GetMc(IXyzabcChain, out DVec3d) XyzabcUtil.GetMc(IXyzabcChain, out double, out double, out double, out double, out double, out double) XyzabcUtil.GetMcAbc_rad(IXyzabcChain, out Abc) XyzabcUtil.GetMcXyzabc(IXyzabcChain) XyzabcUtil.GetNp(IXyzabcChain) XyzabcUtil.GetTransformationMat4d(IXyzabcChain) XyzabcUtil.RequireEndAnchor(IXyzabcChain, IGetAnchor, string, string) XyzabcUtil.RequireEndAnchors(IXyzabcChain) XyzabcUtil.SetMc(IXyzabcChain, DVec3d) XyzabcUtil.SetMc(IXyzabcChain, Vec3d) XyzabcUtil.SetMc(IXyzabcChain, double, double, double) XyzabcUtil.SetMc(IXyzabcChain, double, double, double, double, double, double) XyzabcUtil.SetMcAbc_rad(IXyzabcChain, Vec3d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors GeneralXyzabcMachineTool(IXyzabcChain) Initializes a new instance of the GeneralXyzabcMachineTool class. public GeneralXyzabcMachineTool(IXyzabcChain xyzabcChain) Parameters xyzabcChain IXyzabcChain XYZABC chain to use. GeneralXyzabcMachineTool(string) Builds a machine tool from a compact CodeXyzabcChain axis string. public GeneralXyzabcMachineTool(string chainCode = \"[O][Z][C][w];[O][Y][X][B][S][t]\") Parameters chainCode string Bracket connectivity string consumed by CodeXyzabcChain (defaults to a common 5-axis layout). GeneralXyzabcMachineTool(string, bool) Legacy overload keeping the retired vertical/horizontal flag working. [Obsolete(\"IsVertical is a legacy orientation shim. Author the ground rotation in the GeneralMechanism instead.\")] public GeneralXyzabcMachineTool(string chainCode, bool isVertical) Parameters chainCode string Bracket connectivity string consumed by CodeXyzabcChain. isVertical bool Legacy orientation flag; false lays the machine down. GeneralXyzabcMachineTool(XElement, string, IProgress<IMessage>) Initializes a new instance of the GeneralXyzabcMachineTool class from XML. public GeneralXyzabcMachineTool(XElement src, string baseDirectory, IProgress<IMessage> progress) Parameters src XElement XML element source. baseDirectory string Base directory. progress IProgress<IMessage> Progress reporter for loading XyzabcChain and related children. Fields XName Name of XML element. public static string XName Field Value string Properties CollisionIndexPairs Collection of collision index pairs for collision detection. public HashSet<CollisionIndexPair> CollisionIndexPairs { get; } Property Value HashSet<CollisionIndexPair> EnableAutoGeneratingCollisionIndexPairsOnXmlLoaded Gets or sets whether to automatically generate collision index pairs when loaded from XML. public bool EnableAutoGeneratingCollisionIndexPairsOnXmlLoaded { get; set; } Property Value bool McCodes Gets the machine coordinate code sequence for decoding the MC array. public string[] McCodes { get; } Property Value string[] McTransformers Gets the machine coordinate transformers. public IDynamicRegular[] McTransformers { get; } Property Value IDynamicRegular[] Name Gets or sets the name of the object. public string Name { get; set; } Property Value string Note Gets or sets the descriptive note for the object. public string Note { get; set; } Property Value string TableAnchor Anchor to attach fixture or workpiece. The anchor is the same as IXyzabcChain.Hi.Numerical.Xyzabc.IXyzabcChain.GetTableBuckle. public Anchor TableAnchor { get; } Property Value Anchor ToolAnchor Anchor to attach tool. The anchor is the same as IXyzabcChain.Hi.Numerical.Xyzabc.IXyzabcChain.GetToolBuckle. public Anchor ToolAnchor { get; } Property Value Anchor XyzabcChain XYZABC chain for this machine tool. public IXyzabcChain XyzabcChain { get; } Property Value IXyzabcChain XyzabcChainFile File path for XYZABC chain. public string XyzabcChainFile { get; set; } Property Value string Methods Display(Bind) Display function called in DispEngine rendering loop. public void Display(Bind bind) Parameters bind Bind Bind with DispEngine. See Bind. ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GenerateCollisionIndexPairs() Regenerates CollisionIndexPairs from the chain topology. public void GenerateCollisionIndexPairs() GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor GetAnchorToSolidDictionary() Gets a dictionary that maps Anchor objects to their corresponding Solid objects. public Dictionary<Anchor, Solid> GetAnchorToSolidDictionary() Returns Dictionary<Anchor, Solid> A dictionary where keys are anchors and values are their associated solids. GetAnchoredDisplayeeList() Gets a list of anchored displayable objects. public List<IAnchoredDisplayee> GetAnchoredDisplayeeList() Returns List<IAnchoredDisplayee> A list of IAnchoredDisplayee objects GetAsmb() Gets the key asmb. public Asmb GetAsmb() Returns Asmb The key asmb. GetCollisionIndexPairs() Gets a collection of collision index pairs for collision detection. public IEnumerable<CollisionIndexPair> GetCollisionIndexPairs() Returns IEnumerable<CollisionIndexPair> A collection of CollisionIndexPair objects. GetMachiningChain() public IMachiningChain GetMachiningChain() Returns IMachiningChain GetMcCodeTransformerDictionary() public Dictionary<string, IDynamicRegular> GetMcCodeTransformerDictionary() Returns Dictionary<string, IDynamicRegular> GetTableBuckle() Gets the table buckle anchor point. public IGetAnchor GetTableBuckle() Returns IGetAnchor The table buckle anchor point. GetToolBuckle() Gets the tool buckle anchor point. public IGetAnchor GetToolBuckle() Returns IGetAnchor The tool buckle anchor point. GetTransformerA() Get transformer A. public DynamicRotation GetTransformerA() Returns DynamicRotation transformer A GetTransformerB() Get transformer B. public DynamicRotation GetTransformerB() Returns DynamicRotation transformer B GetTransformerC() Get transformer C. public DynamicRotation GetTransformerC() Returns DynamicRotation transformer C GetTransformerX() Get transformer X. public DynamicTranslation GetTransformerX() Returns DynamicTranslation transformer X GetTransformerY() Get transformer Y. public DynamicTranslation GetTransformerY() Returns DynamicTranslation transformer Y GetTransformerZ() Get transformer Z. public DynamicTranslation GetTransformerZ() Returns DynamicTranslation transformer Z GetXyzabcChain() Get IXyzabcChain. public IXyzabcChain GetXyzabcChain() Returns IXyzabcChain IXyzabcChain GetXyzabcMachineTool() public GeneralXyzabcMachineTool GetXyzabcMachineTool() Returns GeneralXyzabcMachineTool MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcMech.Xyzabc.IXyzabcMachineTool.html": {
    "href": "api/Hi.NcMech.Xyzabc.IXyzabcMachineTool.html",
    "title": "Interface IXyzabcMachineTool | HiAPI-C# 2025",
    "summary": "Interface IXyzabcMachineTool Namespace Hi.NcMech.Xyzabc Assembly HiMech.dll Interface for XYZABC machine tools that combines chain, display, collision and other functionalities. public interface IXyzabcMachineTool : IDisplayee, IGetCollisionIndexPairs, IXyzabcChain, IGetXyzabcChain, IMachiningChain, IGetAsmb, IGetAnchor, IGetTopoIndex, IMakeXmlSource, IGetAnchorToSolidDictionary, IGetAnchoredDisplayeeList, IExpandToBox3d, INameNote Inherited Members IDisplayee.Display(Bind) IGetCollisionIndexPairs.GetCollisionIndexPairs() IXyzabcChain.GetTransformerX() IXyzabcChain.GetTransformerY() IXyzabcChain.GetTransformerZ() IXyzabcChain.GetTransformerA() IXyzabcChain.GetTransformerB() IXyzabcChain.GetTransformerC() IXyzabcChain.GetTransformerXyz() IXyzabcChain.GetTransformerAbc() IGetXyzabcChain.GetXyzabcChain() IMachiningChain.GetTableBuckle() IMachiningChain.GetToolBuckle() IMachiningChain.McCodes IMachiningChain.McTransformers IGetAsmb.GetAsmb() IGetAnchor.GetAnchor() IMakeXmlSource.MakeXmlSource(string, string, bool) IGetAnchorToSolidDictionary.GetAnchorToSolidDictionary() IGetAnchorToSolidDictionary.PrepareAnchorSolids() IGetAnchoredDisplayeeList.GetAnchoredDisplayeeList() IExpandToBox3d.ExpandToBox3d(Box3d) INameNote.Name INameNote.Note Extension Methods DispUtil.Display(IDisplayee, Bind, Mat4d) MachiningChainUtil.GetMcCodeTransformerDictionary(IMachiningChain) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) XyzabcUtil.GenerateCollisionIndexPairs(IXyzabcChain) XyzabcUtil.GetMc(IXyzabcChain, out DVec3d) XyzabcUtil.GetMc(IXyzabcChain, out double, out double, out double, out double, out double, out double) XyzabcUtil.GetMcAbc_rad(IXyzabcChain, out Abc) XyzabcUtil.GetMcXyzabc(IXyzabcChain) XyzabcUtil.GetNp(IXyzabcChain) XyzabcUtil.GetTransformationMat4d(IXyzabcChain) XyzabcUtil.RequireEndAnchor(IXyzabcChain, IGetAnchor, string, string) XyzabcUtil.RequireEndAnchors(IXyzabcChain) XyzabcUtil.SetMc(IXyzabcChain, DVec3d) XyzabcUtil.SetMc(IXyzabcChain, Vec3d) XyzabcUtil.SetMc(IXyzabcChain, double, double, double) XyzabcUtil.SetMc(IXyzabcChain, double, double, double, double, double, double) XyzabcUtil.SetMcAbc_rad(IXyzabcChain, Vec3d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.NcMech.Xyzabc.html": {
    "href": "api/Hi.NcMech.Xyzabc.html",
    "title": "Namespace Hi.NcMech.Xyzabc | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcMech.Xyzabc Classes GeneralXyzabcMachineTool General implementation of an XYZABC machine tool. Interfaces IXyzabcMachineTool Interface for XYZABC machine tools that combines chain, display, collision and other functionalities."
  },
  "api/Hi.NcMech.html": {
    "href": "api/Hi.NcMech.html",
    "title": "Namespace Hi.NcMech | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcMech Interfaces ICollisionIndexPairsSource Interface that provides access to collision index pairs and XML serialization capabilities. Extends IGetCollisionIndexPairs with XML serialization support."
  },
  "api/Hi.NcOpt.CuttingVelocityOptLimit.html": {
    "href": "api/Hi.NcOpt.CuttingVelocityOptLimit.html",
    "title": "Class CuttingVelocityOptLimit | HiAPI-C# 2025",
    "summary": "Class CuttingVelocityOptLimit Namespace Hi.NcOpt Assembly HiMech.dll Represents optimization limits for cutting velocity parameters. public class CuttingVelocityOptLimit : ICuttingVelocityOptLimit, IMakeXmlSource, IDuplicate, IToXElement Inheritance object CuttingVelocityOptLimit Implements ICuttingVelocityOptLimit IMakeXmlSource IDuplicate IToXElement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CuttingVelocityOptLimit() Initializes a new instance of the CuttingVelocityOptLimit class. public CuttingVelocityOptLimit() CuttingVelocityOptLimit(XElement, string) Initializes a new instance of the CuttingVelocityOptLimit class from XML. public CuttingVelocityOptLimit(XElement src, string baseDirectory) Parameters src XElement The XML source element. baseDirectory string The base directory for resolving relative paths. Properties MaxCuttingVelocity_mmdmin Gets or sets the maximum cutting velocity in millimeters per minute. public double MaxCuttingVelocity_mmdmin { get; set; } Property Value double MaxCuttingVelocity_mmds Gets or sets the maximum cutting velocity in millimeters per second. public double MaxCuttingVelocity_mmds { get; set; } Property Value double MinCuttingVelocity_mmdmin Gets or sets the minimum cutting velocity in millimeters per minute. public double MinCuttingVelocity_mmdmin { get; set; } Property Value double MinCuttingVelocity_mmds Gets or sets the minimum cutting velocity in millimeters per second. public double MinCuttingVelocity_mmds { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object GetMaxCuttingVelocity_mmds() Gets the maximum cutting velocity in millimeters per second. public double GetMaxCuttingVelocity_mmds() Returns double The maximum cutting velocity in millimeters per second. GetMinCuttingVelocity_mmds() Gets the minimum cutting velocity in millimeters per second. public double GetMinCuttingVelocity_mmds() Returns double The minimum cutting velocity in millimeters per second. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.NcOpt.FixedFeedPerCycleOptLimit.html": {
    "href": "api/Hi.NcOpt.FixedFeedPerCycleOptLimit.html",
    "title": "Class FixedFeedPerCycleOptLimit | HiAPI-C# 2025",
    "summary": "Class FixedFeedPerCycleOptLimit Namespace Hi.NcOpt Assembly HiMech.dll Represents fixed feed-per-cycle optimization limits. Provides implementation for feed-per-cycle optimization with fixed minimum and maximum values. public class FixedFeedPerCycleOptLimit : IFeedPerToothOptLimit, IMakeXmlSource, IDuplicate, IClearCache, IToXElement Inheritance object FixedFeedPerCycleOptLimit Implements IFeedPerToothOptLimit IMakeXmlSource IDuplicate IClearCache IToXElement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FixedFeedPerCycleOptLimit(Func<int>, double) Initializes a new instance of the FixedFeedPerCycleOptLimit class with specified parameters. public FixedFeedPerCycleOptLimit(Func<int> fluteNumFunc, double maxFeedPerCycle_mm) Parameters fluteNumFunc Func<int> Function that returns the number of flutes maxFeedPerCycle_mm double Maximum feed per cycle in millimeters FixedFeedPerCycleOptLimit(XElement, string, MillingCutter) Ctor. public FixedFeedPerCycleOptLimit(XElement src, string baseDirectory, MillingCutter cutter) Parameters src XElement XML baseDirectory string Base directory path for resolving relative paths cutter MillingCutter The milling cutter to use for flute number calculation Properties FluteNum Gets the number of flutes. public int FluteNum { get; } Property Value int MaxFeedPerCycle_mm Gets or sets the maximum feed per cycle value in millimeters. public double MaxFeedPerCycle_mm { get; set; } Property Value double MinFeedPerCycle_mm Gets or sets the minimum feed per cycle value in millimeters. public double MinFeedPerCycle_mm { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods ClearCache() Clears any cached data held by the implementing object. public void ClearCache() Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object GetMaxFeedPerTooth_mm() Gets the maximum feed per tooth value in millimeters. By the principle of conservation, if the value is different from the NcOptOption.MaxFeedPerTooth_mm, The smaller value will be applied in the optimization process. public double GetMaxFeedPerTooth_mm() Returns double The maximum feed per tooth value in millimeters. GetMinFeedPerTooth_mm() Gets the minimum feed per tooth value in millimeters. By the principle of conservation, if the value is different from the NcOptOption.MinFeedPerTooth_mm, The larger value will be applied in the optimization process. public double GetMinFeedPerTooth_mm() Returns double The minimum feed per tooth value in millimeters. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.NcOpt.FixedFeedPerToothOptLimit.html": {
    "href": "api/Hi.NcOpt.FixedFeedPerToothOptLimit.html",
    "title": "Class FixedFeedPerToothOptLimit | HiAPI-C# 2025",
    "summary": "Class FixedFeedPerToothOptLimit Namespace Hi.NcOpt Assembly HiMech.dll Represents fixed feed-per-tooth optimization limits. Provides implementation for feed-per-tooth optimization with fixed minimum and maximum values. public class FixedFeedPerToothOptLimit : IFeedPerToothOptLimit, IMakeXmlSource, IDuplicate, IToXElement Inheritance object FixedFeedPerToothOptLimit Implements IFeedPerToothOptLimit IMakeXmlSource IDuplicate IToXElement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FixedFeedPerToothOptLimit() Ctor. public FixedFeedPerToothOptLimit() FixedFeedPerToothOptLimit(XElement, string) Initializes a new instance of the FixedFeedPerToothOptLimit class. public FixedFeedPerToothOptLimit(XElement element, string baseDirectory) Parameters element XElement The XML element containing optimization limit data. baseDirectory string The base directory for resolving relative paths. Properties MaxFeedPerTooth_mm Gets or sets the maximum feed per tooth value in millimeters. public double MaxFeedPerTooth_mm { get; set; } Property Value double MinFeedPerTooth_mm Gets or sets the minimum feed per tooth value in millimeters. public double MinFeedPerTooth_mm { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object GetMaxFeedPerTooth_mm() Gets the maximum feed per tooth value in millimeters. By the principle of conservation, if the value is different from the NcOptOption.MaxFeedPerTooth_mm, The smaller value will be applied in the optimization process. public double GetMaxFeedPerTooth_mm() Returns double The maximum feed per tooth value in millimeters. GetMinFeedPerTooth_mm() Gets the minimum feed per tooth value in millimeters. By the principle of conservation, if the value is different from the NcOptOption.MinFeedPerTooth_mm, The larger value will be applied in the optimization process. public double GetMinFeedPerTooth_mm() Returns double The minimum feed per tooth value in millimeters. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.NcOpt.ICutterOptLimitHost.html": {
    "href": "api/Hi.NcOpt.ICutterOptLimitHost.html",
    "title": "Interface ICutterOptLimitHost | HiAPI-C# 2025",
    "summary": "Interface ICutterOptLimitHost Namespace Hi.NcOpt Assembly HiMech.dll Interface for hosts that contain cutter optimization limits. Provides access to cutter optimization limit settings. public interface ICutterOptLimitHost Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties CutterOptLimit Gets or sets the cutter optimization limit settings. ICutterOptOption CutterOptLimit { get; set; } Property Value ICutterOptOption"
  },
  "api/Hi.NcOpt.ICutterOptOption.html": {
    "href": "api/Hi.NcOpt.ICutterOptOption.html",
    "title": "Interface ICutterOptOption | HiAPI-C# 2025",
    "summary": "Interface ICutterOptOption Namespace Hi.NcOpt Assembly HiMech.dll Interface for cutter optimization limits. Combines feed-per-tooth optimization capabilities with duplication and XML serialization support. Inherits from IMakeXmlSource, IFeedPerToothOptLimit, and IDuplicate. public interface ICutterOptOption : IFeedPerToothOptLimit, IMakeXmlSource, IDuplicate Inherited Members IFeedPerToothOptLimit.GetMinFeedPerTooth_mm() IFeedPerToothOptLimit.GetMaxFeedPerTooth_mm() IMakeXmlSource.MakeXmlSource(string, string, bool) IDuplicate.Duplicate(params object[]) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties EnableOpt Gets or sets whether optimization is enabled for this cutter. bool EnableOpt { get; set; } Property Value bool"
  },
  "api/Hi.NcOpt.ICuttingVelocityOptLimit.html": {
    "href": "api/Hi.NcOpt.ICuttingVelocityOptLimit.html",
    "title": "Interface ICuttingVelocityOptLimit | HiAPI-C# 2025",
    "summary": "Interface ICuttingVelocityOptLimit Namespace Hi.NcOpt Assembly HiMech.dll Interface for cutting velocity optimization limits. Defines methods to get minimum and maximum cutting velocity values. Implements IMakeXmlSource for XML serialization and IDuplicate for object duplication. public interface ICuttingVelocityOptLimit : IMakeXmlSource, IDuplicate Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) IDuplicate.Duplicate(params object[]) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetMaxCuttingVelocity_mmds() Gets the maximum cutting velocity in millimeters per second. double GetMaxCuttingVelocity_mmds() Returns double The maximum cutting velocity in millimeters per second. GetMinCuttingVelocity_mmds() Gets the minimum cutting velocity in millimeters per second. double GetMinCuttingVelocity_mmds() Returns double The minimum cutting velocity in millimeters per second."
  },
  "api/Hi.NcOpt.IFeedPerToothOptLimit.html": {
    "href": "api/Hi.NcOpt.IFeedPerToothOptLimit.html",
    "title": "Interface IFeedPerToothOptLimit | HiAPI-C# 2025",
    "summary": "Interface IFeedPerToothOptLimit Namespace Hi.NcOpt Assembly HiMech.dll Interface for feed-per-tooth optimization limits. Defines methods to get minimum and maximum feed per tooth values. Implements IMakeXmlSource for XML serialization and IDuplicate for object duplication. public interface IFeedPerToothOptLimit : IMakeXmlSource, IDuplicate Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) IDuplicate.Duplicate(params object[]) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetMaxFeedPerTooth_mm() Gets the maximum feed per tooth value in millimeters. By the principle of conservation, if the value is different from the NcOptOption.MaxFeedPerTooth_mm, The smaller value will be applied in the optimization process. double GetMaxFeedPerTooth_mm() Returns double The maximum feed per tooth value in millimeters. GetMinFeedPerTooth_mm() Gets the minimum feed per tooth value in millimeters. By the principle of conservation, if the value is different from the NcOptOption.MinFeedPerTooth_mm, The larger value will be applied in the optimization process. double GetMinFeedPerTooth_mm() Returns double The minimum feed per tooth value in millimeters."
  },
  "api/Hi.NcOpt.MillingCutterOptOption.html": {
    "href": "api/Hi.NcOpt.MillingCutterOptOption.html",
    "title": "Class MillingCutterOptOption | HiAPI-C# 2025",
    "summary": "Class MillingCutterOptOption Namespace Hi.NcOpt Assembly HiMech.dll Represents NC optimization option for milling cutters. public class MillingCutterOptOption : ICutterOptOption, IFeedPerToothOptLimit, IMakeXmlSource, IDuplicate, IClearCache, IToXElement Inheritance object MillingCutterOptOption Implements ICutterOptOption IFeedPerToothOptLimit IMakeXmlSource IDuplicate IClearCache IToXElement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MillingCutterOptOption() Ctor with null properties. public MillingCutterOptOption() MillingCutterOptOption(XElement, string, string, MillingCutter) Initializes a new instance of the MillingCutterOptOption class from XML. public MillingCutterOptOption(XElement src, string baseDirectory, string relFile, MillingCutter cutter) Parameters src XElement XML element source. baseDirectory string Base directory. relFile string Relative file path. cutter MillingCutter Milling cutter. Properties EnableLimitByMinimumUncutChipThickness Gets or sets whether to limit feedrate by minimum uncut chip thickness. It is a lower bound limit. public bool EnableLimitByMinimumUncutChipThickness { get; set; } Property Value bool EnableLimitByReliefAngle Gets or sets whether to limit feedrate by relief angle collision. It is a upper bound limit. public bool EnableLimitByReliefAngle { get; set; } Property Value bool EnableOpt Gets or sets whether optimization is enabled. public bool EnableOpt { get; set; } Property Value bool MaxFeedPerTooth_mm Gets or sets the maximum feed per tooth in millimeters. Gets the maximum feed per tooth value in millimeters. By the principle of conservation, if the value is different from the NcOptOption.MaxFeedPerTooth_mm, The smaller value will be applied in the optimization process. public double MaxFeedPerTooth_mm { get; set; } Property Value double MinFeedPerTooth_mm Gets or sets the minimum feed per tooth in millimeters. Gets the minimum feed per tooth value in millimeters. By the principle of conservation, if the value is different from the NcOptOption.MinFeedPerTooth_mm, The larger value will be applied in the optimization process. public double MinFeedPerTooth_mm { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string YieldingSafetyFactor Gets or sets the safety factor for yielding. By the principle of conservation, if the value is different from the NcOptOption.YieldingSafetyFactor, The larger value will be applied in the optimization process. public double YieldingSafetyFactor { get; set; } Property Value double YieldingUtilizationFactor Gets or sets the utilization factor for yielding. It is the reciprocal of YieldingSafetyFactor. public double YieldingUtilizationFactor { get; set; } Property Value double Methods ClearCache() Clears any cached data held by the implementing object. public void ClearCache() Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object Remarks res[0] has to be ICutter. GetMaxFeedPerTooth_mm() Gets the maximum feed per tooth value in millimeters. By the principle of conservation, if the value is different from the NcOptOption.MaxFeedPerTooth_mm, The smaller value will be applied in the optimization process. public double GetMaxFeedPerTooth_mm() Returns double The maximum feed per tooth value in millimeters. GetMinFeedPerTooth_mm() Gets the minimum feed per tooth value in millimeters. By the principle of conservation, if the value is different from the NcOptOption.MinFeedPerTooth_mm, The larger value will be applied in the optimization process. public double GetMinFeedPerTooth_mm() Returns double The minimum feed per tooth value in millimeters. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.NcOpt.NcOptOption.html": {
    "href": "api/Hi.NcOpt.NcOptOption.html",
    "title": "Class NcOptOption | HiAPI-C# 2025",
    "summary": "Class NcOptOption Namespace Hi.NcOpt Assembly HiMech.dll Represents the optimization options for NC operations. public class NcOptOption : IMakeXmlSource, IEquatable<NcOptOption>, IToXElement Inheritance object NcOptOption Implements IMakeXmlSource IEquatable<NcOptOption> IToXElement Inherited Members object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NcOptOption() Ctor. public NcOptOption() NcOptOption(NcOptOption) Copy Ctor. public NcOptOption(NcOptOption src) Parameters src NcOptOption src NcOptOption(XElement) Initializes a new instance of the NcOptOption class from XML. public NcOptOption(XElement src) Parameters src XElement The XML element containing the option data. Properties CompensationMask Internal Use Only. Gets or sets the compensation mask for axis compensation. public int CompensationMask { get; set; } Property Value int EnableDepthCompensation Gets or sets whether depth compensation is enabled. public bool EnableDepthCompensation { get; set; } Property Value bool EnableDepthSplition Enables or disables depth splitting optimization. public bool EnableDepthSplition { get; set; } Property Value bool EnableForwardCompensation Gets or sets whether forward compensation is enabled. public bool EnableForwardCompensation { get; set; } Property Value bool EnableInterpolation Enables or disables interpolation. public bool EnableInterpolation { get; set; } Property Value bool EnableOpt Enables or disables the optimization process. public bool EnableOpt { get; set; } Property Value bool EnableOptFeedrate Enables or disables feedrate optimization. public bool EnableOptFeedrate { get; set; } Property Value bool EnableSideCompensation Gets or sets whether side compensation is enabled. public bool EnableSideCompensation { get; set; } Property Value bool ExtendedPostDistance_mm Gets or sets the extended post-distance in millimeters. public double ExtendedPostDistance_mm { get; set; } Property Value double ExtendedPreDistance_mm Gets or sets the extended pre-distance in millimeters. public double ExtendedPreDistance_mm { get; set; } Property Value double FeedrateAssignmentRatio The option takes effect if EnableInterpolation is true. If the feedrate changing exceeds this ratio, the Feedrate in the NC line will be updated. public double FeedrateAssignmentRatio { get; set; } Property Value double IsPreferFuncIndexDictionaryCalled Internal Use Only. public bool IsPreferFuncIndexDictionaryCalled { get; } Property Value bool MaxAcceleration_mmds2 Gets or sets the maximum acceleration in millimeters per second squared. The typical CNC lathe or machining center has an acceleration of 0.2g (2 m/sec2). High speed machines have accelerations up to 2g (20 m/sec2). An arbitrary value 10mm/s2 is chosen for initial value. Note: 600mm/min=10mm/s. public double MaxAcceleration_mmds2 { get; set; } Property Value double MaxFeedPerTooth_mm Gets or sets the maximum feed per tooth in millimeters. By the principle of conservation, if the value is different from the IFeedPerToothOptLimit.GetMaxFeedPerTooth_mm(), The smaller value will be applied in the optimization process. public double MaxFeedPerTooth_mm { get; set; } Property Value double MaxFeedrate_mmdmin Gets or sets the maximum feedrate in millimeters per minute. public double MaxFeedrate_mmdmin { get; set; } Property Value double MaxFeedrate_mmds Gets or sets the maximum feedrate in millimeters per second. public double MaxFeedrate_mmds { get; set; } Property Value double MaxJerk_mmds3 Gets or sets the maximum jerk in millimeters per second cubed. public double MaxJerk_mmds3 { get; set; } Property Value double MaxSpindlePowerSafetyFactor Gets or sets the safety factor for spindle power. public double MaxSpindlePowerSafetyFactor { get; set; } Property Value double MaxSpindlePowerUtilizationFactor Gets or sets the utilization factor for spindle power. It is the reciprocal of MaxSpindlePowerSafetyFactor. public double MaxSpindlePowerUtilizationFactor { get; set; } Property Value double MaxSpindleTorqueSafetyFactor Gets or sets the safety factor for spindle torque. public double MaxSpindleTorqueSafetyFactor { get; set; } Property Value double MaxSpindleTorqueUtilizationFactor Gets or sets the utilization factor for spindle torque. It is the reciprocal of MaxSpindleTorqueSafetyFactor. public double MaxSpindleTorqueUtilizationFactor { get; set; } Property Value double MinFeedPerTooth_mm Gets or sets the minimum feed per tooth in millimeters. By the principle of conservation, if the value is different from the IFeedPerToothOptLimit.GetMinFeedPerTooth_mm(), The larger value will be applied in the optimization process. public double MinFeedPerTooth_mm { get; set; } Property Value double MinFeedrate_mmdmin Gets or sets the minimum feedrate in millimeters per minute. public double MinFeedrate_mmdmin { get; set; } Property Value double MinFeedrate_mmds Gets or sets the minimum feedrate in millimeters per second. The principle of conversation is applied for feedrate setting (MinFeedrate_mmds and MaxFeedrate_mmds) and feed per tooth setting (MinFeedPerTooth_mm and MaxFeedPerTooth_mm). If feed per tooth setting is not in the range of feedrate setting, The feedrate setting takes priority. public double MinFeedrate_mmds { get; set; } Property Value double OmitLeadingZero Spells a rewritten value below one as .348 instead of the default 0.348. public bool OmitLeadingZero { get; set; } Property Value bool Remarks A text-diff concern, not a numeric one: an external post that compares the optimized program against its source as text reports a change on every word below one when the two spell it differently, even though the value is identical. It lives on the project's option rather than on a machine-level preference so the same .hincproj produces the same bytes on every machine — a reproducibility property worth more than per-site convenience when a diff has to be traced. Applied to Hi.NcParsers.NcWriteback.NcPatchUtil.OmitLeadingZero on every output pass from the option in force at the first step; the default keeps the frozen HardNc convention the Soft-vs-Hard byte parity gates assume. PreferedForce_N Gets or sets the preferred force in Newtons. public double PreferedForce_N { get; set; } Property Value double RapidFeed_mmdmin Gets or sets the rapid feed rate in millimeters per minute. public double RapidFeed_mmdmin { get; set; } Property Value double RapidFeed_mmds Gets or sets the rapid feed rate in millimeters per second. public double RapidFeed_mmds { get; set; } Property Value double ThermalYieldSafetyFactor Gets or sets the safety factor for cutter thermal yield. public double ThermalYieldSafetyFactor { get; set; } Property Value double ThermalYieldUtilizationFactor Gets or sets the safety bound for cutter thermal yield. It is the reciprocal of ThermalYieldSafetyFactor. public double ThermalYieldUtilizationFactor { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string YieldingSafetyFactor Gets or sets the safety factor for yielding. By the principle of conservation, if the value is different from the MillingCutterOptOption.YieldingSafetyFactor, The larger value will be applied in the optimization process. public double YieldingSafetyFactor { get; set; } Property Value double YieldingUtilizationFactor Gets or sets the utilization factor for yielding. It is the reciprocal of YieldingSafetyFactor. public double YieldingUtilizationFactor { get; set; } Property Value double Methods CallPreferFuncIndexDictionary() Calls and returns the prefer function index dictionary, initializing it if it is null. public Dictionary<Func<MillingPhysicsBrief, double>, double> CallPreferFuncIndexDictionary() Returns Dictionary<Func<MillingPhysicsBrief, double>, double> The prefer function index dictionary. Duplicate() Creates a new instance of NcOptOption by duplicating the current instance. public NcOptOption Duplicate() Returns NcOptOption A new NcOptOption instance with the same values as the current instance. Equals(NcOptOption) Indicates whether the current object is equal to another object of the same type. public bool Equals(NcOptOption other) Parameters other NcOptOption An object to compare with this object. Returns bool true if the current object is equal to the other parameter; otherwise, false. Equals(object) Determines whether the specified object is equal to the current object. public override bool Equals(object obj) Parameters obj object The object to compare with the current object. Returns bool true if the specified object is equal to the current object; otherwise, false. GetHashCode() Serves as the default hash function. public override int GetHashCode() Returns int A hash code for the current object. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.NcOpt.NcOptimizationEmbeddedLogMode.html": {
    "href": "api/Hi.NcOpt.NcOptimizationEmbeddedLogMode.html",
    "title": "Enum NcOptimizationEmbeddedLogMode | HiAPI-C# 2025",
    "summary": "Enum NcOptimizationEmbeddedLogMode Namespace Hi.NcOpt Assembly HiNc.dll Embedded log mode for NC optimization. public enum NcOptimizationEmbeddedLogMode Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields FullLog = 2 All the lines are added the log of StepIndex and LineNo. None = 0 No embedded logging. SimpleLog = 1 Only the re-interpolated lines are added the log of StepIndex. The last re-interpolated line from each original line are added the log of LineNo."
  },
  "api/Hi.NcOpt.ShapeBasedCutterOptLimit.html": {
    "href": "api/Hi.NcOpt.ShapeBasedCutterOptLimit.html",
    "title": "Class ShapeBasedCutterOptLimit | HiAPI-C# 2025",
    "summary": "Class ShapeBasedCutterOptLimit Namespace Hi.NcOpt Assembly HiMech.dll Represents optimization limits based on cutter shape parameters. public class ShapeBasedCutterOptLimit : IFeedPerToothOptLimit, IMakeXmlSource, IDuplicate, IClearCache Inheritance object ShapeBasedCutterOptLimit Implements IFeedPerToothOptLimit IMakeXmlSource IDuplicate IClearCache Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ShapeBasedCutterOptLimit(MillingCutter) Initializes a new instance of the ShapeBasedCutterOptLimit class. public ShapeBasedCutterOptLimit(MillingCutter cutter) Parameters cutter MillingCutter The milling cutter. ShapeBasedCutterOptLimit(Func<int>, Func<double>, Func<double>) Initializes a new instance of the ShapeBasedCutterOptLimit class. public ShapeBasedCutterOptLimit(Func<int> fluteNumFunc, Func<double> radiusFunc_mm, Func<double> radialReliefAngleFunc_rad) Parameters fluteNumFunc Func<int> Function to get the number of flutes radiusFunc_mm Func<double> Function to get the radius in millimeters radialReliefAngleFunc_rad Func<double> Function to get the radial relief angle in radians ShapeBasedCutterOptLimit(XElement, string, MillingCutter) Ctor. public ShapeBasedCutterOptLimit(XElement src, string baseDirectory, MillingCutter cutter) Parameters src XElement XML baseDirectory string Base directory path for resolving relative paths cutter MillingCutter The milling cutter to use for calculations Properties FluteNum Gets the number of flutes. public int FluteNum { get; } Property Value int FluteNumFunc Gets or sets the function to get the number of flutes. public Func<int> FluteNumFunc { get; set; } Property Value Func<int> MinFeedPerTooth_mm Gets or sets the minimum feed per tooth in millimeters. public double MinFeedPerTooth_mm { get; set; } Property Value double RadialReliefAngleFunc_rad Gets or sets the function to get the radial relief angle in radians. public Func<double> RadialReliefAngleFunc_rad { get; set; } Property Value Func<double> RadialReliefAngle_rad Gets or sets the radial relief angle in radians. public double RadialReliefAngle_rad { get; } Property Value double RadiusFunc_mm Gets or sets the function to get the radius in millimeters. public Func<double> RadiusFunc_mm { get; set; } Property Value Func<double> Radius_mm Gets or sets the radius in millimeters. public double Radius_mm { get; } Property Value double SafetyFactor Gets or sets the safety factor. public double SafetyFactor { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods ClearCache() Clears any cached data held by the implementing object. public void ClearCache() Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object GetMaxFeedPerTooth_mm() Gets the maximum feed per tooth value in millimeters. By the principle of conservation, if the value is different from the NcOptOption.MaxFeedPerTooth_mm, The smaller value will be applied in the optimization process. public double GetMaxFeedPerTooth_mm() Returns double The maximum feed per tooth value in millimeters. GetMinFeedPerTooth_mm() Gets the minimum feed per tooth value in millimeters. By the principle of conservation, if the value is different from the NcOptOption.MinFeedPerTooth_mm, The larger value will be applied in the optimization process. public double GetMinFeedPerTooth_mm() Returns double The minimum feed per tooth value in millimeters. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcOpt.html": {
    "href": "api/Hi.NcOpt.html",
    "title": "Namespace Hi.NcOpt | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcOpt Classes CuttingVelocityOptLimit Represents optimization limits for cutting velocity parameters. FixedFeedPerCycleOptLimit Represents fixed feed-per-cycle optimization limits. Provides implementation for feed-per-cycle optimization with fixed minimum and maximum values. FixedFeedPerToothOptLimit Represents fixed feed-per-tooth optimization limits. Provides implementation for feed-per-tooth optimization with fixed minimum and maximum values. MillingCutterOptOption Represents NC optimization option for milling cutters. NcOptOption Represents the optimization options for NC operations. ShapeBasedCutterOptLimit Represents optimization limits based on cutter shape parameters. Interfaces ICutterOptLimitHost Interface for hosts that contain cutter optimization limits. Provides access to cutter optimization limit settings. ICutterOptOption Interface for cutter optimization limits. Combines feed-per-tooth optimization capabilities with duplication and XML serialization support. Inherits from IMakeXmlSource, IFeedPerToothOptLimit, and IDuplicate. ICuttingVelocityOptLimit Interface for cutting velocity optimization limits. Defines methods to get minimum and maximum cutting velocity values. Implements IMakeXmlSource for XML serialization and IDuplicate for object duplication. IFeedPerToothOptLimit Interface for feed-per-tooth optimization limits. Defines methods to get minimum and maximum feed per tooth values. Implements IMakeXmlSource for XML serialization and IDuplicate for object duplication. Enums NcOptimizationEmbeddedLogMode Embedded log mode for NC optimization."
  },
  "api/Hi.NcParsers.ControllerPresetWriter.html": {
    "href": "api/Hi.NcParsers.ControllerPresetWriter.html",
    "title": "Class ControllerPresetWriter | HiAPI-C# 2025",
    "summary": "Class ControllerPresetWriter Namespace Hi.NcParsers Assembly HiMech.dll Writes the built-in brand controller presets out as standalone SoftNcRunner resource files. A controller resource file is one serialized SoftNcRunner — the whole pipeline (dependencies, segmenter, initializers, syntaxes, semantics) that decides how a brand's NC code is interpreted. The shipped copies live under Resource/Controller/ so the Object Management Load browser starts populated; they are regenerable snapshots, not the source of truth — the brand properties on SoftNcRunner are. Writing needs no XFactory registration. Reading a file back does: call Reg(XFactory) first, otherwise XFactory.GenListSkippingUnloadable drops every unregistered pipeline entry and hands back a silently hollow runner. public static class ControllerPresetWriter Inheritance object ControllerPresetWriter Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields FileExtension Canonical extension of a serialized SoftNcRunner — named after the controller it describes rather than the class that implements it. The Controller tree's Object Management menu filters on it, so a file written here is visible in its Load browser; the older .SoftNcRunner extension stays loadable there for assets already saved under it. public const string FileExtension = \".Controller\" Field Value string ResourceCategoryFolder Resource category folder the presets are shipped under, relative to the resource root (i.e. Resource/Controller). public const string ResourceCategoryFolder = \"Controller\" Field Value string Properties BrandNames Brand tokens CreateBrandPreset(string) understands, in the order WriteAllBrandPresetFiles(string) writes them. public static IReadOnlyList<string> BrandNames { get; } Property Value IReadOnlyList<string> Methods CreateBrandPreset(string) Gets a fresh brand preset runner, or null when brand is not one of BrandNames. public static SoftNcRunner CreateBrandPreset(string brand) Parameters brand string One of the CncBrandDependency brand tokens. Returns SoftNcRunner Remarks Each brand property builds a new instance per read, so the returned runner is safe to mutate before writing. GetBrandPresetFileName(string) Builds the file name a brand preset is shipped under, e.g. Fanuc.default.Controller — the ResourceDefaultMarker token declares the file system-owned, so the resource seeder may refresh it on version updates. The runner carries no name of its own, so the file name is the only identity a resource browser can show. public static string GetBrandPresetFileName(string brand) Parameters brand string One of the CncBrandDependency brand tokens. Returns string WriteAllBrandPresetFiles(string) Writes every brand preset in BrandNames into targetDirectory and returns the written file paths. public static IReadOnlyList<string> WriteAllBrandPresetFiles(string targetDirectory) Parameters targetDirectory string Directory to write into, e.g. an absolute path ending in Resource/Controller. Returns IReadOnlyList<string> WriteBrandPresetFile(string, string) Writes one brand preset into targetDirectory and returns the written file path. Missing directories are created. public static string WriteBrandPresetFile(string brand, string targetDirectory) Parameters brand string One of the CncBrandDependency brand tokens. targetDirectory string Directory to write into, e.g. an absolute path ending in Resource/Controller. Returns string Exceptions ArgumentException brand is not a known brand. ArgumentNullException targetDirectory is null or blank."
  },
  "api/Hi.NcParsers.Dependencys.AxisType.html": {
    "href": "api/Hi.NcParsers.Dependencys.AxisType.html",
    "title": "Enum AxisType | HiAPI-C# 2025",
    "summary": "Enum AxisType Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll Axis type: linear (translation), rotary (rotation), or spindle (speed/positioning dual mode). public enum AxisType Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Linear = 0 Translation axis (X, Y, Z, U, V, W). Rotary = 1 Rotation axis (A, B, C). Spindle = 2 Spindle axis — can switch between speed mode (S command) and positioning mode (C axis). Common in mill-turn machines. Siemens MD30300, Okuma OSP."
  },
  "api/Hi.NcParsers.Dependencys.CncBrandDependency.html": {
    "href": "api/Hi.NcParsers.Dependencys.CncBrandDependency.html",
    "title": "Class CncBrandDependency | HiAPI-C# 2025",
    "summary": "Class CncBrandDependency Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll Explicit CNC controller brand identifier carried in PipelineNcDependencyList. Use ncDependencyList.OfType<CncBrandDependency>().FirstOrDefault() to retrieve the brand. public class CncBrandDependency : INcDependency, IMakeXmlSource Inheritance object CncBrandDependency Implements INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CncBrandDependency(string) Creates a dependency with the given brand string. public CncBrandDependency(string brand) Parameters brand string Controller brand name (often one of the public const tokens on this type). CncBrandDependency(XElement) Deserializes brand from XML. public CncBrandDependency(XElement src) Parameters src XElement Root element named XName. Fields Fanuc Brand token used when the controller is Fanuc. public const string Fanuc = \"Fanuc\" Field Value string Heidenhain Brand token used when the controller is Heidenhain. public const string Heidenhain = \"Heidenhain\" Field Value string Mazak Brand token used when the controller is Mazak. public const string Mazak = \"Mazak\" Field Value string Siemens Brand token used when the controller is Siemens. public const string Siemens = \"Siemens\" Field Value string Syntec Brand token used when the controller is Syntec. public const string Syntec = \"Syntec\" Field Value string Properties Brand CNC controller brand name (e.g., “Fanuc”, “Siemens”). public string Brand { get; set; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.ControllerParameterTableBase.html": {
    "href": "api/Hi.NcParsers.Dependencys.ControllerParameterTableBase.html",
    "title": "Class ControllerParameterTableBase | HiAPI-C# 2025",
    "summary": "Class ControllerParameterTableBase Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll Base class for brand-specific controller parameter tables. Provides shared data structures, XML IO, and IHomeMcConfig IMachineAxisConfig implementations. Subclasses define brand-specific parameter numbers, XML attribute names, and derived convenience properties. public abstract class ControllerParameterTableBase : IHomeMcConfig, IMachineAxisConfig, IRapidFeedrateConfig, IStrokeLimitConfig, ISpindleControlConfig, IMCodeDeclarationConfig, IToolChangeTriggerConfig, INcDependency, IMakeXmlSource Inheritance object ControllerParameterTableBase Implements IHomeMcConfig IMachineAxisConfig IRapidFeedrateConfig IStrokeLimitConfig ISpindleControlConfig IMCodeDeclarationConfig IToolChangeTriggerConfig INcDependency IMakeXmlSource Derived FanucParameterTable HeidenhainParameterTable SiemensMachineDataTable SyntecParameterTable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties AxisNames Gets the configured axis names in order. public IEnumerable<string> AxisNames { get; } Property Value IEnumerable<string> AxisParams Per-axis float parameters. Outer key = parameter number, inner key = axis name. public Dictionary<int, Dictionary<string, double>> AxisParams { get; set; } Property Value Dictionary<int, Dictionary<string, double>> AxisTypeParamId Parameter/MD/MP number for axis type (linear/rotary/spindle). protected abstract int AxisTypeParamId { get; } Property Value int EffectiveMCodeDeclarations The declaration view the consumers resolve against (IMCodeDeclarationConfig and TryGetMCodeEffects(string, out MCodeEffects)/TryResolveDirection(string, out SpindleDirection)). Defaults to MCodeDeclarations verbatim; a brand subclass overrides it to overlay declarations mandated by its own machine data (e.g. the Siemens MD22560 tool-change M function) without writing them into the stored dictionary — the stored declarations, XML, and clones stay derivation-free and the overlay re-derives on every read. protected virtual IReadOnlyDictionary<string, MCodeEffects> EffectiveMCodeDeclarations { get; } Property Value IReadOnlyDictionary<string, MCodeEffects> IdAttributeName XML attribute name for the parameter ID (“ParamId”, “MdId”, “MpId”). protected abstract string IdAttributeName { get; } Property Value string IntAxisParams Per-axis integer parameters. Outer key = parameter number, inner key = axis name. public Dictionary<int, Dictionary<string, int>> IntAxisParams { get; set; } Property Value Dictionary<int, Dictionary<string, int>> MCodeDeclarations Declared machine M-codes and their effects — the single storage behind both IMCodeDeclarationConfig and the narrower ISpindleControlConfig face, so one code is never half-recognized by two separate maps. Key = M-code as parsed (e.g., “M13”), case-insensitive. Serialized as <MCode> elements (spindle-direction-only entries keep the legacy <SpindleMCode> element for older readers). public Dictionary<string, MCodeEffects> MCodeDeclarations { get; set; } Property Value Dictionary<string, MCodeEffects> RapidRateParamId Parameter/MD/MP number for rapid traverse rate per axis. Null if not defined for this controller brand. protected virtual int? RapidRateParamId { get; } Property Value int? ReferencePositionParamId Parameter/MD/MP number for reference position (G28 home). protected abstract int ReferencePositionParamId { get; } Property Value int SpindleDirectionCodes Spindle-direction view over MCodeDeclarations: every declared code that carries a SpindleDirection. See ISpindleControlConfig. public IReadOnlyDictionary<string, SpindleDirection> SpindleDirectionCodes { get; } Property Value IReadOnlyDictionary<string, SpindleDirection> StrokeLimitNegParamId Parameter/MD/MP number for negative stroke limit per axis. Null if not defined for this controller brand. protected virtual int? StrokeLimitNegParamId { get; } Property Value int? StrokeLimitPosParamId Parameter/MD/MP number for positive stroke limit per axis. Null if not defined for this controller brand. protected virtual int? StrokeLimitPosParamId { get; } Property Value int? SystemParams System-wide parameters. Key = parameter number. public Dictionary<int, double> SystemParams { get; set; } Property Value Dictionary<int, double> ToolWordTriggersChange When true, a T word performs the tool change by itself (turret/lathe semantics — Siemens MD22550 $MC_TOOL_CHANGE_MODE = 0). Default false: T only pre-selects; the trigger M-code changes the tool. See IToolChangeTriggerConfig. Virtual so a brand subclass can defer to its own machine data when that carries the same semantics (the Siemens table consults MD22550 when present). public virtual bool ToolWordTriggersChange { get; set; } Property Value bool Methods AxisParam(int) Returns the per-axis float bucket for paramId, creating it if absent. See AxisParams. public Dictionary<string, double> AxisParam(int paramId) Parameters paramId int Brand-specific parameter/MD/MP number. Returns Dictionary<string, double> ConfigureRotaryAxis(string, double, double) Configures a rotary axis with home position and rapid rate. Sets axis type to Rotary, home position via SetHomePosition(string, double), and per-axis rapid rate (if RapidRateParamId is defined for this brand). Use RemoveAxis(string) to remove the axis entirely. public void ConfigureRotaryAxis(string axisName, double homePosition_deg = 0, double rapidRate_degdmin = 36000) Parameters axisName string Axis name (e.g., “A”, “B”, “C”). homePosition_deg double Home position in degrees (default 0). rapidRate_degdmin double Rapid traverse rate in deg/min (default 36000). ConfigureSpindleDirectionCode(string, SpindleDirection) Adds or updates a custom spindle direction M-code. public void ConfigureSpindleDirectionCode(string mCode, SpindleDirection direction) Parameters mCode string direction SpindleDirection CopyParamsTo(ControllerParameterTableBase) Deep-copies this table's SystemParams, AxisParams, IntAxisParams, MCodeDeclarations, and ToolWordTriggersChange into target, replacing the target's dictionaries with independent copies (outer and inner buckets; declaration entries cloned). Subclasses expose a typed DeepClone that constructs the concrete table and calls this. Used by the parameter-table proxies to clone their fixed machine-config seed into a host that has no table yet. protected void CopyParamsTo(ControllerParameterTableBase target) Parameters target ControllerParameterTableBase The table to overwrite with deep copies of this table's parameters. DeclareMCode(string, MCodeEffects) Adds or replaces the declaration for an M-code. The effects are copied on store, so the caller may reuse or further mutate its instance without coupling declarations to each other. public void DeclareMCode(string mCode, MCodeEffects effects) Parameters mCode string effects MCodeEffects DescribeAxisParam(int) Per-axis double counterpart of DescribeSystemParam(int). Covers the role ids the base class consumes (reference position, rapid rate, stroke limits); brand subclasses may override for their own vocabulary or extra numbers. public virtual string DescribeAxisParam(int paramId) Parameters paramId int Brand-specific parameter/MD/MP number. Returns string DescribeIntAxisParam(int) Per-axis integer counterpart of DescribeSystemParam(int). Covers the axis-type id the base class consumes. public virtual string DescribeIntAxisParam(int paramId) Parameters paramId int Brand-specific parameter/MD/MP number. Returns string DescribeSystemParam(int) Short usage label for a well-known system parameter id, or null when the id has no modeled meaning (a raw pass-through row). Brand subclasses extend this with their own well-known numbers; the native parameter UI shows the label next to the raw id so an operator can tell the modeled parameters from free extras. public virtual string DescribeSystemParam(int paramId) Parameters paramId int Brand-specific parameter/MD/MP number. Returns string GetHomePosition(string) Gets the home position for a specific axis. Returns null if the axis has no home position configured. public double? GetHomePosition(string axisName) Parameters axisName string Returns double? GetLinearAxisRapidRate_mmdmin(string) Gets rapid traverse feedrate for a linear axis in mm/min. Returns a default value if the axis is not configured. public double GetLinearAxisRapidRate_mmdmin(string axisName) Parameters axisName string Returns double GetNegativeLimit(string) Gets the negative stroke limit for a specific axis. Unit is mm for linear axes, deg for rotary axes. Returns null if not configured (no limit). public double? GetNegativeLimit(string axisName) Parameters axisName string Returns double? GetPositiveLimit(string) Gets the positive stroke limit for a specific axis. Unit is mm for linear axes, deg for rotary axes. Returns null if not configured (no limit). public double? GetPositiveLimit(string axisName) Parameters axisName string Returns double? GetRotaryAxisRapidRate_degdmin(string) Gets rapid traverse feedrate for a rotary axis in deg/min. Returns a default value if the axis is not configured. public double GetRotaryAxisRapidRate_degdmin(string axisName) Parameters axisName string Returns double IntAxisParam(int) Returns the per-axis integer bucket for paramId, creating it if absent. See IntAxisParams. public Dictionary<string, int> IntAxisParam(int paramId) Parameters paramId int Brand-specific parameter/MD/MP number. Returns Dictionary<string, int> IsRotaryAxis(string) Returns true if the axis is rotary or spindle, false if linear. public bool IsRotaryAxis(string axisName) Parameters axisName string Returns bool MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public abstract XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. ReadXml(XElement) Populates SystemParams, AxisParams, and IntAxisParams from src using the brand-specific IdAttributeName. protected void ReadXml(XElement src) Parameters src XElement XML element produced by WriteXml(string). RemoveAxis(string) Removes an axis from the configuration. public void RemoveAxis(string axisName) Parameters axisName string RemoveMCodeDeclaration(string) Removes the declaration for an M-code. public void RemoveMCodeDeclaration(string mCode) Parameters mCode string RemoveSpindleDirectionCode(string) Removes a custom spindle direction M-code. public void RemoveSpindleDirectionCode(string mCode) Parameters mCode string SetAxis(string, AxisType) Adds or updates an axis with the specified type. public void SetAxis(string axisName, AxisType type) Parameters axisName string type AxisType SetHomePosition(string, double) Sets the home position for a specific axis. public void SetHomePosition(string axisName, double value) Parameters axisName string value double SetLinearAxisRapidRate_mmdmin(string, double) Sets rapid traverse feedrate for a linear axis in mm/min. public void SetLinearAxisRapidRate_mmdmin(string axisName, double value) Parameters axisName string value double SetNegativeLimit(string, double) Sets the negative stroke limit for a specific axis. Unit is mm for linear axes, deg for rotary axes. public void SetNegativeLimit(string axisName, double value) Parameters axisName string value double SetPositiveLimit(string, double) Sets the positive stroke limit for a specific axis. Unit is mm for linear axes, deg for rotary axes. public void SetPositiveLimit(string axisName, double value) Parameters axisName string value double SetRotaryAxisRapidRate_degdmin(string, double) Sets rapid traverse feedrate for a rotary axis in deg/min. public void SetRotaryAxisRapidRate_degdmin(string axisName, double value) Parameters axisName string value double TryGetMCodeEffects(string, out MCodeEffects) Resolves a parsed flag to its declared effects. Returns false for undeclared codes — ISO defaults are the consumers' concern, not this config's. The returned instance is the live declaration: treat it as read-only and reconfigure through DeclareMCode(string, MCodeEffects) instead of mutating it. public bool TryGetMCodeEffects(string mCode, out MCodeEffects effects) Parameters mCode string effects MCodeEffects Returns bool TryResolveDirection(string, out SpindleDirection) Resolves a parsed flag to a spindle direction. Returns true only for configured custom codes whose declaration carries no other effect — the caller consumes the whole flag for this one meaning, so a composite declaration (e.g. spindle + coolant) must instead be expanded by MCodeExpansionSyntax to keep its other halves alive. ISO M03/M04/M05 defaults are the caller's fallback, not this config's concern. public bool TryResolveDirection(string mCode, out SpindleDirection direction) Parameters mCode string direction SpindleDirection Returns bool WriteXml(string) Serializes SystemParams, AxisParams, and IntAxisParams into a new XElement. Inverse of ReadXml(XElement). protected XElement WriteXml(string xName) Parameters xName string Element name for the produced XML element. Returns XElement"
  },
  "api/Hi.NcParsers.Dependencys.Fanuc.CutterCompensationType.html": {
    "href": "api/Hi.NcParsers.Dependencys.Fanuc.CutterCompensationType.html",
    "title": "Enum CutterCompensationType | HiAPI-C# 2025",
    "summary": "Enum CutterCompensationType Namespace Hi.NcParsers.Dependencys.Fanuc Assembly HiMech.dll Fanuc #5003: Cutter compensation startup/cancellation type. public enum CutterCompensationType Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields TypeA = 0 Type A: compensation vector perpendicular to the block next to startup/cancellation. TypeB = 1 Type B: compensation vector perpendicular to startup/cancellation block + intersection vector. TypeC = 2 Type C: when startup/cancellation block has no movement, shift perpendicular to the adjacent block."
  },
  "api/Hi.NcParsers.Dependencys.Fanuc.FanucGotoIterationDependency.html": {
    "href": "api/Hi.NcParsers.Dependencys.Fanuc.FanucGotoIterationDependency.html",
    "title": "Class FanucGotoIterationDependency | HiAPI-C# 2025",
    "summary": "Class FanucGotoIterationDependency Namespace Hi.NcParsers.Dependencys.Fanuc Assembly HiMech.dll Watchdog for Fanuc Custom Macro B GOTO loops. Holds a MaxIterationsPerTarget limit (XML-persisted user config — the soft cap above which the upcoming FanucGotoSyntax stops firing and emits a warning) plus a runtime per-target hit counter (CountByTarget — not serialised, cleared at session start by the ISessionResettable sweep in RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken)). The dependency is syntax-managed: FanucGotoSyntax reads the limit, increments the counter, and decides whether to fire. There is no host Func provider — the dep is placed in Hi.NcParsers.Dependencys.Fanuc rather than Hi.NcParsers.Dependencys.SystemWired because nothing outside the syntax pipeline writes it; OnSessionReset() is the session-init hook the runner invokes through ISessionResettable, not a host-wired Func. The counter key is (FileName, TargetN) where FileName is the source-level file path of the block containing the GOTO (the relative path form carried on FilePath — same form used by IndexedFileLine labels). Source-level keying means multiple inline invocations of the same subprogram pool their counts (they ARE the same source-code GOTO), while two different files with their own N100 stay isolated (they ARE different jumps). Default MaxIterationsPerTarget is 1000 — a runaway-loop guard, not a precise iteration budget. Legitimate macro loops (multi-hole drill matrices, calibration sweeps) sit well below this; truly infinite loops hit the limit fast. Projects with batch-style macros that legitimately need higher counts can raise the value in the project XML. public class FanucGotoIterationDependency : INcDependency, IMakeXmlSource, ISessionResettable Inheritance object FanucGotoIterationDependency Implements INcDependency IMakeXmlSource ISessionResettable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FanucGotoIterationDependency() Initializes a new instance with the default limit and an empty counter. public FanucGotoIterationDependency() FanucGotoIterationDependency(XElement) Loads MaxIterationsPerTarget from XML produced by MakeXmlSource(string, string, bool); absent element falls back to DefaultMaxIterationsPerTarget. public FanucGotoIterationDependency(XElement src) Parameters src XElement Root element named XName. Fields DefaultMaxIterationsPerTarget Default for MaxIterationsPerTarget. Sized as a runaway-loop guard: legitimate Fanuc macros (drill grids, calibration sweeps) stay well below, while truly unbounded loops hit it fast. public const int DefaultMaxIterationsPerTarget = 1000 Field Value int Properties CountByTarget Per-target hit counter keyed by (FileName, TargetN). Runtime-only; not serialised. Cleared by OnSessionReset() on the session-init edge so a brand-preset runner reused across sessions does not leak counts. public Dictionary<(string FileName, int TargetN), int> CountByTarget { get; } Property Value Dictionary<(string FileName, int TargetN), int> MaxIterationsPerTarget Soft cap on consecutive fires of any single GOTO target within one source file (see CountByTarget for the keying). Above this, the consuming syntax should emit a warning and suppress the redirect on the over-limit block; subsequent blocks flow through naturally. public int MaxIterationsPerTarget { get; set; } Property Value int XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. OnSessionReset() Clears CountByTarget; leaves MaxIterationsPerTarget untouched. public void OnSessionReset() Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.Fanuc.FanucParameterTable.html": {
    "href": "api/Hi.NcParsers.Dependencys.Fanuc.FanucParameterTable.html",
    "title": "Class FanucParameterTable | HiAPI-C# 2025",
    "summary": "Class FanucParameterTable Namespace Hi.NcParsers.Dependencys.Fanuc Assembly HiMech.dll Fanuc controller parameter table. Stores system parameters (single value) and axis parameters (per-axis value) following real Fanuc parameter numbering. public class FanucParameterTable : ControllerParameterTableBase, IHomeMcConfig, IMachineAxisConfig, IRapidFeedrateConfig, IStrokeLimitConfig, ISpindleControlConfig, IMCodeDeclarationConfig, IToolChangeTriggerConfig, ICannedCycleConfig, IIsoCoordinateConfig, INcDependency, IMakeXmlSource, IVariableLookup Inheritance object ControllerParameterTableBase FanucParameterTable Implements IHomeMcConfig IMachineAxisConfig IRapidFeedrateConfig IStrokeLimitConfig ISpindleControlConfig IMCodeDeclarationConfig IToolChangeTriggerConfig ICannedCycleConfig IIsoCoordinateConfig INcDependency IMakeXmlSource IVariableLookup Inherited Members ControllerParameterTableBase.GetLinearAxisRapidRate_mmdmin(string) ControllerParameterTableBase.GetRotaryAxisRapidRate_degdmin(string) ControllerParameterTableBase.SetLinearAxisRapidRate_mmdmin(string, double) ControllerParameterTableBase.SetRotaryAxisRapidRate_degdmin(string, double) ControllerParameterTableBase.GetPositiveLimit(string) ControllerParameterTableBase.GetNegativeLimit(string) ControllerParameterTableBase.SetPositiveLimit(string, double) ControllerParameterTableBase.SetNegativeLimit(string, double) ControllerParameterTableBase.DescribeIntAxisParam(int) ControllerParameterTableBase.SystemParams ControllerParameterTableBase.AxisParams ControllerParameterTableBase.IntAxisParams ControllerParameterTableBase.AxisParam(int) ControllerParameterTableBase.IntAxisParam(int) ControllerParameterTableBase.GetHomePosition(string) ControllerParameterTableBase.SetHomePosition(string, double) ControllerParameterTableBase.AxisNames ControllerParameterTableBase.IsRotaryAxis(string) ControllerParameterTableBase.SetAxis(string, AxisType) ControllerParameterTableBase.RemoveAxis(string) ControllerParameterTableBase.ConfigureRotaryAxis(string, double, double) ControllerParameterTableBase.MCodeDeclarations ControllerParameterTableBase.EffectiveMCodeDeclarations ControllerParameterTableBase.TryGetMCodeEffects(string, out MCodeEffects) ControllerParameterTableBase.DeclareMCode(string, MCodeEffects) ControllerParameterTableBase.RemoveMCodeDeclaration(string) ControllerParameterTableBase.ToolWordTriggersChange ControllerParameterTableBase.SpindleDirectionCodes ControllerParameterTableBase.TryResolveDirection(string, out SpindleDirection) ControllerParameterTableBase.ConfigureSpindleDirectionCode(string, SpindleDirection) ControllerParameterTableBase.RemoveSpindleDirectionCode(string) ControllerParameterTableBase.ReadXml(XElement) ControllerParameterTableBase.WriteXml(string) ControllerParameterTableBase.CopyParamsTo(ControllerParameterTableBase) object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FanucParameterTable() Initializes a new instance, seeding Param1020, Param3741, Param5003, and the ISO G54-G59/G54.1 P-table coordinate offsets with their default values. public FanucParameterTable() FanucParameterTable(XElement) Initializes a new instance by deserializing from src. public FanucParameterTable(XElement src) Parameters src XElement XML element produced by MakeXmlSource(string, string, bool). Fields CoordOffsetMax Inclusive upper bound of the G54-G59 work coordinate offset address range (#5328). public const int CoordOffsetMax = 5328 Field Value int CoordOffsetMin Inclusive lower bound of the G54-G59 work coordinate offset address range (#5221). public const int CoordOffsetMin = 5221 Field Value int ExtCoordOffsetMax Inclusive upper bound of the G54.1 P-table extended offset range (#7999). public const int ExtCoordOffsetMax = 7999 Field Value int ExtCoordOffsetMin Inclusive lower bound of the G54.1 P-table extended offset range (#7001). public const int ExtCoordOffsetMin = 7001 Field Value int ParamAxisType #1006: Axis type per axis. See AxisType. public const int ParamAxisType = 1006 Field Value int ParamControlledAxes #1020: Number of controlled axes. public const int ParamControlledAxes = 1020 Field Value int ParamCutterCompType #5003: Cutter compensation startup type. See CutterCompensationType. public const int ParamCutterCompType = 5003 Field Value int ParamG54OffsetBase #5221: Base address (X) of G54 work coordinate offset. G54.Y at +1 (#5222), G54.Z at +2 (#5223). G55..G59 follow at stride 20. See IsoCoordinateAddressMap. public const int ParamG54OffsetBase = 5221 Field Value int ParamG54p1P1OffsetBase #7001: Base address (X) of G54.1 P1 extended work coordinate offset. G54.1 P2..P48 follow at stride 20. See IsoCoordinateAddressMap. public const int ParamG54p1P1OffsetBase = 7001 Field Value int ParamMaxSpindleSpeed #3741: Maximum spindle speed (RPM). public const int ParamMaxSpindleSpeed = 3741 Field Value int ParamPeckRetraction #4002: G83 peck drilling retraction distance (mm). Fanuc stores this value in mm directly in the system parameter. public const int ParamPeckRetraction = 4002 Field Value int ParamRapidRate #1420: Rapid traverse rate per axis (mm/min or deg/min). public const int ParamRapidRate = 1420 Field Value int ParamReferencePosition #1240: G28 first reference position per axis. public const int ParamReferencePosition = 1240 Field Value int ParamStrokeLimitNeg #1320: Negative stroke limit per axis (mm or deg). public const int ParamStrokeLimitNeg = 1320 Field Value int ParamStrokeLimitPos #1300: Positive stroke limit per axis (mm or deg). public const int ParamStrokeLimitPos = 1300 Field Value int Properties AxisParam1006 #1006: Axis type per axis. See AxisType. See AxisNames. See IsRotaryAxis(string). See SetAxis(string, AxisType). public Dictionary<string, int> AxisParam1006 { get; set; } Property Value Dictionary<string, int> AxisParam1240 #1240: G28 first reference position per axis. See IHomeMcConfig. See GetHomePosition(string). See SetHomePosition(string, double). public Dictionary<string, double> AxisParam1240 { get; set; } Property Value Dictionary<string, double> AxisParam1420 #1420: Rapid traverse rate per axis (mm/min or deg/min). See IRapidFeedrateConfig. public Dictionary<string, double> AxisParam1420 { get; set; } Property Value Dictionary<string, double> AxisTypeParamId Parameter/MD/MP number for axis type (linear/rotary/spindle). protected override int AxisTypeParamId { get; } Property Value int ControlledAxisCount Number of controlled axes. Delegates to Param1020. public int ControlledAxisCount { get; set; } Property Value int CoordinateIds Enumerates the G-code coordinate ids that this provider currently has data for. public IEnumerable<string> CoordinateIds { get; } Property Value IEnumerable<string> CutterCompType Cutter compensation startup type. Delegates to Param5003. public CutterCompensationType CutterCompType { get; set; } Property Value CutterCompensationType Default3Axis Default 3-axis Fanuc milling machine. public static FanucParameterTable Default3Axis { get; } Property Value FanucParameterTable IdAttributeName XML attribute name for the parameter ID (“ParamId”, “MdId”, “MpId”). protected override string IdAttributeName { get; } Property Value string MaxSpindleSpeed_rpm Maximum spindle speed in RPM. Delegates to Param3741. public double MaxSpindleSpeed_rpm { get; set; } Property Value double Param1020 #1020: Number of controlled axes. See ControlledAxisCount. public int Param1020 { get; set; } Property Value int Param3741 #3741: Maximum spindle speed (RPM). See MaxSpindleSpeed_rpm. public double Param3741 { get; set; } Property Value double Param5003 #5003: Cutter compensation startup type. See CutterCompType. public CutterCompensationType Param5003 { get; set; } Property Value CutterCompensationType PeckRetractionDistance_mm G83 peck drilling clearance distance above the previous stroke bottom before re-entering at feed (mm). public double PeckRetractionDistance_mm { get; } Property Value double RapidRateParamId Parameter/MD/MP number for rapid traverse rate per axis. Null if not defined for this controller brand. protected override int? RapidRateParamId { get; } Property Value int? ReferencePositionParamId Parameter/MD/MP number for reference position (G28 home). protected override int ReferencePositionParamId { get; } Property Value int StrokeLimitNegParamId Parameter/MD/MP number for negative stroke limit per axis. Null if not defined for this controller brand. protected override int? StrokeLimitNegParamId { get; } Property Value int? StrokeLimitPosParamId Parameter/MD/MP number for positive stroke limit per axis. Null if not defined for this controller brand. protected override int? StrokeLimitPosParamId { get; } Property Value int? XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods DeepClone() Returns an independent deep copy of this table (all three parameter dictionaries cloned). Used by FanucParameterTableProxy to clone its fixed machine-config seed into a host that has no table yet. public FanucParameterTable DeepClone() Returns FanucParameterTable DescribeAxisParam(int) Per-axis double counterpart of DescribeSystemParam(int). Covers the role ids the base class consumes (reference position, rapid rate, stroke limits); brand subclasses may override for their own vocabulary or extra numbers. public override string DescribeAxisParam(int paramId) Parameters paramId int Brand-specific parameter/MD/MP number. Returns string DescribeSystemParam(int) Short usage label for a well-known system parameter id, or null when the id has no modeled meaning (a raw pass-through row). Brand subclasses extend this with their own well-known numbers; the native parameter UI shows the label next to the raw id so an operator can tell the modeled parameters from free extras. public override string DescribeSystemParam(int paramId) Parameters paramId int Brand-specific parameter/MD/MP number. Returns string Get(string) Returns the value of the variable identified by key (e.g. \"#124\"), or null if vacant or unknown to this lookup. public double? Get(string key) Parameters key string Returns double? Remarks Routes Fanuc system-variable reads to SystemParams: #5221-#5328 (G54-G59 work coordinate offsets) and #7001-#7999 (G54.1 P1-P48 extended offsets) are returned directly by parameter address. Other ranges return null so the evaluator's lookup chain can fall through. GetCoordinateOffset(string) Gets the offset for the given G-code coordinate id. Returns null when no offset is configured for that id by this provider (callers iterate the next provider, or fall back to Zero). public Vec3d GetCoordinateOffset(string coordId) Parameters coordId string Returns Vec3d MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public override XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetCoordinateOffset(string, Vec3d) Sets the offset for the given G-code coordinate id. public void SetCoordinateOffset(string coordId, Vec3d offset) Parameters coordId string offset Vec3d"
  },
  "api/Hi.NcParsers.Dependencys.Fanuc.FanucParameterTableProxy.html": {
    "href": "api/Hi.NcParsers.Dependencys.Fanuc.FanucParameterTableProxy.html",
    "title": "Class FanucParameterTableProxy | HiAPI-C# 2025",
    "summary": "Class FanucParameterTableProxy Namespace Hi.NcParsers.Dependencys.Fanuc Assembly HiMech.dll Get-or-create INcDependencyProxy for FanucParameterTable (the Fanuc / Mazak family parameter table): a placeholder in the shared PipelineNcDependencyList that resolves the host project's own parameter table. Unlike the pure per-case proxies, the Fanuc-family parameter table mixes machine config (axis types / reference positions / rapid / stroke) with per-case work-coordinate offsets (#5221+ / #7001+), so the proxy carries a fixed machine-config Seed that is serialized into the shared runner file. On wire, the host receives a deep clone of the seed only when it has no FanucParameterTable yet; a loaded project's own full table wins. The resolved host table holds everything (machine config + per-case coordinates) and is fully serialized on the project. The proxy deliberately does not implement the machine-config interfaces (IMachineAxisConfig etc.) — every machine-config consumer must go through GetEffectiveNcDependencyList() so it sees the resolved host table, never this placeholder. public sealed class FanucParameterTableProxy : INcDependencyProxy, INcDependency, IMakeXmlSource Inheritance object FanucParameterTableProxy Implements INcDependencyProxy INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FanucParameterTableProxy(FanucParameterTable) Creates a proxy carrying seed as its machine-config seed, defaulting to Default3Axis. public FanucParameterTableProxy(FanucParameterTable seed = null) Parameters seed FanucParameterTable The machine-config seed cloned into a fresh host. Properties Seed The fixed machine-config seed deep-cloned into a host that has no FanucParameterTable yet. Carried on the shared runner and serialized into the runner file — never the per-case instance, which lives on the host (see GetNcDependency()). public FanucParameterTable Seed { get; } Property Value FanucParameterTable XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods GetNcDependency() Takes the host's FanucParameterTable (created during InitNcDependencyHost(INcDependencyListHost)). Returns null when no host is wired. public INcDependency GetNcDependency() Returns INcDependency InitNcDependencyHost(INcDependencyListHost) Wires the host and materializes the host FanucParameterTable: when the host list has none, a deep clone of Seed is installed so machine config + per-case coordinates exist and are editable before any run. GetNcDependency() is then a pure take. Idempotent — an existing host table (a loaded project's) is left untouched. public void InitNcDependencyHost(INcDependencyListHost host) Parameters host INcDependencyListHost MakeXmlSource(string, string, bool) Serializes only the machine-config Seed — the wired host and the resolved host table are runtime-only and not persisted in the shared runner. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Rehydrates the carried Seed from the nested FanucParameterTable element, falling back to Default3Axis when absent. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.Fanuc.FanucPositionVariableLookup.html": {
    "href": "api/Hi.NcParsers.Dependencys.Fanuc.FanucPositionVariableLookup.html",
    "title": "Class FanucPositionVariableLookup | HiAPI-C# 2025",
    "summary": "Class FanucPositionVariableLookup Namespace Hi.NcParsers.Dependencys.Fanuc Assembly HiMech.dll Fanuc-style position system variables read from the previous block's runtime-state JSON sections: #5001-#5003Block-end position X/Y/Z (workpiece) → previous block's ProgramXyz. #5021-#5023Current machine position X/Y/Z → previous block's MachineCoordinateState. #5041-#5043Current absolute position X/Y/Z → previous block's ProgramXyz. Stateless. Configured on RuntimeVariableLookups rather than NcDependencyList because the read needs the block node for Previous access — there is no long-lived dependency object that owns this data. public sealed class FanucPositionVariableLookup : IRuntimeVariableLookup, IMakeXmlSource Inheritance object FanucPositionVariableLookup Implements IRuntimeVariableLookup IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FanucPositionVariableLookup() Default constructor. public FanucPositionVariableLookup() FanucPositionVariableLookup(XElement) Loads from an XML element produced by MakeXmlSource(string, string, bool). Stateless — no fields to deserialise. public FanucPositionVariableLookup(XElement src) Parameters src XElement Fields AbsoluteXyzBase Inclusive lower bound of the absolute XYZ position range (#5041). public const int AbsoluteXyzBase = 5041 Field Value int BlockEndXyzBase Inclusive lower bound of the block-end XYZ position range (#5001). public const int BlockEndXyzBase = 5001 Field Value int MachineCoordXyzBase Inclusive lower bound of the machine-coordinate XYZ position range (#5021). public const int MachineCoordXyzBase = 5021 Field Value int Properties XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Get(string, LazyLinkedListNode<SyntaxPiece>, IReadOnlyList<INcDependency>) Returns the value of the variable identified by key in the context of node and dependencies, or null if the key is outside this lookup's range or the value is vacant. public double? Get(string key, LazyLinkedListNode<SyntaxPiece> node, IReadOnlyList<INcDependency> dependencies) Parameters key string node LazyLinkedListNode<SyntaxPiece> dependencies IReadOnlyList<INcDependency> Returns double? MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.Fanuc.FanucToolOffsetVariableLookup.html": {
    "href": "api/Hi.NcParsers.Dependencys.Fanuc.FanucToolOffsetVariableLookup.html",
    "title": "Class FanucToolOffsetVariableLookup | HiAPI-C# 2025",
    "summary": "Class FanucToolOffsetVariableLookup Namespace Hi.NcParsers.Dependencys.Fanuc Assembly HiMech.dll Fanuc-side adapter that exposes a wrapped ToolOffsetTable (resolved at call time from the dependency list) as an IRuntimeVariableLookup following Fanuc Memory C tool offset addressing: #2001+N → effective height of offset N (geometry − wear). The underlying ToolOffsetTable stays brand-neutral — Heidenhain / Siemens can use the same storage with different addressing by registering their own adapter alongside the table. Stateless: holds no reference of its own and resolves the table from the per-call dependencies list, so XML round-trip is trivial (an empty element). Registered on a brand preset's RuntimeVariableLookups, not on PipelineNcDependencyList — the wrapper owns no long-lived data, only the Fanuc-style id addressing scheme. The underlying ToolOffsetTable still lives in NcDependencyList as the data dependency. public sealed class FanucToolOffsetVariableLookup : IRuntimeVariableLookup, IMakeXmlSource Inheritance object FanucToolOffsetVariableLookup Implements IRuntimeVariableLookup IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FanucToolOffsetVariableLookup() Default constructor. public FanucToolOffsetVariableLookup() FanucToolOffsetVariableLookup(XElement) Loads from an XML element produced by MakeXmlSource(string, string, bool). Stateless — no fields to deserialise. public FanucToolOffsetVariableLookup(XElement src) Parameters src XElement Fields ToolHeightMax Inclusive upper bound of the Fanuc tool height address range (#2200). public const int ToolHeightMax = 2200 Field Value int ToolHeightMin Inclusive lower bound of the Fanuc tool height address range (#2001). public const int ToolHeightMin = 2001 Field Value int Properties XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Get(string, LazyLinkedListNode<SyntaxPiece>, IReadOnlyList<INcDependency>) Returns the value of the variable identified by key in the context of node and dependencies, or null if the key is outside this lookup's range or the value is vacant. public double? Get(string key, LazyLinkedListNode<SyntaxPiece> node, IReadOnlyList<INcDependency> dependencies) Parameters key string node LazyLinkedListNode<SyntaxPiece> dependencies IReadOnlyList<INcDependency> Returns double? Remarks Routes #2001-#2200 to GetToolHeightOffset_mm(int) on the ToolOffsetTable found in dependencies; other keys return null so the evaluator's lookup chain falls through. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.Fanuc.FanucWhileDoIterationDependency.html": {
    "href": "api/Hi.NcParsers.Dependencys.Fanuc.FanucWhileDoIterationDependency.html",
    "title": "Class FanucWhileDoIterationDependency | HiAPI-C# 2025",
    "summary": "Class FanucWhileDoIterationDependency Namespace Hi.NcParsers.Dependencys.Fanuc Assembly HiMech.dll Watchdog for Fanuc Custom Macro B WHILE/END m bounded loops. Sibling to FanucGotoIterationDependency with the same “soft-cap + runtime counter + session-init ISessionResettable” shape, but kept as a separate dep (rather than sharing the GOTO bucket) so loop and jump iteration limits can be tuned independently and so diagnostic codes do not cross. The counter key is (FileName, LoopId) where FileName is the source-level file path of the WHILE/END pair (the relative path form carried on FilePath). Source-level keying means multiple inline invocations of the same subprogram pool their counts (same source-code loop), while two different files each with their own WHILE DO 1 stay isolated. The consuming syntax (FanucWhileDoSyntax) increments the counter at the END m reverse-jump step — not on the WHILE entry — so a loop that exits on first WHILE evaluation (condition false from the outset) consumes zero iterations. Above MaxIterationsPerLoopId, the END m block emits a warning and suppresses the redirect; subsequent flow falls through past END. Default MaxIterationsPerLoopId is 10000 — higher than the GOTO equivalent (1000) because WHILE/END is the legitimate iteration primitive that NcOpt-generated programs (drill grids, adaptive sweeps) depend on, and 1000 is too tight for those. public class FanucWhileDoIterationDependency : INcDependency, IMakeXmlSource, ISessionResettable Inheritance object FanucWhileDoIterationDependency Implements INcDependency IMakeXmlSource ISessionResettable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FanucWhileDoIterationDependency() Initializes a new instance with the default limit and an empty counter. public FanucWhileDoIterationDependency() FanucWhileDoIterationDependency(XElement) Loads MaxIterationsPerLoopId from XML produced by MakeXmlSource(string, string, bool); absent element falls back to DefaultMaxIterationsPerLoopId. public FanucWhileDoIterationDependency(XElement src) Parameters src XElement Root element named XName. Fields DefaultMaxIterationsPerLoopId Default for MaxIterationsPerLoopId. Sized for legitimate macro iteration (NcOpt drill grids, calibration sweeps) while still catching runaway loops in a tractable time. public const int DefaultMaxIterationsPerLoopId = 10000 Field Value int Properties CountByLoop Per-loop hit counter keyed by (FileName, LoopId). Runtime-only; not serialised. Cleared by OnSessionReset() on the session-init edge so a brand-preset runner reused across sessions does not leak counts. public Dictionary<(string FileName, int LoopId), int> CountByLoop { get; } Property Value Dictionary<(string FileName, int TargetN), int> MaxIterationsPerLoopId Soft cap on consecutive END m reverse-jumps for any single (FileName, LoopId) pair. Above this the END m block emits FanucWhileDo–IterationLimitExceeded and suppresses the redirect; flow falls through past END. public int MaxIterationsPerLoopId { get; set; } Property Value int XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. OnSessionReset() Clears CountByLoop; leaves MaxIterationsPerLoopId untouched. public void OnSessionReset() Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.Fanuc.RetainedCommonVariableTable.html": {
    "href": "api/Hi.NcParsers.Dependencys.Fanuc.RetainedCommonVariableTable.html",
    "title": "Class RetainedCommonVariableTable | HiAPI-C# 2025",
    "summary": "Class RetainedCommonVariableTable Namespace Hi.NcParsers.Dependencys.Fanuc Assembly HiMech.dll Fanuc-style ISO controller common variable table for the retained range #500-#999. These variables survive a power cycle (in real hardware they live in NV-RAM) and are serialised into the project file. Excluded by design: Local #1-#33Call-frame scoped (Fanuc local variables); lives in the SyntaxPiece JSON dataflow, not here. Non-retained common #100-#499Cleared by program-end / power reset; lives in the SyntaxPiece JSON dataflow as well, not in this table. System #1000+Read-only or computed from runtime state; resolved by dedicated reading syntaxes against other dependencies (e.g. FanucParameterTable, tool offset / WCS tables). Vacant (Fanuc <vacant>) is represented by null: either the dictionary has no entry for the key, or the entry maps to null. Both are treated identically by GetVariable(int). Naming rationale: Fanuc official documentation calls #500-#999 \"retained common variables\" (and #100-#499 \"non-retained common variables\"). The umbrella term \"macro variable\" was avoided because it conflicts with Custom Macro B's call-frame concept (G65/G66 push a frame containing the local #1-#33); using RetainedCommonVariableTable reserves \"macro\" for the call-frame topic. public class RetainedCommonVariableTable : INcDependency, IMakeXmlSource, IVariableLookup Inheritance object RetainedCommonVariableTable Implements INcDependency IMakeXmlSource IVariableLookup Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors RetainedCommonVariableTable() Empty table. public RetainedCommonVariableTable() RetainedCommonVariableTable(XElement) Loads from XML produced by MakeXmlSource(string, string, bool). public RetainedCommonVariableTable(XElement src) Parameters src XElement Fields RetainedCommonMax Inclusive upper bound of the retained common range (#999). public const int RetainedCommonMax = 999 Field Value int RetainedCommonMin Inclusive lower bound of the retained common range (#500). public const int RetainedCommonMin = 500 Field Value int Properties Variables Backing store. Key = variable number (e.g. 500). Value null = vacant. A missing key is also treated as vacant. Keys are constrained to RetainedCommonMin..RetainedCommonMax; out-of-range writes are silently ignored. public Dictionary<int, double?> Variables { get; set; } Property Value Dictionary<int, double?> XName XML element name. public static string XName { get; } Property Value string Methods Get(string) Returns the value of the variable identified by key (e.g. \"#124\"), or null if vacant or unknown to this lookup. public double? Get(string key) Parameters key string Returns double? Remarks Routes #500-#999 reads to GetVariable(int); other keys return null so the evaluator's lookup chain falls through. GetVariable(int) Reads a retained common variable. Returns null for vacant (either the entry is absent or stored as null). public double? GetVariable(int id) Parameters id int Variable number in RetainedCommonMin..RetainedCommonMax. Returns double? MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetVariable(int, double?) Writes a retained common variable. Pass null to set vacant. Ignores ids outside RetainedCommonMin..RetainedCommonMax. public void SetVariable(int id, double? value) Parameters id int Variable number. value double? New value, or null for vacant."
  },
  "api/Hi.NcParsers.Dependencys.Fanuc.RetainedCommonVariableTableProxy.html": {
    "href": "api/Hi.NcParsers.Dependencys.Fanuc.RetainedCommonVariableTableProxy.html",
    "title": "Class RetainedCommonVariableTableProxy | HiAPI-C# 2025",
    "summary": "Class RetainedCommonVariableTableProxy Namespace Hi.NcParsers.Dependencys.Fanuc Assembly HiMech.dll Get-or-create INcDependencyProxy for RetainedCommonVariableTable: a placeholder in the shared PipelineNcDependencyList that resolves the host project's own per-case retained common variables (#500–#999). public sealed class RetainedCommonVariableTableProxy : INcDependencyProxy, INcDependency, IMakeXmlSource Inheritance object RetainedCommonVariableTableProxy Implements INcDependencyProxy INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods GetNcDependency() Takes the host's RetainedCommonVariableTable (created during InitNcDependencyHost(INcDependencyListHost)). Returns null when no host is wired. public INcDependency GetNcDependency() Returns INcDependency InitNcDependencyHost(INcDependencyListHost) Wires the host and materializes the per-case RetainedCommonVariableTable: when the host list has none, one is created and installed so it exists and is editable before any run. GetNcDependency() is then a pure take. Idempotent — an existing table is left untouched. public void InitNcDependencyHost(INcDependencyListHost host) Parameters host INcDependencyListHost MakeXmlSource(string, string, bool) Runtime-only proxy — the wired host and the resolved table are not persisted in the shared runner; serialization writes only the empty element. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.Fanuc.html": {
    "href": "api/Hi.NcParsers.Dependencys.Fanuc.html",
    "title": "Namespace Hi.NcParsers.Dependencys.Fanuc | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.Dependencys.Fanuc Classes FanucGotoIterationDependency Watchdog for Fanuc Custom Macro B GOTO loops. Holds a MaxIterationsPerTarget limit (XML-persisted user config — the soft cap above which the upcoming FanucGotoSyntax stops firing and emits a warning) plus a runtime per-target hit counter (CountByTarget — not serialised, cleared at session start by the ISessionResettable sweep in RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken)). The dependency is syntax-managed: FanucGotoSyntax reads the limit, increments the counter, and decides whether to fire. There is no host Func provider — the dep is placed in Hi.NcParsers.Dependencys.Fanuc rather than Hi.NcParsers.Dependencys.SystemWired because nothing outside the syntax pipeline writes it; OnSessionReset() is the session-init hook the runner invokes through ISessionResettable, not a host-wired Func. The counter key is (FileName, TargetN) where FileName is the source-level file path of the block containing the GOTO (the relative path form carried on FilePath — same form used by IndexedFileLine labels). Source-level keying means multiple inline invocations of the same subprogram pool their counts (they ARE the same source-code GOTO), while two different files with their own N100 stay isolated (they ARE different jumps). Default MaxIterationsPerTarget is 1000 — a runaway-loop guard, not a precise iteration budget. Legitimate macro loops (multi-hole drill matrices, calibration sweeps) sit well below this; truly infinite loops hit the limit fast. Projects with batch-style macros that legitimately need higher counts can raise the value in the project XML. FanucParameterTable Fanuc controller parameter table. Stores system parameters (single value) and axis parameters (per-axis value) following real Fanuc parameter numbering. FanucParameterTableProxy Get-or-create INcDependencyProxy for FanucParameterTable (the Fanuc / Mazak family parameter table): a placeholder in the shared PipelineNcDependencyList that resolves the host project's own parameter table. Unlike the pure per-case proxies, the Fanuc-family parameter table mixes machine config (axis types / reference positions / rapid / stroke) with per-case work-coordinate offsets (#5221+ / #7001+), so the proxy carries a fixed machine-config Seed that is serialized into the shared runner file. On wire, the host receives a deep clone of the seed only when it has no FanucParameterTable yet; a loaded project's own full table wins. The resolved host table holds everything (machine config + per-case coordinates) and is fully serialized on the project. The proxy deliberately does not implement the machine-config interfaces (IMachineAxisConfig etc.) — every machine-config consumer must go through GetEffectiveNcDependencyList() so it sees the resolved host table, never this placeholder. FanucPositionVariableLookup Fanuc-style position system variables read from the previous block's runtime-state JSON sections: #5001-#5003Block-end position X/Y/Z (workpiece) → previous block's ProgramXyz. #5021-#5023Current machine position X/Y/Z → previous block's MachineCoordinateState. #5041-#5043Current absolute position X/Y/Z → previous block's ProgramXyz. Stateless. Configured on RuntimeVariableLookups rather than NcDependencyList because the read needs the block node for Previous access — there is no long-lived dependency object that owns this data. FanucToolOffsetVariableLookup Fanuc-side adapter that exposes a wrapped ToolOffsetTable (resolved at call time from the dependency list) as an IRuntimeVariableLookup following Fanuc Memory C tool offset addressing: #2001+N → effective height of offset N (geometry − wear). The underlying ToolOffsetTable stays brand-neutral — Heidenhain / Siemens can use the same storage with different addressing by registering their own adapter alongside the table. Stateless: holds no reference of its own and resolves the table from the per-call dependencies list, so XML round-trip is trivial (an empty element). Registered on a brand preset's RuntimeVariableLookups, not on PipelineNcDependencyList — the wrapper owns no long-lived data, only the Fanuc-style id addressing scheme. The underlying ToolOffsetTable still lives in NcDependencyList as the data dependency. FanucWhileDoIterationDependency Watchdog for Fanuc Custom Macro B WHILE/END m bounded loops. Sibling to FanucGotoIterationDependency with the same “soft-cap + runtime counter + session-init ISessionResettable” shape, but kept as a separate dep (rather than sharing the GOTO bucket) so loop and jump iteration limits can be tuned independently and so diagnostic codes do not cross. The counter key is (FileName, LoopId) where FileName is the source-level file path of the WHILE/END pair (the relative path form carried on FilePath). Source-level keying means multiple inline invocations of the same subprogram pool their counts (same source-code loop), while two different files each with their own WHILE DO 1 stay isolated. The consuming syntax (FanucWhileDoSyntax) increments the counter at the END m reverse-jump step — not on the WHILE entry — so a loop that exits on first WHILE evaluation (condition false from the outset) consumes zero iterations. Above MaxIterationsPerLoopId, the END m block emits a warning and suppresses the redirect; subsequent flow falls through past END. Default MaxIterationsPerLoopId is 10000 — higher than the GOTO equivalent (1000) because WHILE/END is the legitimate iteration primitive that NcOpt-generated programs (drill grids, adaptive sweeps) depend on, and 1000 is too tight for those. RetainedCommonVariableTable Fanuc-style ISO controller common variable table for the retained range #500-#999. These variables survive a power cycle (in real hardware they live in NV-RAM) and are serialised into the project file. Excluded by design: Local #1-#33Call-frame scoped (Fanuc local variables); lives in the SyntaxPiece JSON dataflow, not here. Non-retained common #100-#499Cleared by program-end / power reset; lives in the SyntaxPiece JSON dataflow as well, not in this table. System #1000+Read-only or computed from runtime state; resolved by dedicated reading syntaxes against other dependencies (e.g. FanucParameterTable, tool offset / WCS tables). Vacant (Fanuc <vacant>) is represented by null: either the dictionary has no entry for the key, or the entry maps to null. Both are treated identically by GetVariable(int). Naming rationale: Fanuc official documentation calls #500-#999 \"retained common variables\" (and #100-#499 \"non-retained common variables\"). The umbrella term \"macro variable\" was avoided because it conflicts with Custom Macro B's call-frame concept (G65/G66 push a frame containing the local #1-#33); using RetainedCommonVariableTable reserves \"macro\" for the call-frame topic. RetainedCommonVariableTableProxy Get-or-create INcDependencyProxy for RetainedCommonVariableTable: a placeholder in the shared PipelineNcDependencyList that resolves the host project's own per-case retained common variables (#500–#999). Enums CutterCompensationType Fanuc #5003: Cutter compensation startup/cancellation type."
  },
  "api/Hi.NcParsers.Dependencys.Generic.FallbackConfig.html": {
    "href": "api/Hi.NcParsers.Dependencys.Generic.FallbackConfig.html",
    "title": "Class FallbackConfig | HiAPI-C# 2025",
    "summary": "Class FallbackConfig Namespace Hi.NcParsers.Dependencys.Generic Assembly HiMech.dll HiNC-specific fallback dependency that provides default values for all optional configuration interfaces. Should be placed as the last element in PipelineNcDependencyList so that brand-specific parameter tables (which appear earlier) take priority via OfType<T>().FirstOrDefault(). When a brand table (e.g., FanucParameterTable) implements the same interface, its values are used instead. This class serves as a safety net for brands that do not define certain parameters (e.g., Siemens/Heidenhain have no system parameter for G83 peck retraction — it is per-call). public class FallbackConfig : ICannedCycleConfig, INcDependency, IMakeXmlSource Inheritance object FallbackConfig Implements ICannedCycleConfig INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FallbackConfig() Initializes a new instance with default settings (PeckRetractionDistance_mm = 5.0). public FallbackConfig() FallbackConfig(XElement) Initializes a new instance by deserializing from src. public FallbackConfig(XElement src) Parameters src XElement XML element produced by MakeXmlSource(string, string, bool). Properties PeckRetractionDistance_mm G83 peck drilling clearance distance above the previous stroke bottom before re-entering at feed (mm). public double PeckRetractionDistance_mm { get; set; } Property Value double XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.Generic.GenericBlockSkipConfig.html": {
    "href": "api/Hi.NcParsers.Dependencys.Generic.GenericBlockSkipConfig.html",
    "title": "Class GenericBlockSkipConfig | HiAPI-C# 2025",
    "summary": "Class GenericBlockSkipConfig Namespace Hi.NcParsers.Dependencys.Generic Assembly HiMech.dll Default IBlockSkipConfig. Mirrors the typical Fanuc factory default: layer 1 (bare / prefix) is ON, other layers are OFF. Each layer can be toggled individually. XML form: <GenericBlockSkipConfig> <EnabledLayers>1,3</EnabledLayers> </GenericBlockSkipConfig> When EnabledLayers is absent the default is layer 1 only. public class GenericBlockSkipConfig : IBlockSkipConfig, INcDependency, IMakeXmlSource Inheritance object GenericBlockSkipConfig Implements IBlockSkipConfig INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors GenericBlockSkipConfig() Initializes a new instance with only layer 1 (the bare / prefix) enabled, matching the typical Fanuc factory default. public GenericBlockSkipConfig() GenericBlockSkipConfig(XElement) Initializes a new instance by deserializing from src. Falls back to layer 1 only when the EnabledLayers child element is absent or blank. public GenericBlockSkipConfig(XElement src) Parameters src XElement XML element produced by MakeXmlSource(string, string, bool). Properties EnabledLayers CSV of currently-enabled layers, e.g. “1,3”. public string EnabledLayers { get; set; } Property Value string XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods IsLayerEnabled(int) Returns true when blocks tagged with this layer should be skipped (controller switch ON). public bool IsLayerEnabled(int layer) Parameters layer int Skip layer, 1..9. Bare / is layer 1. Returns bool MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetLayerEnabled(int, bool) Enables / disables a specific skip layer. public void SetLayerEnabled(int layer, bool enabled) Parameters layer int Skip layer, 1..9. enabled bool True to skip blocks tagged with this layer."
  },
  "api/Hi.NcParsers.Dependencys.Generic.IsoCoordinateTable.html": {
    "href": "api/Hi.NcParsers.Dependencys.Generic.IsoCoordinateTable.html",
    "title": "Class IsoCoordinateTable | HiAPI-C# 2025",
    "summary": "Class IsoCoordinateTable Namespace Hi.NcParsers.Dependencys.Generic Assembly HiMech.dll Coordinate table for NC controller. The dictionary key is a G-code coordinate name (e.g. “G54”, “G59.2”); the dictionary value is machine coordinate offset. Brand-agnostic standalone implementation of IIsoCoordinateConfig. Brand parameter tables (Fanuc, Syntec, Siemens, Heidenhain) provide hardware-faithful alternatives that map to real controller parameters. public class IsoCoordinateTable : Dictionary<string, Vec3d>, IDictionary<string, Vec3d>, ICollection<KeyValuePair<string, Vec3d>>, IReadOnlyDictionary<string, Vec3d>, IReadOnlyCollection<KeyValuePair<string, Vec3d>>, IEnumerable<KeyValuePair<string, Vec3d>>, IDictionary, ICollection, IEnumerable, IDeserializationCallback, ISerializable, IIsoCoordinateConfig, INcDependency, IMakeXmlSource Inheritance object Dictionary<string, Vec3d> IsoCoordinateTable Implements IDictionary<string, Vec3d> ICollection<KeyValuePair<string, Vec3d>> IReadOnlyDictionary<string, Vec3d> IReadOnlyCollection<KeyValuePair<string, Vec3d>> IEnumerable<KeyValuePair<string, Vec3d>> IDictionary ICollection IEnumerable IDeserializationCallback ISerializable IIsoCoordinateConfig INcDependency IMakeXmlSource Inherited Members Dictionary<string, Vec3d>.Add(string, Vec3d) Dictionary<string, Vec3d>.Clear() Dictionary<string, Vec3d>.ContainsKey(string) Dictionary<string, Vec3d>.ContainsValue(Vec3d) Dictionary<string, Vec3d>.EnsureCapacity(int) Dictionary<string, Vec3d>.GetAlternateLookup<TAlternateKey>() Dictionary<string, Vec3d>.GetEnumerator() Dictionary<string, Vec3d>.OnDeserialization(object) Dictionary<string, Vec3d>.Remove(string) Dictionary<string, Vec3d>.Remove(string, out Vec3d) Dictionary<string, Vec3d>.TrimExcess() Dictionary<string, Vec3d>.TrimExcess(int) Dictionary<string, Vec3d>.TryAdd(string, Vec3d) Dictionary<string, Vec3d>.TryGetAlternateLookup<TAlternateKey>(out Dictionary<string, Vec3d>.AlternateLookup<TAlternateKey>) Dictionary<string, Vec3d>.TryGetValue(string, out Vec3d) Dictionary<string, Vec3d>.Comparer Dictionary<string, Vec3d>.Count Dictionary<string, Vec3d>.Capacity Dictionary<string, Vec3d>.this[string] Dictionary<string, Vec3d>.Keys Dictionary<string, Vec3d>.Values object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) DictionaryUtil.Retrieve<K, V>(Dictionary<K, V>, K, out V, bool) DictionaryUtil.GetOrCreate<TKey, TValue>(IDictionary<TKey, TValue>, TKey) DictionaryUtil.GetOrCreate<TKey, TValue>(IDictionary<TKey, TValue>, TKey, TValue) DictionaryUtil.GetOrCreate<TKey, TValue>(IDictionary<TKey, TValue>, TKey, Func<TValue>) DictionaryUtil.TryGetValueByKeys<TKey, TValue>(IDictionary<TKey, TValue>, IEnumerable<TKey>, out TValue) StringUtil.ToDotSplitedString<T>(IEnumerable<T>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors IsoCoordinateTable() Creates the brand-neutral table seeded with every id of G54Series (G54–G59 and G59.1–G59.9) at zero. public IsoCoordinateTable() IsoCoordinateTable(IEnumerable<string>) Creates a table seeded with seedIds at zero — the shape a runner wants this provider to carry next to a brand table (see ExtendedG59x). public IsoCoordinateTable(IEnumerable<string> seedIds) Parameters seedIds IEnumerable<string> Coordinate ids to seed; null seeds nothing. IsoCoordinateTable(XElement) Initializes a new instance of the IsoCoordinateTable class from XML. Supports both new string ID format (“G54”) and legacy integer format (54000). public IsoCoordinateTable(XElement src) Parameters src XElement The XML element containing coordinate data. Fields XName Gets the XML element name for the IsoCoordinateTable. public static string XName Field Value string Properties CoordinateIds Enumerates the G-code coordinate ids that this provider currently has data for. public IEnumerable<string> CoordinateIds { get; } Property Value IEnumerable<string> ExtendedG59x A table carrying only the extended G59xSeries (G59.1–G59.9) — the rows the Fanuc-family parameter tables do not map. The Fanuc, Mazak and Syntec presets mount one behind their brand table through IsoCoordinateTableProxy, so the two providers' id sets are disjoint and CoordinateOffsetUtil.ResolveOffset's first-non-null walk never has to choose between them. public static IsoCoordinateTable ExtendedG59x { get; } Property Value IsoCoordinateTable Methods DeepClone() Returns an independent copy (entries and their offset vectors). Used by IsoCoordinateTableProxy to clone its seed into a host that has no table yet. public IsoCoordinateTable DeepClone() Returns IsoCoordinateTable GetCoordinateOffset(string) Gets the offset for the given G-code coordinate id. Returns null when no offset is configured for that id by this provider (callers iterate the next provider, or fall back to Zero). public Vec3d GetCoordinateOffset(string coordId) Parameters coordId string Returns Vec3d LegacyIntToKey(int) Converts a legacy 1000x integer ID to a G-code string key. e.g. 54000 -> “G54”, 59200 -> “G59.2”. public static string LegacyIntToKey(int id) Parameters id int Returns string MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetCoordinateOffset(string, Vec3d) Sets the offset for the given G-code coordinate id. public void SetCoordinateOffset(string coordId, Vec3d offset) Parameters coordId string offset Vec3d"
  },
  "api/Hi.NcParsers.Dependencys.Generic.IsoCoordinateTableProxy.html": {
    "href": "api/Hi.NcParsers.Dependencys.Generic.IsoCoordinateTableProxy.html",
    "title": "Class IsoCoordinateTableProxy | HiAPI-C# 2025",
    "summary": "Class IsoCoordinateTableProxy Namespace Hi.NcParsers.Dependencys.Generic Assembly HiMech.dll Get-or-create INcDependencyProxy for IsoCoordinateTable: a placeholder in the shared PipelineNcDependencyList that resolves the host project's own per-case work coordinate offsets (G54–G59…). The proxy may carry a Seed — the shape (which ids exist, all zero) a fresh host table is cloned from. The Fanuc, Mazak and Syntec presets mount this proxy behind their brand parameter table with the ExtendedG59x seed, so the brand table keeps G54–G59 and G54.1 P1–P48 while this table carries only the extended G59.1–G59.9 the brand tables cannot map. Without a seed the fresh table is the full brand-neutral set (the shape every pre-seed <IsoCoordinateTableProxy/> element materialized). public sealed class IsoCoordinateTableProxy : INcDependencyProxy, INcDependency, IMakeXmlSource Inheritance object IsoCoordinateTableProxy Implements INcDependencyProxy INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors IsoCoordinateTableProxy() Creates a proxy whose fresh host table is the full brand-neutral default. public IsoCoordinateTableProxy() IsoCoordinateTableProxy(IsoCoordinateTable) Creates a proxy whose fresh host table is cloned from seed (null for the full brand-neutral default). public IsoCoordinateTableProxy(IsoCoordinateTable seed) Parameters seed IsoCoordinateTable The shape a fresh host table is cloned from. Properties Seed The shape a fresh host table is deep-cloned from — its ids at zero — or null for the full brand-neutral default. Carried on the shared runner and serialized into the runner file; never the per-case instance, which lives on the host (see GetNcDependency()). public IsoCoordinateTable Seed { get; } Property Value IsoCoordinateTable XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods GetNcDependency() Takes the host's IsoCoordinateTable (created during InitNcDependencyHost(INcDependencyListHost)). Returns null when no host is wired. public INcDependency GetNcDependency() Returns INcDependency InitNcDependencyHost(INcDependencyListHost) Wires the host and materializes the per-case IsoCoordinateTable: when the host list has none, one is created (a clone of Seed, else the full default) and installed so it exists and is editable before any run. GetNcDependency() is then a pure take. Idempotent — an existing table is left untouched, whatever its shape. public void InitNcDependencyHost(INcDependencyListHost host) Parameters host INcDependencyListHost MakeXmlSource(string, string, bool) Serializes only the Seed (an empty element when there is none) — the wired host and the resolved table are runtime-only and not persisted in the shared runner. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Rehydrates the carried Seed from the nested IsoCoordinateTable element when present. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.Generic.MachineAxisConfig.html": {
    "href": "api/Hi.NcParsers.Dependencys.Generic.MachineAxisConfig.html",
    "title": "Class MachineAxisConfig | HiAPI-C# 2025",
    "summary": "Class MachineAxisConfig Namespace Hi.NcParsers.Dependencys.Generic Assembly HiMech.dll Brand-neutral IMachineAxisConfig backed by a plain axis→type map, for pipelines that have no controller parameter table (e.g. the NX CLSF runner). Typically populated from the machine chain via ConfigureByMachiningChain(IMachiningChain); rotary axes default to modular (IsModularRotary(string) inherited), matching the cyclic shortest-path treatment of McAbcCyclicPathSyntax. public class MachineAxisConfig : IMachineAxisConfig, INcDependency, IMakeXmlSource Inheritance object MachineAxisConfig Implements IMachineAxisConfig INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MachineAxisConfig() Creates an empty config; axes are added via SetAxis(string, AxisType). public MachineAxisConfig() MachineAxisConfig(XElement) Reconstructs a config from its XML element. public MachineAxisConfig(XElement src) Parameters src XElement XML element previously produced by MakeXmlSource(string, string, bool). Properties AxisNames Gets the configured axis names in order. public IEnumerable<string> AxisNames { get; } Property Value IEnumerable<string> XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods Clear() Removes every axis. Call before re-populating from a different machine chain — axes left over from a previous chain (e.g. rotaries after switching 5-axis → 3-axis) would otherwise send the modal rotary lookbacks walking the whole stream for values that no block carries. public void Clear() IsRotaryAxis(string) Returns true if the axis is rotary or spindle, false if linear. public bool IsRotaryAxis(string axisName) Parameters axisName string Returns bool MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory RemoveAxis(string) Removes an axis from the configuration. public void RemoveAxis(string axisName) Parameters axisName string SetAxis(string, AxisType) Adds or updates an axis with the specified type. public void SetAxis(string axisName, AxisType type) Parameters axisName string type AxisType"
  },
  "api/Hi.NcParsers.Dependencys.Generic.SubProgramFolderConfig.html": {
    "href": "api/Hi.NcParsers.Dependencys.Generic.SubProgramFolderConfig.html",
    "title": "Class SubProgramFolderConfig | HiAPI-C# 2025",
    "summary": "Class SubProgramFolderConfig Namespace Hi.NcParsers.Dependencys.Generic Assembly HiMech.dll Folder lookup configuration for SubProgramCallSyntax: where to find an O<n> file when the host program executes M98 P_ L_ (InternalFolder) or M198 P_ (ExternalFolder, modelling Fanuc's external storage call — memory card, USB, DNC drive — whose only difference from M98 is the search root). Either path may be absolute or relative; when relative, it resolves against the host file's parent directory at lookup time. Either may be null — a null ExternalFolder falls back to InternalFolder; a null InternalFolder falls back to the host file's parent directory. public class SubProgramFolderConfig : INcDependency, IMakeXmlSource Inheritance object SubProgramFolderConfig Implements INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SubProgramFolderConfig() Initializes a new instance with the default “NC” internal folder and null external folder. public SubProgramFolderConfig() SubProgramFolderConfig(XElement) Loads InternalFolder / ExternalFolder from XML produced by MakeXmlSource(string, string, bool); either child element may be absent. public SubProgramFolderConfig(XElement src) Parameters src XElement Root element named XName. Properties ExternalFolder Folder for M198 P_ lookup, modelling Fanuc's “subprogram on external storage” semantics. Absolute or relative. Null means “fall back to InternalFolder” — a simulator-friendly default for projects that don't actually distinguish internal vs external storage on disk. public string ExternalFolder { get; set; } Property Value string InternalFolder Folder for M98 P_ lookup. Absolute or relative; relative is resolved against the host file's parent directory at use time. Null means “use the host file's parent directory directly”. Default “NC” mirrors a typical project layout where the main program sits beside an NC/ subdirectory of subprograms. public string InternalFolder { get; set; } Property Value string XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.Generic.ToolOffsetRow.html": {
    "href": "api/Hi.NcParsers.Dependencys.Generic.ToolOffsetRow.html",
    "title": "Class ToolOffsetRow | HiAPI-C# 2025",
    "summary": "Class ToolOffsetRow Namespace Hi.NcParsers.Dependencys.Generic Assembly HiMech.dll Single row of a ToolOffsetTable. Stores geometry (ideal) and wear components for height and radius. Matches Fanuc Memory C layout where H and D share the same row. public class ToolOffsetRow Inheritance object ToolOffsetRow Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ToolOffsetRow() Initializes a new instance with all components zero. public ToolOffsetRow() ToolOffsetRow(double, double, double, double) Initializes a new instance with the supplied geometry and wear components. public ToolOffsetRow(double idealHeight_mm, double axialWear_mm, double idealRadius_mm, double radialWear_mm) Parameters idealHeight_mm double Initial value of IdealHeight_mm. axialWear_mm double Initial value of AxialWear_mm. idealRadius_mm double Initial value of IdealRadius_mm. radialWear_mm double Initial value of RadialWear_mm. Properties AxialWear_mm Accumulated axial wear in millimetres, subtracted from IdealHeight_mm by FullHeight_mm. public double AxialWear_mm { get; set; } Property Value double FullHeight_mm Effective height: geometry minus wear. public double FullHeight_mm { get; } Property Value double FullRadius_mm Effective radius: geometry minus wear. public double FullRadius_mm { get; } Property Value double IdealHeight_mm Geometric tool height in millimetres before wear is subtracted. Combined with AxialWear_mm via FullHeight_mm. public double IdealHeight_mm { get; set; } Property Value double IdealRadius_mm Geometric tool radius in millimetres before wear is subtracted. Combined with RadialWear_mm via FullRadius_mm. public double IdealRadius_mm { get; set; } Property Value double RadialWear_mm Accumulated radial wear in millimetres, subtracted from IdealRadius_mm by FullRadius_mm. public double RadialWear_mm { get; set; } Property Value double"
  },
  "api/Hi.NcParsers.Dependencys.Generic.ToolOffsetTable.html": {
    "href": "api/Hi.NcParsers.Dependencys.Generic.ToolOffsetTable.html",
    "title": "Class ToolOffsetTable | HiAPI-C# 2025",
    "summary": "Class ToolOffsetTable Namespace Hi.NcParsers.Dependencys.Generic Assembly HiMech.dll Integer-keyed tool offset table implementing IToolOffsetConfig. Suitable for Fanuc (H/D), Heidenhain (tool number), Mazak, Okuma, and other ISO-compatible controllers. Key = offset number (Fanuc H or D number). public class ToolOffsetTable : INcDependency, IMakeXmlSource, IToolOffsetConfig Inheritance object ToolOffsetTable Implements INcDependency IMakeXmlSource IToolOffsetConfig Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ToolOffsetTable() Initializes a new instance with an empty Offsets table. public ToolOffsetTable() ToolOffsetTable(XElement) Initializes a new instance by deserializing from src. public ToolOffsetTable(XElement src) Parameters src XElement XML element produced by MakeXmlSource(string, string, bool). Properties Offsets Tool offset rows keyed by offset number (Fanuc H or D number, Heidenhain tool number, etc.). public Dictionary<int, ToolOffsetRow> Offsets { get; set; } Property Value Dictionary<int, ToolOffsetRow> XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods GetToolHeightOffset_mm(int) Gets the effective tool height offset (geometry - wear) in mm. Returns 0 if the offset number is not configured — indistinguishable from a configured zero; a consumer that must warn on a vacant row uses TryGetToolHeightOffset_mm(int, out double). public double GetToolHeightOffset_mm(int offsetNumber) Parameters offsetNumber int Offset number: Fanuc H number, Heidenhain tool number, etc. Returns double GetToolRadiusOffset_mm(int) Gets the effective tool radius offset (geometry - wear) in mm. Returns 0 if the offset number is not configured — indistinguishable from a configured zero; a consumer that must warn on a vacant row uses TryGetToolRadiusOffset_mm(int, out double). public double GetToolRadiusOffset_mm(int offsetNumber) Parameters offsetNumber int Offset number: Fanuc D number, Heidenhain tool number, etc. Returns double MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetToolOffset(int, double, double, double, double) Sets all four offset components for the given offset number. public void SetToolOffset(int offsetNumber, double idealHeight_mm, double axialWear_mm, double idealRadius_mm, double radialWear_mm) Parameters offsetNumber int idealHeight_mm double axialWear_mm double idealRadius_mm double radialWear_mm double TryGetToolHeightOffset_mm(int, out double) Attempts to get the effective tool height offset (geometry - wear) in mm. Returns false when offsetNumber has no configured row — the only reliable miss signal, since 0 is a legal configured offset. The compensation syntaxes warn on a miss (Comp-ToolHeight–RowMissing) instead of silently machining with a zero-length tool. public bool TryGetToolHeightOffset_mm(int offsetNumber, out double height_mm) Parameters offsetNumber int Offset number: Fanuc H number, Heidenhain tool number, etc. height_mm double The effective height offset; 0 on miss. Returns bool TryGetToolRadiusOffset_mm(int, out double) Attempts to get the effective tool radius offset (geometry - wear) in mm. Returns false when offsetNumber has no configured row (see TryGetToolHeightOffset_mm(int, out double)). public bool TryGetToolRadiusOffset_mm(int offsetNumber, out double radius_mm) Parameters offsetNumber int Offset number: Fanuc D number, Heidenhain tool number, etc. radius_mm double The effective radius offset; 0 on miss. Returns bool UpdateIdealByToolHouse(MachiningToolHouse) Refreshes the ideal (geometry) components from the tool house — ideal height = the tool's spindle-buckle→tool-tip length, ideal radius = the cutter profile's max radius — preserving accumulated wear, and drops rows whose tool id no longer exists in the house. Offset number maps 1:1 to the tool id. Mirrors the HardNc MillingToolOffsetTable.UpdateIdealMillingToolOffsetTableByToolHouse semantics so H/D offsets follow the tool house when the project's IsIdealOffsetDependentOnToolHouse is on. public void UpdateIdealByToolHouse(MachiningToolHouse toolHouse) Parameters toolHouse MachiningToolHouse Source tool house; no-op when null."
  },
  "api/Hi.NcParsers.Dependencys.Generic.ToolOffsetTableProxy.html": {
    "href": "api/Hi.NcParsers.Dependencys.Generic.ToolOffsetTableProxy.html",
    "title": "Class ToolOffsetTableProxy | HiAPI-C# 2025",
    "summary": "Class ToolOffsetTableProxy Namespace Hi.NcParsers.Dependencys.Generic Assembly HiMech.dll Get-or-create INcDependencyProxy for ToolOffsetTable: a placeholder in the shared PipelineNcDependencyList that resolves the host project's own per-case tool offsets. The shared runner file holds only this proxy, never the offset data. public sealed class ToolOffsetTableProxy : INcDependencyProxy, INcDependency, IMakeXmlSource Inheritance object ToolOffsetTableProxy Implements INcDependencyProxy INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods GetNcDependency() Takes the host's ToolOffsetTable (created during InitNcDependencyHost(INcDependencyListHost)). Returns null when no host is wired. public INcDependency GetNcDependency() Returns INcDependency InitNcDependencyHost(INcDependencyListHost) Wires the host and materializes the per-case ToolOffsetTable: when the host list has none, one is created and installed so it exists and is editable before any run. GetNcDependency() is then a pure take. Idempotent — an existing table is left untouched. public void InitNcDependencyHost(INcDependencyListHost host) Parameters host INcDependencyListHost MakeXmlSource(string, string, bool) Runtime-only proxy — the wired host and the resolved table are not persisted in the shared runner; serialization writes only the empty element. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.Generic.ToolingMcConfig.html": {
    "href": "api/Hi.NcParsers.Dependencys.Generic.ToolingMcConfig.html",
    "title": "Class ToolingMcConfig | HiAPI-C# 2025",
    "summary": "Class ToolingMcConfig Namespace Hi.NcParsers.Dependencys.Generic Assembly HiMech.dll HiNC-specific: machine position axes move to during tool change (M06). Not a standard Fanuc parameter — in real Fanuc, tool change motion is programmed in the macro program (O9006). Each axis value: a position to move to, or NaN to stay. public class ToolingMcConfig : IToolingMcConfig, INcDependency, IMakeXmlSource Inheritance object ToolingMcConfig Implements IToolingMcConfig INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ToolingMcConfig() Initializes a new instance with an empty AxisPositions map and zero ToolingTime. public ToolingMcConfig() ToolingMcConfig(XElement) Initializes a new instance by deserializing from src. public ToolingMcConfig(XElement src) Parameters src XElement XML element produced by MakeXmlSource(string, string, bool). Properties AxisPositions Per-axis tooling positions. NaN means the axis stays where it is. public Dictionary<string, double> AxisPositions { get; set; } Property Value Dictionary<string, double> Default3Axis Default: XY stay, Z moves to 0, rotary axes stay (no A/B/C entry — GetToolingPosition(string) returns null → NaN in ToolingMcAbc_deg → the axis does not participate in the tool-change motion). public static ToolingMcConfig Default3Axis { get; } Property Value ToolingMcConfig ToolingTime Duration of the tool changer mechanism (arm swap, magazine rotation, etc.). Does not include axis motion time to/from the tooling position. public TimeSpan ToolingTime { get; set; } Property Value TimeSpan XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods GetToolingPosition(string) Gets the tooling position for a specific axis. Returns NaN if the axis should stay where it is. Returns null if the axis has no tooling position configured. public double? GetToolingPosition(string axisName) Parameters axisName string Returns double? MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetToolingPosition(string, double) Sets the tooling position for a specific axis. Use NaN to indicate the axis should stay. public void SetToolingPosition(string axisName, double value) Parameters axisName string value double"
  },
  "api/Hi.NcParsers.Dependencys.Generic.html": {
    "href": "api/Hi.NcParsers.Dependencys.Generic.html",
    "title": "Namespace Hi.NcParsers.Dependencys.Generic | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.Dependencys.Generic Classes FallbackConfig HiNC-specific fallback dependency that provides default values for all optional configuration interfaces. Should be placed as the last element in PipelineNcDependencyList so that brand-specific parameter tables (which appear earlier) take priority via OfType<T>().FirstOrDefault(). When a brand table (e.g., FanucParameterTable) implements the same interface, its values are used instead. This class serves as a safety net for brands that do not define certain parameters (e.g., Siemens/Heidenhain have no system parameter for G83 peck retraction — it is per-call). GenericBlockSkipConfig Default IBlockSkipConfig. Mirrors the typical Fanuc factory default: layer 1 (bare / prefix) is ON, other layers are OFF. Each layer can be toggled individually. XML form: <GenericBlockSkipConfig> <EnabledLayers>1,3</EnabledLayers> </GenericBlockSkipConfig> When EnabledLayers is absent the default is layer 1 only. IsoCoordinateTable Coordinate table for NC controller. The dictionary key is a G-code coordinate name (e.g. “G54”, “G59.2”); the dictionary value is machine coordinate offset. Brand-agnostic standalone implementation of IIsoCoordinateConfig. Brand parameter tables (Fanuc, Syntec, Siemens, Heidenhain) provide hardware-faithful alternatives that map to real controller parameters. IsoCoordinateTableProxy Get-or-create INcDependencyProxy for IsoCoordinateTable: a placeholder in the shared PipelineNcDependencyList that resolves the host project's own per-case work coordinate offsets (G54–G59…). The proxy may carry a Seed — the shape (which ids exist, all zero) a fresh host table is cloned from. The Fanuc, Mazak and Syntec presets mount this proxy behind their brand parameter table with the ExtendedG59x seed, so the brand table keeps G54–G59 and G54.1 P1–P48 while this table carries only the extended G59.1–G59.9 the brand tables cannot map. Without a seed the fresh table is the full brand-neutral set (the shape every pre-seed <IsoCoordinateTableProxy/> element materialized). MachineAxisConfig Brand-neutral IMachineAxisConfig backed by a plain axis→type map, for pipelines that have no controller parameter table (e.g. the NX CLSF runner). Typically populated from the machine chain via ConfigureByMachiningChain(IMachiningChain); rotary axes default to modular (IsModularRotary(string) inherited), matching the cyclic shortest-path treatment of McAbcCyclicPathSyntax. SubProgramFolderConfig Folder lookup configuration for SubProgramCallSyntax: where to find an O<n> file when the host program executes M98 P_ L_ (InternalFolder) or M198 P_ (ExternalFolder, modelling Fanuc's external storage call — memory card, USB, DNC drive — whose only difference from M98 is the search root). Either path may be absolute or relative; when relative, it resolves against the host file's parent directory at lookup time. Either may be null — a null ExternalFolder falls back to InternalFolder; a null InternalFolder falls back to the host file's parent directory. ToolOffsetRow Single row of a ToolOffsetTable. Stores geometry (ideal) and wear components for height and radius. Matches Fanuc Memory C layout where H and D share the same row. ToolOffsetTable Integer-keyed tool offset table implementing IToolOffsetConfig. Suitable for Fanuc (H/D), Heidenhain (tool number), Mazak, Okuma, and other ISO-compatible controllers. Key = offset number (Fanuc H or D number). ToolOffsetTableProxy Get-or-create INcDependencyProxy for ToolOffsetTable: a placeholder in the shared PipelineNcDependencyList that resolves the host project's own per-case tool offsets. The shared runner file holds only this proxy, never the offset data. ToolingMcConfig HiNC-specific: machine position axes move to during tool change (M06). Not a standard Fanuc parameter — in real Fanuc, tool change motion is programmed in the macro program (O9006). Each axis value: a position to move to, or NaN to stay."
  },
  "api/Hi.NcParsers.Dependencys.Heidenhain.HeidenhainGotoIterationDependency.html": {
    "href": "api/Hi.NcParsers.Dependencys.Heidenhain.HeidenhainGotoIterationDependency.html",
    "title": "Class HeidenhainGotoIterationDependency | HiAPI-C# 2025",
    "summary": "Class HeidenhainGotoIterationDependency Namespace Hi.NcParsers.Dependencys.Heidenhain Assembly HiMech.dll Watchdog for Heidenhain FN 9–12 GOTO LBL jumps — the label-keyed sibling of the Siemens SiemensGotoIterationDependency, with the same “soft-cap + runtime counter + session-init ISessionResettable” shape. Kept per-brand for diagnostic clarity and because klartext targets are LBL numbers-or-names, matched in their canonical form (“01” ≡ 1 on a TNC, quotes stripped). The counter key is (FileName, Label) where FileName is the source-level file path of the jump host (the relative form carried on FilePath) and Label is the normalised target. Klartext has no direction mnemonic — a backward jump is the language's loop primitive, a forward jump can only fire once per arrival — so all jumps to one label share one bucket and the cap stays generous. The consuming syntax (HeidenhainGotoSyntax) counts after the condition gate and before the label scan; above MaxIterationsPerLabel the jump warns HeidenhainGoto--IterationLimitExceeded and falls through. A missing dependency disables the cap (Fanuc parity) — the brand preset wires one by default. public class HeidenhainGotoIterationDependency : INcDependency, IMakeXmlSource, ISessionResettable Inheritance object HeidenhainGotoIterationDependency Implements INcDependency IMakeXmlSource ISessionResettable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainGotoIterationDependency() Initializes a new instance with the default limit and an empty counter. public HeidenhainGotoIterationDependency() HeidenhainGotoIterationDependency(XElement) Loads MaxIterationsPerLabel from XML produced by MakeXmlSource(string, string, bool); absent element falls back to DefaultMaxIterationsPerLabel. public HeidenhainGotoIterationDependency(XElement src) Parameters src XElement Root element named XName. Fields DefaultMaxIterationsPerLabel Default for MaxIterationsPerLabel — the Fanuc / Siemens GOTO default: klartext counting loops are short (feed scaling, retry sections), so the cap stays tight. public const int DefaultMaxIterationsPerLabel = 1000 Field Value int Properties CountByLabel Per-target hit counter keyed by (FileName, Label) with the label in canonical form. Runtime-only; not serialised. Cleared by OnSessionReset() on the session-init edge. public Dictionary<(string FileName, string Label), int> CountByLabel { get; } Property Value Dictionary<(string FileName, string Label), int> MaxIterationsPerLabel Soft cap on fired jumps for any single (FileName, Label) pair. Above this the host block emits HeidenhainGoto–IterationLimitExceeded and falls through. public int MaxIterationsPerLabel { get; set; } Property Value int XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. OnSessionReset() Clears CountByLabel; leaves MaxIterationsPerLabel untouched. public void OnSessionReset() Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.Heidenhain.HeidenhainParameterTable.html": {
    "href": "api/Hi.NcParsers.Dependencys.Heidenhain.HeidenhainParameterTable.html",
    "title": "Class HeidenhainParameterTable | HiAPI-C# 2025",
    "summary": "Class HeidenhainParameterTable Namespace Hi.NcParsers.Dependencys.Heidenhain Assembly HiMech.dll Heidenhain TNC/iTNC machine parameter table. Stores machine parameters (MP numbers) as system and per-axis values. MP100–MP199: General machine configuration. MP400–MP499: Axis-specific parameters. public class HeidenhainParameterTable : ControllerParameterTableBase, IHomeMcConfig, IMachineAxisConfig, IRapidFeedrateConfig, IStrokeLimitConfig, ISpindleControlConfig, IMCodeDeclarationConfig, IToolChangeTriggerConfig, INcDependency, IMakeXmlSource Inheritance object ControllerParameterTableBase HeidenhainParameterTable Implements IHomeMcConfig IMachineAxisConfig IRapidFeedrateConfig IStrokeLimitConfig ISpindleControlConfig IMCodeDeclarationConfig IToolChangeTriggerConfig INcDependency IMakeXmlSource Inherited Members ControllerParameterTableBase.GetLinearAxisRapidRate_mmdmin(string) ControllerParameterTableBase.GetRotaryAxisRapidRate_degdmin(string) ControllerParameterTableBase.SetLinearAxisRapidRate_mmdmin(string, double) ControllerParameterTableBase.SetRotaryAxisRapidRate_degdmin(string, double) ControllerParameterTableBase.GetPositiveLimit(string) ControllerParameterTableBase.GetNegativeLimit(string) ControllerParameterTableBase.SetPositiveLimit(string, double) ControllerParameterTableBase.SetNegativeLimit(string, double) ControllerParameterTableBase.DescribeIntAxisParam(int) ControllerParameterTableBase.SystemParams ControllerParameterTableBase.AxisParams ControllerParameterTableBase.IntAxisParams ControllerParameterTableBase.AxisParam(int) ControllerParameterTableBase.IntAxisParam(int) ControllerParameterTableBase.GetHomePosition(string) ControllerParameterTableBase.SetHomePosition(string, double) ControllerParameterTableBase.AxisNames ControllerParameterTableBase.IsRotaryAxis(string) ControllerParameterTableBase.SetAxis(string, AxisType) ControllerParameterTableBase.RemoveAxis(string) ControllerParameterTableBase.ConfigureRotaryAxis(string, double, double) ControllerParameterTableBase.MCodeDeclarations ControllerParameterTableBase.EffectiveMCodeDeclarations ControllerParameterTableBase.TryGetMCodeEffects(string, out MCodeEffects) ControllerParameterTableBase.DeclareMCode(string, MCodeEffects) ControllerParameterTableBase.RemoveMCodeDeclaration(string) ControllerParameterTableBase.ToolWordTriggersChange ControllerParameterTableBase.SpindleDirectionCodes ControllerParameterTableBase.TryResolveDirection(string, out SpindleDirection) ControllerParameterTableBase.ConfigureSpindleDirectionCode(string, SpindleDirection) ControllerParameterTableBase.RemoveSpindleDirectionCode(string) ControllerParameterTableBase.ReadXml(XElement) ControllerParameterTableBase.WriteXml(string) ControllerParameterTableBase.CopyParamsTo(ControllerParameterTableBase) object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainParameterTable() Initializes a new instance with empty parameter tables. public HeidenhainParameterTable() HeidenhainParameterTable(XElement) Initializes a new instance by deserializing from src. public HeidenhainParameterTable(XElement src) Parameters src XElement XML element produced by MakeXmlSource(string, string, bool). Fields MpAxisType MP400: Axis type per axis (0=linear, 1=rotary, 2=spindle). public const int MpAxisType = 400 Field Value int MpMaxSpindleSpeed MP100: Maximum spindle speed (RPM). public const int MpMaxSpindleSpeed = 100 Field Value int MpRapidRate MP1010: Rapid traverse rate per axis (mm/min or deg/min). public const int MpRapidRate = 1010 Field Value int MpReferencePosition MP410: Reference point position per axis. public const int MpReferencePosition = 410 Field Value int MpStrokeLimitNeg MP430: Negative stroke limit per axis. public const int MpStrokeLimitNeg = 430 Field Value int MpStrokeLimitPos MP420: Positive stroke limit per axis. public const int MpStrokeLimitPos = 420 Field Value int MpToolAxisDirection MP101: Tool axis direction (0=Z, 1=Y, 2=X). public const int MpToolAxisDirection = 101 Field Value int Properties AxisMp1010 MP1010: Rapid traverse rate per axis (mm/min or deg/min). See IRapidFeedrateConfig. public Dictionary<string, double> AxisMp1010 { get; set; } Property Value Dictionary<string, double> AxisMp400 MP400: Axis type per axis. See AxisType. See AxisNames. public Dictionary<string, int> AxisMp400 { get; set; } Property Value Dictionary<string, int> AxisMp410 MP410: Reference point position per axis. See IHomeMcConfig. public Dictionary<string, double> AxisMp410 { get; set; } Property Value Dictionary<string, double> AxisTypeParamId Parameter/MD/MP number for axis type (linear/rotary/spindle). protected override int AxisTypeParamId { get; } Property Value int Default3Axis Default 3-axis Heidenhain milling machine. public static HeidenhainParameterTable Default3Axis { get; } Property Value HeidenhainParameterTable IdAttributeName XML attribute name for the parameter ID (“ParamId”, “MdId”, “MpId”). protected override string IdAttributeName { get; } Property Value string MaxSpindleSpeed_rpm Maximum spindle speed in RPM. Delegates to Mp100. public double MaxSpindleSpeed_rpm { get; set; } Property Value double Mp100 MP100: Maximum spindle speed (RPM). See MaxSpindleSpeed_rpm. public double Mp100 { get; set; } Property Value double Mp101 MP101: Tool axis direction (0=Z, 1=Y, 2=X). See ToolAxisDirection. public int Mp101 { get; set; } Property Value int RapidRateParamId Parameter/MD/MP number for rapid traverse rate per axis. Null if not defined for this controller brand. protected override int? RapidRateParamId { get; } Property Value int? ReferencePositionParamId Parameter/MD/MP number for reference position (G28 home). protected override int ReferencePositionParamId { get; } Property Value int StrokeLimitNegParamId Parameter/MD/MP number for negative stroke limit per axis. Null if not defined for this controller brand. protected override int? StrokeLimitNegParamId { get; } Property Value int? StrokeLimitPosParamId Parameter/MD/MP number for positive stroke limit per axis. Null if not defined for this controller brand. protected override int? StrokeLimitPosParamId { get; } Property Value int? ToolAxisDirection Tool axis direction (0=Z, 1=Y, 2=X). Delegates to Mp101. public int ToolAxisDirection { get; set; } Property Value int XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods DeepClone() Returns an independent deep copy of this table (all three parameter dictionaries cloned). Used by HeidenhainParameterTableProxy to clone its fixed machine-config seed into a host that has no table yet. public HeidenhainParameterTable DeepClone() Returns HeidenhainParameterTable DescribeAxisParam(int) Per-axis double counterpart of DescribeSystemParam(int). Covers the role ids the base class consumes (reference position, rapid rate, stroke limits); brand subclasses may override for their own vocabulary or extra numbers. public override string DescribeAxisParam(int paramId) Parameters paramId int Brand-specific parameter/MD/MP number. Returns string DescribeSystemParam(int) Short usage label for a well-known system parameter id, or null when the id has no modeled meaning (a raw pass-through row). Brand subclasses extend this with their own well-known numbers; the native parameter UI shows the label next to the raw id so an operator can tell the modeled parameters from free extras. public override string DescribeSystemParam(int paramId) Parameters paramId int Brand-specific parameter/MD/MP number. Returns string MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public override XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.Heidenhain.HeidenhainParameterTableProxy.html": {
    "href": "api/Hi.NcParsers.Dependencys.Heidenhain.HeidenhainParameterTableProxy.html",
    "title": "Class HeidenhainParameterTableProxy | HiAPI-C# 2025",
    "summary": "Class HeidenhainParameterTableProxy Namespace Hi.NcParsers.Dependencys.Heidenhain Assembly HiMech.dll Get-or-create INcDependencyProxy for HeidenhainParameterTable: a placeholder in the shared PipelineNcDependencyList that resolves the host project's own machine parameter table. Like the Fanuc-family parameter table, the Heidenhain MP table mixes machine config (axis types / reference positions / rapid rates / tool axis direction) with per-project edits, so the proxy carries a fixed machine-config Seed that is serialized into the shared runner file. On wire, the host receives a deep clone of the seed only when it has no HeidenhainParameterTable yet; a loaded project's own full table wins, so a same-brand re-flash re-binds to the project's parameters instead of resetting them. The resolved host table is fully serialized on the project. The proxy deliberately does not implement the machine-config interfaces (IMachineAxisConfig etc.) — every machine-config consumer must go through GetEffectiveNcDependencyList() so it sees the resolved host table, never this placeholder. public sealed class HeidenhainParameterTableProxy : INcDependencyProxy, INcDependency, IMakeXmlSource Inheritance object HeidenhainParameterTableProxy Implements INcDependencyProxy INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainParameterTableProxy(HeidenhainParameterTable) Creates a proxy carrying seed as its machine-config seed, defaulting to Default3Axis. public HeidenhainParameterTableProxy(HeidenhainParameterTable seed = null) Parameters seed HeidenhainParameterTable The machine-config seed cloned into a fresh host. Properties Seed The fixed machine-config seed deep-cloned into a host that has no HeidenhainParameterTable yet. Carried on the shared runner and serialized into the runner file — never the per-case instance, which lives on the host (see GetNcDependency()). public HeidenhainParameterTable Seed { get; } Property Value HeidenhainParameterTable XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods GetNcDependency() Takes the host's HeidenhainParameterTable (created during InitNcDependencyHost(INcDependencyListHost)). Returns null when no host is wired. public INcDependency GetNcDependency() Returns INcDependency InitNcDependencyHost(INcDependencyListHost) Wires the host and materializes the host HeidenhainParameterTable: when the host list has none, a deep clone of Seed is installed so the machine parameters exist and are editable before any run. GetNcDependency() is then a pure take. Idempotent — an existing host table (a loaded project's) is left untouched. public void InitNcDependencyHost(INcDependencyListHost host) Parameters host INcDependencyListHost MakeXmlSource(string, string, bool) Serializes only the machine-config Seed — the wired host and the resolved host table are runtime-only and not persisted in the shared runner. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Rehydrates the carried Seed from the nested HeidenhainParameterTable element, falling back to Default3Axis when absent. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.Heidenhain.HeidenhainQParameterTable.html": {
    "href": "api/Hi.NcParsers.Dependencys.Heidenhain.HeidenhainQParameterTable.html",
    "title": "Class HeidenhainQParameterTable | HiAPI-C# 2025",
    "summary": "Class HeidenhainQParameterTable Namespace Hi.NcParsers.Dependencys.Heidenhain Assembly HiMech.dll Heidenhain Q-parameter table for the ranges that persist on a real TNC: free parameters Q0-Q99 (survive power cycles) and the permanent QR0-QR499 range (nonvolatile, backed up with the machine). Like the Siemens sibling SiemensRParameterTable, this table is not session-reset and is serialised into the project file. The other Q ranges deliberately live elsewhere: Q100-Q199 are controller-written system parameters — Get(string) returns null for them (read fail-soft, no fabricated values) and the reading syntax refuses writes; Q200+ are volatile cycle/user parameters carried block-to-block in Vars.Volatile (JSON dataflow, cleared at program end) — Get(string) also returns null so the evaluator's chain falls through to HeidenhainVolatileQLookup. Reads flow through Get(string) (registered automatically because the table sits on the runner's effective NcDependencyList); writes flow through HeidenhainQParameterReadingSyntax, which consumes literal Parsing.Assignments.Qn entries after VariableEvaluatorSyntax has normalized expression RHS to literals. Vacant is represented by null: either the dictionary has no entry for the key, or the entry maps to null — both read identically. A vacant read failing loud (Variable--Vacant via the evaluator) surfaces missing setup data instead of silently machining with 0. public class HeidenhainQParameterTable : INcDependency, IMakeXmlSource, IVariableLookup Inheritance object HeidenhainQParameterTable Implements INcDependency IMakeXmlSource IVariableLookup Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainQParameterTable() Empty table. public HeidenhainQParameterTable() HeidenhainQParameterTable(XElement) Loads from XML produced by MakeXmlSource(string, string, bool). public HeidenhainQParameterTable(XElement src) Parameters src XElement Fields PersistentMax Inclusive upper bound of the persistent free range (Q99). public const int PersistentMax = 99 Field Value int PersistentMin Inclusive lower bound of the persistent free range (Q0). public const int PersistentMin = 0 Field Value int QRMax Inclusive upper bound of the permanent QR range (QR499). public const int QRMax = 499 Field Value int QRMin Inclusive lower bound of the permanent QR range (QR0). public const int QRMin = 0 Field Value int SystemMax Inclusive upper bound of the read-only system range (Q199). public const int SystemMax = 199 Field Value int SystemMin Inclusive lower bound of the read-only system range (Q100). public const int SystemMin = 100 Field Value int Properties QRVariables Backing store of the permanent QR range. Key = QR number (e.g. 5 for QR5); same vacant semantics as Variables. Keys are constrained to QRMin..QRMax. public Dictionary<int, double?> QRVariables { get; set; } Property Value Dictionary<int, double?> Variables Backing store of the free persistent range. Key = Q number (e.g. 1 for Q1). Value null = vacant; a missing key is also vacant. Keys are constrained to PersistentMin..PersistentMax; out-of-range writes are silently ignored. public Dictionary<int, double?> Variables { get; set; } Property Value Dictionary<int, double?> XName XML element name. public static string XName { get; } Property Value string Methods Get(string) Returns the value of the variable identified by key (e.g. \"#124\"), or null if vacant or unknown to this lookup. public double? Get(string key) Parameters key string Returns double? Remarks Routes Qn keys in the persistent free range and QRn keys (canonical uppercase from HeidenhainExpressionParser; lowercase from raw captures also resolves) to their stores. All other keys — including the system range Q100-Q199 (read fail-soft by design), the volatile range Q200+ (lives in Vars.Volatile) and QL/QS — return null so the evaluator's lookup chain falls through. GetQRVariable(int) Reads a permanent QR parameter (QR0-QR499). Returns null for vacant. public double? GetQRVariable(int id) Parameters id int Parameter number in QRMin..QRMax. Returns double? GetVariable(int) Reads a free Q parameter (Q0-Q99). Returns null for vacant (either the entry is absent or stored as null). public double? GetVariable(int id) Parameters id int Parameter number in PersistentMin..PersistentMax. Returns double? MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetQRVariable(int, double?) Writes a permanent QR parameter. Pass null to set vacant. Ignores ids outside QRMin..QRMax. public void SetQRVariable(int id, double? value) Parameters id int Parameter number. value double? New value, or null for vacant. SetVariable(int, double?) Writes a free Q parameter. Pass null to set vacant. Ignores ids outside PersistentMin..PersistentMax. public void SetVariable(int id, double? value) Parameters id int Parameter number. value double? New value, or null for vacant."
  },
  "api/Hi.NcParsers.Dependencys.Heidenhain.HeidenhainQParameterTableProxy.html": {
    "href": "api/Hi.NcParsers.Dependencys.Heidenhain.HeidenhainQParameterTableProxy.html",
    "title": "Class HeidenhainQParameterTableProxy | HiAPI-C# 2025",
    "summary": "Class HeidenhainQParameterTableProxy Namespace Hi.NcParsers.Dependencys.Heidenhain Assembly HiMech.dll Get-or-create INcDependencyProxy for HeidenhainQParameterTable: a placeholder in the shared PipelineNcDependencyList that resolves the host project's own per-case Q parameters (Q0–Q99 + QR0–QR499). public sealed class HeidenhainQParameterTableProxy : INcDependencyProxy, INcDependency, IMakeXmlSource Inheritance object HeidenhainQParameterTableProxy Implements INcDependencyProxy INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods GetNcDependency() Takes the host's HeidenhainQParameterTable (created during InitNcDependencyHost(INcDependencyListHost)). Returns null when no host is wired. public INcDependency GetNcDependency() Returns INcDependency InitNcDependencyHost(INcDependencyListHost) Wires the host and materializes the per-case HeidenhainQParameterTable: when the host list has none, one is created and installed so it exists and is editable before any run. GetNcDependency() is then a pure take. Idempotent — an existing table is left untouched. public void InitNcDependencyHost(INcDependencyListHost host) Parameters host INcDependencyListHost MakeXmlSource(string, string, bool) Runtime-only proxy — the wired host and the resolved table are not persisted in the shared runner; serialization writes only the empty element. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.Heidenhain.html": {
    "href": "api/Hi.NcParsers.Dependencys.Heidenhain.html",
    "title": "Namespace Hi.NcParsers.Dependencys.Heidenhain | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.Dependencys.Heidenhain Classes HeidenhainGotoIterationDependency Watchdog for Heidenhain FN 9–12 GOTO LBL jumps — the label-keyed sibling of the Siemens SiemensGotoIterationDependency, with the same “soft-cap + runtime counter + session-init ISessionResettable” shape. Kept per-brand for diagnostic clarity and because klartext targets are LBL numbers-or-names, matched in their canonical form (“01” ≡ 1 on a TNC, quotes stripped). The counter key is (FileName, Label) where FileName is the source-level file path of the jump host (the relative form carried on FilePath) and Label is the normalised target. Klartext has no direction mnemonic — a backward jump is the language's loop primitive, a forward jump can only fire once per arrival — so all jumps to one label share one bucket and the cap stays generous. The consuming syntax (HeidenhainGotoSyntax) counts after the condition gate and before the label scan; above MaxIterationsPerLabel the jump warns HeidenhainGoto--IterationLimitExceeded and falls through. A missing dependency disables the cap (Fanuc parity) — the brand preset wires one by default. HeidenhainParameterTable Heidenhain TNC/iTNC machine parameter table. Stores machine parameters (MP numbers) as system and per-axis values. MP100–MP199: General machine configuration. MP400–MP499: Axis-specific parameters. HeidenhainParameterTableProxy Get-or-create INcDependencyProxy for HeidenhainParameterTable: a placeholder in the shared PipelineNcDependencyList that resolves the host project's own machine parameter table. Like the Fanuc-family parameter table, the Heidenhain MP table mixes machine config (axis types / reference positions / rapid rates / tool axis direction) with per-project edits, so the proxy carries a fixed machine-config Seed that is serialized into the shared runner file. On wire, the host receives a deep clone of the seed only when it has no HeidenhainParameterTable yet; a loaded project's own full table wins, so a same-brand re-flash re-binds to the project's parameters instead of resetting them. The resolved host table is fully serialized on the project. The proxy deliberately does not implement the machine-config interfaces (IMachineAxisConfig etc.) — every machine-config consumer must go through GetEffectiveNcDependencyList() so it sees the resolved host table, never this placeholder. HeidenhainQParameterTable Heidenhain Q-parameter table for the ranges that persist on a real TNC: free parameters Q0-Q99 (survive power cycles) and the permanent QR0-QR499 range (nonvolatile, backed up with the machine). Like the Siemens sibling SiemensRParameterTable, this table is not session-reset and is serialised into the project file. The other Q ranges deliberately live elsewhere: Q100-Q199 are controller-written system parameters — Get(string) returns null for them (read fail-soft, no fabricated values) and the reading syntax refuses writes; Q200+ are volatile cycle/user parameters carried block-to-block in Vars.Volatile (JSON dataflow, cleared at program end) — Get(string) also returns null so the evaluator's chain falls through to HeidenhainVolatileQLookup. Reads flow through Get(string) (registered automatically because the table sits on the runner's effective NcDependencyList); writes flow through HeidenhainQParameterReadingSyntax, which consumes literal Parsing.Assignments.Qn entries after VariableEvaluatorSyntax has normalized expression RHS to literals. Vacant is represented by null: either the dictionary has no entry for the key, or the entry maps to null — both read identically. A vacant read failing loud (Variable--Vacant via the evaluator) surfaces missing setup data instead of silently machining with 0. HeidenhainQParameterTableProxy Get-or-create INcDependencyProxy for HeidenhainQParameterTable: a placeholder in the shared PipelineNcDependencyList that resolves the host project's own per-case Q parameters (Q0–Q99 + QR0–QR499)."
  },
  "api/Hi.NcParsers.Dependencys.HeidenhainDatumTable.html": {
    "href": "api/Hi.NcParsers.Dependencys.HeidenhainDatumTable.html",
    "title": "Class HeidenhainDatumTable | HiAPI-C# 2025",
    "summary": "Class HeidenhainDatumTable Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll Heidenhain datum preset and datum shift tables. CYCL DEF 247 Q339=N reads from DatumPresetTable, CYCL DEF 7 #N reads from DatumShiftTable. Each table maps an integer ID (1–20) to a Vec3d offset. On real Heidenhain controllers, preset and datum tables are separate disk files (e.g. TNC:\\table\\preset.pr, *.d) — distinct from MP-prefixed Machine Parameters (held by HeidenhainParameterTable). HiNC mirrors that separation by keeping this dependency independent of HeidenhainParameterTable. Implements IIsoCoordinateConfig by mapping the ISO/DIN G54–G59 codes to preset rows 1–6, the conventional Heidenhain compatibility mapping for ISO/DIN programs running on a Heidenhain. public class HeidenhainDatumTable : IIsoCoordinateConfig, INcDependency, IMakeXmlSource Inheritance object HeidenhainDatumTable Implements IIsoCoordinateConfig INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainDatumTable() Initializes a new instance with rows 1-20 of DatumPresetTable and DatumShiftTable seeded to zero. public HeidenhainDatumTable() HeidenhainDatumTable(XElement) Initializes a new instance by deserializing from src. public HeidenhainDatumTable(XElement src) Parameters src XElement XML element produced by MakeXmlSource(string, string, bool). Fields PresetCoordinateIdPrefix CoordinateId prefix for preset rows (CYCL DEF 247), written by LogicSyntaxs.Heidenhain.HeidenhainCoordinateOffsetSyntax and resolved back to DatumPresetTable by GetCoordinateOffset(string) so the shared modal-lookback path (IsoCoordinateOffsetSyntax) keeps the offset alive on the blocks after the declaration. public const string PresetCoordinateIdPrefix = \"DATUM_PRESET_\" Field Value string ShiftCoordinateIdPrefix Shift-row id prefix (CYCL DEF 7 #N) used in the DatumShift section's ShiftId; the shift is carried modally by HeidenhainCoordinateOffsetSyntax itself (additive to the preset), not by the ISO coordinate-offset path. public const string ShiftCoordinateIdPrefix = \"DATUM_SHIFT_\" Field Value string Properties CoordinateIds Enumerates the G-code coordinate ids that this provider currently has data for. public IEnumerable<string> CoordinateIds { get; } Property Value IEnumerable<string> DatumPresetTable Preset rows (CYCL DEF 247 Q339=N) keyed by preset id (1-20). Rows 1-6 are aliased to ISO G54-G59 via IIsoCoordinateConfig. public Dictionary<int, Vec3d> DatumPresetTable { get; set; } Property Value Dictionary<int, Vec3d> DatumShiftTable Datum shift rows (CYCL DEF 7 #N) keyed by table id (1-20). public Dictionary<int, Vec3d> DatumShiftTable { get; set; } Property Value Dictionary<int, Vec3d> XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods GetCoordinateOffset(string) Gets the offset for the given G-code coordinate id. Returns null when no offset is configured for that id by this provider (callers iterate the next provider, or fall back to Zero). public Vec3d GetCoordinateOffset(string coordId) Parameters coordId string Returns Vec3d GetDatumPreset(int) Returns the preset offset for q339, or Zero if absent. See DatumPresetTable. public Vec3d GetDatumPreset(int q339) Parameters q339 int Preset id (CYCL DEF 247 Q339). Returns Vec3d GetDatumShift(int) Returns the datum shift offset for tableId, or Zero if absent. See DatumShiftTable. public Vec3d GetDatumShift(int tableId) Parameters tableId int Datum shift row id (CYCL DEF 7 #N). Returns Vec3d MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetCoordinateOffset(string, Vec3d) Sets the offset for the given G-code coordinate id. public void SetCoordinateOffset(string coordId, Vec3d offset) Parameters coordId string offset Vec3d SetDatumPreset(int, Vec3d) Sets the preset offset for q339. See DatumPresetTable. public void SetDatumPreset(int q339, Vec3d offset) Parameters q339 int Preset id (CYCL DEF 247 Q339). offset Vec3d Translation to store. SetDatumShift(int, Vec3d) Sets the datum shift offset for tableId. See DatumShiftTable. public void SetDatumShift(int tableId, Vec3d offset) Parameters tableId int Datum shift row id (CYCL DEF 7 #N). offset Vec3d Translation to store."
  },
  "api/Hi.NcParsers.Dependencys.HeidenhainDatumTableProxy.html": {
    "href": "api/Hi.NcParsers.Dependencys.HeidenhainDatumTableProxy.html",
    "title": "Class HeidenhainDatumTableProxy | HiAPI-C# 2025",
    "summary": "Class HeidenhainDatumTableProxy Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll Get-or-create INcDependencyProxy for HeidenhainDatumTable: a placeholder in the shared PipelineNcDependencyList that resolves the host project's own per-case datum preset / datum shift tables. public sealed class HeidenhainDatumTableProxy : INcDependencyProxy, INcDependency, IMakeXmlSource Inheritance object HeidenhainDatumTableProxy Implements INcDependencyProxy INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods GetNcDependency() Takes the host's HeidenhainDatumTable (created during InitNcDependencyHost(INcDependencyListHost)). Returns null when no host is wired. public INcDependency GetNcDependency() Returns INcDependency InitNcDependencyHost(INcDependencyListHost) Wires the host and materializes the per-case HeidenhainDatumTable: when the host list has none, one is created and installed so it exists and is editable before any run. GetNcDependency() is then a pure take. Idempotent — an existing table is left untouched. public void InitNcDependencyHost(INcDependencyListHost host) Parameters host INcDependencyListHost MakeXmlSource(string, string, bool) Runtime-only proxy — the wired host and the resolved table are not persisted in the shared runner; serialization writes only the empty element. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.IBlockSkipConfig.html": {
    "href": "api/Hi.NcParsers.Dependencys.IBlockSkipConfig.html",
    "title": "Interface IBlockSkipConfig | HiAPI-C# 2025",
    "summary": "Interface IBlockSkipConfig Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll Runtime state of the controller's Block Delete / Block Skip switches. Present in PipelineNcDependencyList exposes this to the runner so that blocks whose head carries / or /N (parsed by BlockSkipSyntax into BlockSkip) are skipped at semantic time. Layers are 1..9; Layer 1 corresponds to the bare / prefix. Controllers (Fanuc / Syntec / Mazak / Siemens) let each layer be toggled independently via panel switches or system parameters. When this dependency is absent from PipelineNcDependencyList, no block is skipped (safest default: simulate the full machining). The syntax still consumes the / prefix so no UnparsedText--Remaining diagnostic is produced. public interface IBlockSkipConfig : INcDependency, IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods IsLayerEnabled(int) Returns true when blocks tagged with this layer should be skipped (controller switch ON). bool IsLayerEnabled(int layer) Parameters layer int Skip layer, 1..9. Bare / is layer 1. Returns bool SetLayerEnabled(int, bool) Enables / disables a specific skip layer. void SetLayerEnabled(int layer, bool enabled) Parameters layer int Skip layer, 1..9. enabled bool True to skip blocks tagged with this layer."
  },
  "api/Hi.NcParsers.Dependencys.ICannedCycleConfig.html": {
    "href": "api/Hi.NcParsers.Dependencys.ICannedCycleConfig.html",
    "title": "Interface ICannedCycleConfig | HiAPI-C# 2025",
    "summary": "Interface ICannedCycleConfig Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll Canned cycle configuration parameters. Implemented by brand-specific parameter tables (e.g., FanucParameterTable for Fanuc #4002, SyntecParameterTable for Syntec Pr4002) and by FallbackConfig as a safety net. Siemens and Heidenhain specify peck clearance per-call (CYCLE83 parameter / CYCL DEF), so their tables do not implement this interface. The FallbackConfig provides the default value in those cases. public interface ICannedCycleConfig : INcDependency, IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties PeckRetractionDistance_mm G83 peck drilling clearance distance above the previous stroke bottom before re-entering at feed (mm). double PeckRetractionDistance_mm { get; } Property Value double"
  },
  "api/Hi.NcParsers.Dependencys.IHomeMcConfig.html": {
    "href": "api/Hi.NcParsers.Dependencys.IHomeMcConfig.html",
    "title": "Interface IHomeMcConfig | HiAPI-C# 2025",
    "summary": "Interface IHomeMcConfig Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll G28 first reference position (home machine coordinate) per axis. public interface IHomeMcConfig : INcDependency, IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties HomeMcAbc_deg ABC home position in degrees. Defaults to 0 per missing axis. Vec3d HomeMcAbc_deg { get; set; } Property Value Vec3d HomeMcXyz XYZ home position. Defaults to 0 per missing axis. Vec3d HomeMcXyz { get; set; } Property Value Vec3d Methods GetHomePosition(string) Gets the home position for a specific axis. Returns null if the axis has no home position configured. double? GetHomePosition(string axisName) Parameters axisName string Returns double? SetHomePosition(string, double) Sets the home position for a specific axis. void SetHomePosition(string axisName, double value) Parameters axisName string value double"
  },
  "api/Hi.NcParsers.Dependencys.IIndexingPositionConfig.html": {
    "href": "api/Hi.NcParsers.Dependencys.IIndexingPositionConfig.html",
    "title": "Interface IIndexingPositionConfig | HiAPI-C# 2025",
    "summary": "Interface IIndexingPositionConfig Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll Indexing-axis position table: maps 1-based indexing position numbers to axis coordinates for axes that only take up discrete stations (Hirth couplings, indexing rotary tables, turret-style workholders). Consumed by the coded-position coordinate functions (Siemens CAC()/CIC()/CDC()/CACP()/CACN() — unwrapped by SiemensAcIcSyntax, resolved by McAbcSyntax / IncrementalResolveSyntax via CodedPositionUtil). Implemented by SiemensMachineDataTable using the Siemens machine data (MD30500 $MA_INDEX_AX_ASSIGN_POS_TAB per axis; global tables MD10910/MD10930; equidistant MD30501–MD30503). Positions are expressed in the axis' native units (degrees for rotary, mm for linear) in the coordinate frame the axis word itself is written in — machine coordinates for rotary words, program coordinates for linear words. Position numbering is 1-based: number 1 is the first table entry (the Siemens machine-data help and alarm texts count this way; the 0-based value range printed in some programming-manual editions describes the machine-data array index, not the programmable number). public interface IIndexingPositionConfig : INcDependency, IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields PositionMatchTolerance Tolerance, in axis units (degrees or mm), within which an axis position is considered exactly on an indexing position by TryFindIndexingAnchor(string, double, out int, out bool). Anchors come from previous exact table writes, so the tolerance only needs to absorb float round-trip drift — real indexing spacings are many orders of magnitude larger. public const double PositionMatchTolerance = 1E-06 Field Value double Methods GetIndexingPositionCount(string) Number of programmable indexing positions: the table length for table-assigned axes, the per-cycle position count for cyclic equidistant axes, MaxValue for unbounded (non-cyclic equidistant) axes, and 0 when the axis is not a usable indexing axis. int GetIndexingPositionCount(string axisName) Parameters axisName string Axis name (e.g., “C”). Returns int IsIndexingAxis(string) True when the axis is configured as an indexing axis with a usable position table (a non-empty table, or a valid equidistant definition). An axis declared indexing but with an empty/invalid table reports false — the coded-position words then stay unrecognized (loud residue) instead of resolving against garbage. bool IsIndexingAxis(string axisName) Parameters axisName string Axis name (e.g., “C”). Returns bool IsIndexingCyclic(string) True when position-number arithmetic wraps modulo GetIndexingPositionCount(string) — an indexing axis that is also a modular rotary axis (IsModularRotary(string)). Advancing past the last position continues at position 1. bool IsIndexingCyclic(string axisName) Parameters axisName string Axis name (e.g., “C”). Returns bool TryFindIndexingAnchor(string, double, out int, out bool) Locates an axis position relative to the indexing table for incremental (CIC) resolution: floorNumber is the number of the nearest indexing position at or below position (cyclically behind on cyclic axes; 0 when the position lies below the whole table on a non-cyclic axis), and exactlyOnPosition reports a match within PositionMatchTolerance. False when the axis is not a usable indexing axis. bool TryFindIndexingAnchor(string axisName, double position, out int floorNumber, out bool exactlyOnPosition) Parameters axisName string Axis name (e.g., “C”). position double Current axis coordinate (degrees or mm); rotary values may lie outside one revolution and are normalized by the implementation. floorNumber int Number of the nearest indexing position at or (cyclically) below the given position. exactlyOnPosition bool True when the position sits on an indexing position within PositionMatchTolerance. Returns bool TryGetIndexingPosition(string, int, out double) Resolves a 1-based indexing position number to its axis coordinate. False when the axis is not a usable indexing axis or the number is outside [1, count]. bool TryGetIndexingPosition(string axisName, int positionNumber, out double position) Parameters axisName string Axis name (e.g., “C”). positionNumber int 1-based indexing position number. position double Resolved axis coordinate (degrees or mm). Returns bool"
  },
  "api/Hi.NcParsers.Dependencys.IIsoCoordinateConfig.html": {
    "href": "api/Hi.NcParsers.Dependencys.IIsoCoordinateConfig.html",
    "title": "Interface IIsoCoordinateConfig | HiAPI-C# 2025",
    "summary": "Interface IIsoCoordinateConfig Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll ISO work coordinate offset provider. Maps a G-code work coordinate id (e.g. “G54”, “G59.2”, “G54.1P1”) to a machine-coordinate offset Vec3d. Implementations include IsoCoordinateTable (brand-agnostic standalone storage), FanucParameterTable / SyntecParameterTable (parameter-table integration via real Fanuc/Syntec parameter numbers #5221+ for G54–G59 and #7001+ for G54.1 P1–P48), SiemensFrameTable (Sinumerik $P_UIFR frames), and HeidenhainDatumTable (Heidenhain preset rows). public interface IIsoCoordinateConfig : INcDependency, IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties CoordinateIds Enumerates the G-code coordinate ids that this provider currently has data for. IEnumerable<string> CoordinateIds { get; } Property Value IEnumerable<string> Methods GetCoordinateOffset(string) Gets the offset for the given G-code coordinate id. Returns null when no offset is configured for that id by this provider (callers iterate the next provider, or fall back to Zero). Vec3d GetCoordinateOffset(string coordId) Parameters coordId string Returns Vec3d SetCoordinateOffset(string, Vec3d) Sets the offset for the given G-code coordinate id. void SetCoordinateOffset(string coordId, Vec3d offset) Parameters coordId string offset Vec3d"
  },
  "api/Hi.NcParsers.Dependencys.IMCodeDeclarationConfig.html": {
    "href": "api/Hi.NcParsers.Dependencys.IMCodeDeclarationConfig.html",
    "title": "Interface IMCodeDeclarationConfig | HiAPI-C# 2025",
    "summary": "Interface IMCodeDeclarationConfig Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll Machine-declared M-code map: what each machine-specific (OEM/PLC) M-code does, as MCodeEffects — possibly several effects per code (tool change, spindle direction, coolant) plus a note for behavior this simulation does not model. Consumed by MCodeExpansionSyntax, which expands declared codes into the canonical ISO flags ahead of the regular consumers. Machine-level (per-case parameter table) rather than brand vocabulary — implemented by ControllerParameterTableBase, alongside the narrower ISpindleControlConfig face over the same storage. public interface IMCodeDeclarationConfig : INcDependency, IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties MCodeDeclarations Declared machine M-codes. Key = M-code as parsed (e.g. “M13”), matched case-insensitively; value = the effects the code performs. Enumerable for UI/serialization. IReadOnlyDictionary<string, MCodeEffects> MCodeDeclarations { get; } Property Value IReadOnlyDictionary<string, MCodeEffects> Methods DeclareMCode(string, MCodeEffects) Adds or replaces the declaration for an M-code. The effects are copied on store, so the caller may reuse or further mutate its instance without coupling declarations to each other. void DeclareMCode(string mCode, MCodeEffects effects) Parameters mCode string effects MCodeEffects RemoveMCodeDeclaration(string) Removes the declaration for an M-code. void RemoveMCodeDeclaration(string mCode) Parameters mCode string TryGetMCodeEffects(string, out MCodeEffects) Resolves a parsed flag to its declared effects. Returns false for undeclared codes — ISO defaults are the consumers' concern, not this config's. The returned instance is the live declaration: treat it as read-only and reconfigure through DeclareMCode(string, MCodeEffects) instead of mutating it. bool TryGetMCodeEffects(string mCode, out MCodeEffects effects) Parameters mCode string effects MCodeEffects Returns bool"
  },
  "api/Hi.NcParsers.Dependencys.IMachineAxisConfig.html": {
    "href": "api/Hi.NcParsers.Dependencys.IMachineAxisConfig.html",
    "title": "Interface IMachineAxisConfig | HiAPI-C# 2025",
    "summary": "Interface IMachineAxisConfig Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll Machine axis configuration: which axes exist and their types. Compatible with Fanuc, Siemens, Heidenhain, Mazak, Okuma. public interface IMachineAxisConfig : INcDependency, IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties AxisNames Gets the configured axis names in order. IEnumerable<string> AxisNames { get; } Property Value IEnumerable<string> Methods IsModularRotary(string) Whether the rotary axis wraps 0°–360° (modular). Affects cyclic shortest-path resolution. Returns false for linear axes. bool IsModularRotary(string axisName) Parameters axisName string Returns bool IsRotaryAxis(string) Returns true if the axis is rotary or spindle, false if linear. bool IsRotaryAxis(string axisName) Parameters axisName string Returns bool RemoveAxis(string) Removes an axis from the configuration. void RemoveAxis(string axisName) Parameters axisName string SetAxis(string, AxisType) Adds or updates an axis with the specified type. void SetAxis(string axisName, AxisType type) Parameters axisName string type AxisType"
  },
  "api/Hi.NcParsers.Dependencys.INcDependency.html": {
    "href": "api/Hi.NcParsers.Dependencys.INcDependency.html",
    "title": "Interface INcDependency | HiAPI-C# 2025",
    "summary": "Interface INcDependency Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll Marker interface for objects that participate in the NC dependency list resolved by the soft-NC runtime. public interface INcDependency : IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.NcParsers.Dependencys.INcDependencyListHost.html": {
    "href": "api/Hi.NcParsers.Dependencys.INcDependencyListHost.html",
    "title": "Interface INcDependencyListHost | HiAPI-C# 2025",
    "summary": "Interface INcDependencyListHost Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll Hosts a per-case INcDependency list that INcDependencyProxy placeholders in a shared SoftNcRunner resolve their data against. Implemented by the object owning both the shared runner and the varied setting data — e.g. MachiningProject. public interface INcDependencyListHost Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties PerCaseNcDependencyList The case-specific dependencies (tool offsets, coordinate tables, parameter tables, …) that proxies take from — never the runner's own fixed list. A get-or-create proxy may also append the dependency it makes here. List<INcDependency> PerCaseNcDependencyList { get; } Property Value List<INcDependency>"
  },
  "api/Hi.NcParsers.Dependencys.INcDependencyProxy.html": {
    "href": "api/Hi.NcParsers.Dependencys.INcDependencyProxy.html",
    "title": "Interface INcDependencyProxy | HiAPI-C# 2025",
    "summary": "Interface INcDependencyProxy Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll An INcDependency placeholder that resolves the real dependency lazily at pipeline-build time instead of carrying the data itself. Lets a shared SoftNcRunner hold only the fixed pipeline logic while the frequently-varied data lives on the owning INcDependencyListHost (e.g. a MachiningProject). \"Maker and taker\": GetNcDependency() either constructs the dependency on demand (maker) or fetches one from the host wired by InitNcDependencyHost(INcDependencyListHost) (taker). A get-or-create proxy does both — it takes the host's instance when present and otherwise makes one, installing it into the host list so it persists and is editable per case. A proxy may carry runtime-only state (the wired host, a memoized resolved dependency). That state is host-wired per run and MUST NOT be written by MakeXmlSource(string, string, bool) — same runtime-only posture as ProjectFolderDependency. public interface INcDependencyProxy : INcDependency, IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetNcDependency() Resolves the concrete dependency this proxy stands in for. Called by GetEffectiveNcDependencyList() to build the list passed to every Build / Resolve / Expand / Initialize / GetSentences call. May return null when no host is wired or it supplied no matching data — callers null-check individual dependencies. INcDependency GetNcDependency() Returns INcDependency InitNcDependencyHost(INcDependencyListHost) Wires the host whose PerCaseNcDependencyList this proxy takes from (or makes against). Called by the host / project service before the pipeline runs — mirrors how BaseDirectoryProvider is wired from HiNc. Runtime-only; not persisted. A get-or-create proxy may also materialize its data into the host list here, so the per-case dependency exists and is editable before any run. void InitNcDependencyHost(INcDependencyListHost host) Parameters host INcDependencyListHost The owner of the per-case dependency data."
  },
  "api/Hi.NcParsers.Dependencys.IPowerResettable.html": {
    "href": "api/Hi.NcParsers.Dependencys.IPowerResettable.html",
    "title": "Interface IPowerResettable | HiAPI-C# 2025",
    "summary": "Interface IPowerResettable Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll Marks an INcDependency that holds volatile state which must be cleared when the controller performs a power reset (power off then on). Implementers should clear only the volatile subset they own (e.g. Fanuc common volatile macro variables #100-#499), and leave persistent state untouched (e.g. #500-#999, controller parameters). Call-frame local state (Fanuc #1-#33, Heidenhain Q200-Q1199) is NOT in scope — that lives in the SyntaxPiece JSON dataflow and is bounded by call activation, not power cycle. public interface IPowerResettable : INcDependency, IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods OnPowerReset() Clears the volatile subset owned by this dependency. Called by SessionShell.PowerReset() for every IPowerResettable in the active NcDependencyList. void OnPowerReset()"
  },
  "api/Hi.NcParsers.Dependencys.IRapidFeedrateConfig.html": {
    "href": "api/Hi.NcParsers.Dependencys.IRapidFeedrateConfig.html",
    "title": "Interface IRapidFeedrateConfig | HiAPI-C# 2025",
    "summary": "Interface IRapidFeedrateConfig Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll Provides per-axis rapid traverse feedrate for motion semantics. Implemented by ControllerParameterTableBase using brand-specific parameter numbers (e.g., Fanuc #1420, Siemens MD32000, Heidenhain MP1010). public interface IRapidFeedrateConfig : INcDependency, IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetLinearAxisRapidRate_mmdmin(string) Gets rapid traverse feedrate for a linear axis in mm/min. Returns a default value if the axis is not configured. double GetLinearAxisRapidRate_mmdmin(string axisName) Parameters axisName string Returns double GetRotaryAxisRapidRate_degdmin(string) Gets rapid traverse feedrate for a rotary axis in deg/min. Returns a default value if the axis is not configured. double GetRotaryAxisRapidRate_degdmin(string axisName) Parameters axisName string Returns double SetLinearAxisRapidRate_mmdmin(string, double) Sets rapid traverse feedrate for a linear axis in mm/min. void SetLinearAxisRapidRate_mmdmin(string axisName, double value) Parameters axisName string value double SetRotaryAxisRapidRate_degdmin(string, double) Sets rapid traverse feedrate for a rotary axis in deg/min. void SetRotaryAxisRapidRate_degdmin(string axisName, double value) Parameters axisName string value double"
  },
  "api/Hi.NcParsers.Dependencys.ISpindleControlConfig.html": {
    "href": "api/Hi.NcParsers.Dependencys.ISpindleControlConfig.html",
    "title": "Interface ISpindleControlConfig | HiAPI-C# 2025",
    "summary": "Interface ISpindleControlConfig Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll Machine-specific spindle control codes: maps custom spindle direction M-codes to SpindleDirection — e.g., an ultrasonic spindle started by M203 (CW) and stopped by M205 (STOP) instead of ISO M03/M05. Consulted by SpindleSpeedSyntax in addition to the built-in ISO defaults (M03/M04/M05), which always stay in effect; a configured code wins over its ISO meaning when both match. Machine-level (per-case parameter table) rather than brand vocabulary — implemented by ControllerParameterTableBase as a spindle-direction face over its MCodeDeclarations storage (the multi-effect IMCodeDeclarationConfig map), so one code is never half-recognized by two separate maps. public interface ISpindleControlConfig : INcDependency, IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties SpindleDirectionCodes Configured custom spindle direction M-codes. Key = M-code as parsed (e.g., “M203”), matched case-insensitively; value = resulting direction. Enumerable for UI/serialization. IReadOnlyDictionary<string, SpindleDirection> SpindleDirectionCodes { get; } Property Value IReadOnlyDictionary<string, SpindleDirection> Methods ConfigureSpindleDirectionCode(string, SpindleDirection) Adds or updates a custom spindle direction M-code. void ConfigureSpindleDirectionCode(string mCode, SpindleDirection direction) Parameters mCode string direction SpindleDirection RemoveSpindleDirectionCode(string) Removes a custom spindle direction M-code. void RemoveSpindleDirectionCode(string mCode) Parameters mCode string TryResolveDirection(string, out SpindleDirection) Resolves a parsed flag to a spindle direction. Returns true only for configured custom codes whose declaration carries no other effect — the caller consumes the whole flag for this one meaning, so a composite declaration (e.g. spindle + coolant) must instead be expanded by MCodeExpansionSyntax to keep its other halves alive. ISO M03/M04/M05 defaults are the caller's fallback, not this config's concern. bool TryResolveDirection(string mCode, out SpindleDirection direction) Parameters mCode string direction SpindleDirection Returns bool"
  },
  "api/Hi.NcParsers.Dependencys.IStrokeLimitConfig.html": {
    "href": "api/Hi.NcParsers.Dependencys.IStrokeLimitConfig.html",
    "title": "Interface IStrokeLimitConfig | HiAPI-C# 2025",
    "summary": "Interface IStrokeLimitConfig Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll Per-axis stroke (travel) limits. Unit is mm for linear axes, deg for rotary axes. Implemented by ControllerParameterTableBase using brand-specific parameter numbers (e.g., Fanuc #1300/#1320, Siemens MD36100/MD36110, Heidenhain MP420/MP430). public interface IStrokeLimitConfig : INcDependency, IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods CheckStrokeLimit(DVec3d, IProgress<IMessage>) Checks whether a position is within all configured stroke limits. bool CheckStrokeLimit(DVec3d mcXyzabc, IProgress<IMessage> stripReporter = null) Parameters mcXyzabc DVec3d Machine coordinate. Point = XYZ (mm), Normal = ABC (rad). stripReporter IProgress<IMessage> Progress sink for cutter-location strip updates. Can be null. Returns bool True if within all limits or no limits configured. GetNegativeLimit(string) Gets the negative stroke limit for a specific axis. Unit is mm for linear axes, deg for rotary axes. Returns null if not configured (no limit). double? GetNegativeLimit(string axisName) Parameters axisName string Returns double? GetPositiveLimit(string) Gets the positive stroke limit for a specific axis. Unit is mm for linear axes, deg for rotary axes. Returns null if not configured (no limit). double? GetPositiveLimit(string axisName) Parameters axisName string Returns double? SetNegativeLimit(string, double) Sets the negative stroke limit for a specific axis. Unit is mm for linear axes, deg for rotary axes. void SetNegativeLimit(string axisName, double value) Parameters axisName string value double SetPositiveLimit(string, double) Sets the positive stroke limit for a specific axis. Unit is mm for linear axes, deg for rotary axes. void SetPositiveLimit(string axisName, double value) Parameters axisName string value double"
  },
  "api/Hi.NcParsers.Dependencys.IToolChangeTriggerConfig.html": {
    "href": "api/Hi.NcParsers.Dependencys.IToolChangeTriggerConfig.html",
    "title": "Interface IToolChangeTriggerConfig | HiAPI-C# 2025",
    "summary": "Interface IToolChangeTriggerConfig Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll Machine-level tool-change trigger mode. Machining centers with a magazine treat a bare T word as pre-selection only (the magazine rotates, no feed axis moves) and change the tool on the trigger M-code; lathes/turret machines index the turret — and thereby change the tool — on the T word itself. Real controllers declare this per machine (e.g. Siemens MD22550 $MC_TOOL_CHANGE_MODE, where 0 means the T word performs the change). Consulted by ToolChangeSyntax; machine-level (per-case parameter table) rather than brand vocabulary — implemented by ControllerParameterTableBase. Custom trigger M-codes are the separate IMCodeDeclarationConfig concern (IsToolChange). public interface IToolChangeTriggerConfig : INcDependency, IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties ToolWordTriggersChange When true, a block carrying a T word performs the tool change by itself (turret semantics); default false keeps the ISO machining-center behavior where only the trigger M-code changes the tool and T merely arms the selection. bool ToolWordTriggersChange { get; set; } Property Value bool"
  },
  "api/Hi.NcParsers.Dependencys.IToolOffsetConfig.html": {
    "href": "api/Hi.NcParsers.Dependencys.IToolOffsetConfig.html",
    "title": "Interface IToolOffsetConfig | HiAPI-C# 2025",
    "summary": "Interface IToolOffsetConfig Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll Tool offset configuration indexed by a single integer offset number. Applies to Fanuc (H/D numbers), Heidenhain (tool number), Mazak, Okuma, and other ISO-compatible controllers where one integer selects the offset row. For Siemens (840D/Sinumerik) where offsets are addressed by (tool number, cutting edge D number), see ISiemensToolOffsetConfig. public interface IToolOffsetConfig Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetToolHeightOffset_mm(int) Gets the effective tool height offset (geometry - wear) in mm. Returns 0 if the offset number is not configured — indistinguishable from a configured zero; a consumer that must warn on a vacant row uses TryGetToolHeightOffset_mm(int, out double). double GetToolHeightOffset_mm(int offsetNumber) Parameters offsetNumber int Offset number: Fanuc H number, Heidenhain tool number, etc. Returns double GetToolRadiusOffset_mm(int) Gets the effective tool radius offset (geometry - wear) in mm. Returns 0 if the offset number is not configured — indistinguishable from a configured zero; a consumer that must warn on a vacant row uses TryGetToolRadiusOffset_mm(int, out double). double GetToolRadiusOffset_mm(int offsetNumber) Parameters offsetNumber int Offset number: Fanuc D number, Heidenhain tool number, etc. Returns double SetToolOffset(int, double, double, double, double) Sets all four offset components for the given offset number. void SetToolOffset(int offsetNumber, double idealHeight_mm, double axialWear_mm, double idealRadius_mm, double radialWear_mm) Parameters offsetNumber int idealHeight_mm double axialWear_mm double idealRadius_mm double radialWear_mm double TryGetToolHeightOffset_mm(int, out double) Attempts to get the effective tool height offset (geometry - wear) in mm. Returns false when offsetNumber has no configured row — the only reliable miss signal, since 0 is a legal configured offset. The compensation syntaxes warn on a miss (Comp-ToolHeight–RowMissing) instead of silently machining with a zero-length tool. bool TryGetToolHeightOffset_mm(int offsetNumber, out double height_mm) Parameters offsetNumber int Offset number: Fanuc H number, Heidenhain tool number, etc. height_mm double The effective height offset; 0 on miss. Returns bool TryGetToolRadiusOffset_mm(int, out double) Attempts to get the effective tool radius offset (geometry - wear) in mm. Returns false when offsetNumber has no configured row (see TryGetToolHeightOffset_mm(int, out double)). bool TryGetToolRadiusOffset_mm(int offsetNumber, out double radius_mm) Parameters offsetNumber int Offset number: Fanuc D number, Heidenhain tool number, etc. radius_mm double The effective radius offset; 0 on miss. Returns bool"
  },
  "api/Hi.NcParsers.Dependencys.IToolingMcConfig.html": {
    "href": "api/Hi.NcParsers.Dependencys.IToolingMcConfig.html",
    "title": "Interface IToolingMcConfig | HiAPI-C# 2025",
    "summary": "Interface IToolingMcConfig Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll Machine position axes move to during tool change (M06). public interface IToolingMcConfig : INcDependency, IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties ToolingMcAbc_deg ABC tooling position in degrees. NaN per missing or stay-in-place axis. Vec3d ToolingMcAbc_deg { get; set; } Property Value Vec3d ToolingMcXyz XYZ tooling position. NaN per missing or stay-in-place axis. Vec3d ToolingMcXyz { get; set; } Property Value Vec3d ToolingTime Duration of the tool changer mechanism (arm swap, magazine rotation, etc.). Does not include axis motion time to/from the tooling position. TimeSpan ToolingTime { get; set; } Property Value TimeSpan Methods GetToolingPosition(string) Gets the tooling position for a specific axis. Returns NaN if the axis should stay where it is. Returns null if the axis has no tooling position configured. double? GetToolingPosition(string axisName) Parameters axisName string Returns double? SetToolingPosition(string, double) Sets the tooling position for a specific axis. Use NaN to indicate the axis should stay. void SetToolingPosition(string axisName, double value) Parameters axisName string value double"
  },
  "api/Hi.NcParsers.Dependencys.IsoCoordinateAddressMap.html": {
    "href": "api/Hi.NcParsers.Dependencys.IsoCoordinateAddressMap.html",
    "title": "Class IsoCoordinateAddressMap | HiAPI-C# 2025",
    "summary": "Class IsoCoordinateAddressMap Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll Fanuc-style ISO coordinate parameter address mapping. G54–G59 → #5221+ (stride 20, three consecutive numbers per entry for X/Y/Z), G54.1 P1–P48 → #7001+ (stride 20). Shared between FanucParameterTable (which calls these “ParamId”) and SyntecParameterTable (which calls them “PrId”) because both follow the same numeric scheme. public static class IsoCoordinateAddressMap Inheritance object IsoCoordinateAddressMap Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields G54Base #5221: base address of G54 (X). G54.Y=#5222, G54.Z=#5223. public const int G54Base = 5221 Field Value int G54p1CoordinateIdPrefix Coordinate-id prefix of the additional (G54.1 P) work coordinate systems: the id is this prefix followed by the un-padded P index, e.g. “G54.1P4” — the G-code spelling without its embedded space. public const string G54p1CoordinateIdPrefix = \"G54.1P\" Field Value string G54p1P1Base #7001: base address of G54.1 P1 (X). G54.1 P1.Y=#7002, P1.Z=#7003. public const int G54p1P1Base = 7001 Field Value int G54p1PCount 48: number of G54.1 P entries (P1..P48). public const int G54p1PCount = 48 Field Value int G5xCount 6: number of G5x entries (G54..G59). public const int G5xCount = 6 Field Value int Stride 20: address stride between successive coordinate entries. public const int Stride = 20 Field Value int Methods DescribeAddress(int) Inverse of TryResolveBase(string) per single address: describes an address inside the mapped ranges as its work-coordinate component (“G54 X offset”, “G54.1P3 Z offset”), or null outside them (including the unused tail of each 20-address stride). public static string DescribeAddress(int addr) Parameters addr int Parameter address (e.g. 5222). Returns string EnumerateCoordinateIds(IDictionary<int, double>) Enumerates the coordinate ids (G54..G59, G54.1P1..G54.1P48) that have at least one axis entry present in systemParams. public static IEnumerable<string> EnumerateCoordinateIds(IDictionary<int, double> systemParams) Parameters systemParams IDictionary<int, double> Returns IEnumerable<string> G54p1CoordinateId(int) Composes the coordinate id of additional work coordinate system p (“G54.1P4” for P4). Inverse of TryParseG54p1Index(string, out int). public static string G54p1CoordinateId(int p) Parameters p int P index as written in the program (1-based). Returns string Read(IDictionary<int, double>, int) Reads X/Y/Z from systemParams at consecutive addresses starting at baseAddr. Returns null when none of the three addresses are present (i.e. the entry is unmanaged). public static Vec3d Read(IDictionary<int, double> systemParams, int baseAddr) Parameters systemParams IDictionary<int, double> baseAddr int Returns Vec3d SeedAllDefaults(IDictionary<int, double>) Seeds all G54–G59 and G54.1 P1–P48 entries with zero. Total 162 SystemParams entries (6×3 + 48×3). Used by brand parameter tables to satisfy the “managed parameter must have default” invariant — real Fanuc on a fresh-battery controller also reads 0 for these addresses, so the model matches hardware. public static void SeedAllDefaults(IDictionary<int, double> systemParams) Parameters systemParams IDictionary<int, double> TryParseG54p1Index(string, out int) Reads the P index back out of an additional work coordinate id (“G54.1P4” → 4). Any integer is accepted — range checking against the table (1..G54p1PCount) is TryResolveBase(string)'s job — so a caller can tell “an additional system whose index the table does not hold” apart from “not an additional system at all”. public static bool TryParseG54p1Index(string coordId, out int p) Parameters coordId string Coordinate id to inspect. p int The parsed index on success. Returns bool TryResolveBase(string) Resolves a coordinate id to its 3-axis base address (X address; Y at +1, Z at +2), or null if the id is outside the Fanuc-mapped set (G54–G59, G54.1P1–G54.1P48). public static int? TryResolveBase(string coordId) Parameters coordId string Returns int? Write(IDictionary<int, double>, int, Vec3d) Writes X/Y/Z to systemParams at consecutive addresses starting at baseAddr. public static void Write(IDictionary<int, double> systemParams, int baseAddr, Vec3d offset) Parameters systemParams IDictionary<int, double> baseAddr int offset Vec3d"
  },
  "api/Hi.NcParsers.Dependencys.MCodeEffects.html": {
    "href": "api/Hi.NcParsers.Dependencys.MCodeEffects.html",
    "title": "Class MCodeEffects | HiAPI-C# 2025",
    "summary": "Class MCodeEffects Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll What one machine-declared M-code does. Real-machine OEM M-codes are frequently composite — e.g. an M13 that means “spindle CW + flood coolant on” — so a declaration carries every effect the code performs rather than a single meaning, and additionally an UnmodeledNote for the parts this simulation does not model. Declaring only the known parts and staying loud about the rest keeps a composite code from being half-consumed silently. Stored per machine in MCodeDeclarations and consumed by MCodeExpansionSyntax, which expands the declared code into the canonical ISO flags the regular consumers already understand. public class MCodeEffects Inheritance object MCodeEffects Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties CoolantMode Coolant mode the code commands (expands to M07/M08/M09): one of Mist, Flood, Off. null/empty when the code does not touch coolant. public string CoolantMode { get; set; } Property Value string IsEmpty True when the declaration carries no effect and no note — such an entry means “consume this code silently; it is irrelevant to simulation”. public bool IsEmpty { get; } Property Value bool IsSpindleDirectionOnly True when SpindleDirection is the declaration's sole content. The two consumption paths partition on this: only such declarations resolve through TryResolveDirection(string, out SpindleDirection) (whose caller consumes the whole flag in place, preserving legacy behavior), and MCodeExpansionSyntax deliberately skips them and expands only composite declarations, so no effect is swallowed and nothing is translated twice. public bool IsSpindleDirectionOnly { get; } Property Value bool IsToolChange The code performs a tool change (expands to M06) — the machine-configurable trigger real controllers declare via e.g. Siemens MD22560 $MC_TOOL_CHANGE_M_CODE. public bool IsToolChange { get; set; } Property Value bool SpindleDirection Spindle direction the code commands (expands to M03/M04/M05), or null when the code does not touch the spindle. public SpindleDirection? SpindleDirection { get; set; } Property Value SpindleDirection? UnmodeledNote Free-text description of what the code additionally does on the real machine that this simulation does not model (e.g. “chip conveyor forward”). When set, consuming the code emits one informational diagnostic per occurrence instead of staying silent — a declaration must not downgrade the visible Parsing–Unconsumed warning into nothing. public string UnmodeledNote { get; set; } Property Value string Methods Clone() Returns an independent copy of this declaration. public MCodeEffects Clone() Returns MCodeEffects NormalizeCoolantMode(string) Maps a raw coolant-mode string to the canonical Coolant constant (case-insensitive), or null when the value names no known mode. public static string NormalizeCoolantMode(string value) Parameters value string Returns string"
  },
  "api/Hi.NcParsers.Dependencys.Siemens.ISiemensToolOffsetConfig.html": {
    "href": "api/Hi.NcParsers.Dependencys.Siemens.ISiemensToolOffsetConfig.html",
    "title": "Interface ISiemensToolOffsetConfig | HiAPI-C# 2025",
    "summary": "Interface ISiemensToolOffsetConfig Namespace Hi.NcParsers.Dependencys.Siemens Assembly HiMech.dll Siemens (840D/Sinumerik) tool offset configuration. Offsets are addressed by (tool number T, cutting edge D number), unlike IToolOffsetConfig where a single integer selects the row. Siemens stores up to 25 data fields per cutting edge ($TC_DP1..$TC_DP25), including three independent length components (L1/L2/L3 for Z/X/Y directions), radius, and corresponding wear values. public interface ISiemensToolOffsetConfig Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetToolHeightOffset_mm(int, int) Gets the effective tool height offset in mm for a specific tool and cutting edge: $TC_DP3 (length 1, typically Z direction) plus its additive wear $TC_DP12 — Sinumerik wear values are added, a shortened tool carries negative wear. Returns 0 if the tool/edge is not configured. double GetToolHeightOffset_mm(int toolNumber, int edgeNumber) Parameters toolNumber int Tool number (T). edgeNumber int Cutting edge number (D). Returns double GetToolLengthOffset_mm(int, int, int) Gets an additional length offset for the specified direction. directionIndex: 0 = L1 ($TC_DP3, Z), 1 = L2 ($TC_DP4, X), 2 = L3 ($TC_DP5, Y). Returns 0 if not configured. double GetToolLengthOffset_mm(int toolNumber, int edgeNumber, int directionIndex) Parameters toolNumber int edgeNumber int directionIndex int Returns double GetToolRadiusOffset_mm(int, int) Gets the effective tool radius offset in mm for a specific tool and cutting edge: $TC_DP6 (radius) plus its additive wear $TC_DP15. Returns 0 if the tool/edge is not configured. double GetToolRadiusOffset_mm(int toolNumber, int edgeNumber) Parameters toolNumber int Tool number (T). edgeNumber int Cutting edge number (D). Returns double TryGetToolHeightOffset_mm(int, int, out double) Attempts to get the effective tool height offset in mm ($TC_DP3 plus additive wear $TC_DP12) for a specific tool and cutting edge. Returns false when the (tool, edge) pair has no configured row, so the caller can fall back to another source (e.g. the generic IToolOffsetConfig). This is the only reliable miss signal — 0.0 is a legal configured offset, so the zero returned by GetToolHeightOffset_mm(int, int) cannot distinguish a vacant row from a configured zero. bool TryGetToolHeightOffset_mm(int toolNumber, int edgeNumber, out double offset_mm) Parameters toolNumber int Tool number (T). edgeNumber int Cutting edge number (D). offset_mm double The effective height offset; 0 on miss. Returns bool"
  },
  "api/Hi.NcParsers.Dependencys.Siemens.SiemensFrameTable.html": {
    "href": "api/Hi.NcParsers.Dependencys.Siemens.SiemensFrameTable.html",
    "title": "Class SiemensFrameTable | HiAPI-C# 2025",
    "summary": "Class SiemensFrameTable Namespace Hi.NcParsers.Dependencys.Siemens Assembly HiMech.dll Sinumerik settable work coordinate frames ($P_UIFR[n]). Models G54–G57 (ISO-compatible), G505–G599 (extended Siemens), and G500 (cancel — always zero). On real Sinumerik, $P_UIFR is a frame array containing translation, rotation, scale and mirror per entry. HiNC currently consumes only the translation component, so this table stores Vec3d per id. $P_UIFR is NOT in the machine data table — therefore this is a separate dependency from SiemensMachineDataTable (which holds MD-prefixed OEM machine data such as MD30300 axis type, MD34010 reference position, etc.). Deliberately not ISessionResettable: settable frames are setting data on the control — a $P_UIFR write from the program survives reset and power-off, so a replayed session must see the values the previous run wrote. public class SiemensFrameTable : IIsoCoordinateConfig, INcDependency, IMakeXmlSource Inheritance object SiemensFrameTable Implements IIsoCoordinateConfig INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SiemensFrameTable() Initializes a new instance with G54-G57 and the Siemens extended G505-G599 series seeded as zero Vec3d entries in Frames. public SiemensFrameTable() SiemensFrameTable(XElement) Initializes a new instance by deserializing from src. public SiemensFrameTable(XElement src) Parameters src XElement XML element produced by MakeXmlSource(string, string, bool). Properties AxisOffsets Per-axis translation components beyond X/Y/Z, keyed by G-code id then uppercase axis letter (e.g. [“G54”][“C”] = 12.5). Real Sinumerik frames carry a translation per machine axis including rotaries ($P_UIFR[1,C,TR]); X/Y/Z stay in Frames so existing consumers (GetCoordinateOffset(string)) are unaffected. Absent entries read as 0 — matching Sinumerik where every allocated frame axis defaults to zero. Rotary components are recorded/read through the $P_UIFR bridge; the transform chain does not consume them yet (frame work owns that). public Dictionary<string, Dictionary<string, double>> AxisOffsets { get; set; } Property Value Dictionary<string, Dictionary<string, double>> CoordinateIds Enumerates the G-code coordinate ids that this provider currently has data for. public IEnumerable<string> CoordinateIds { get; } Property Value IEnumerable<string> Frames Settable frames keyed by G-code id. G500 is treated specially (always zero) and is not stored here. public Dictionary<string, Vec3d> Frames { get; set; } Property Value Dictionary<string, Vec3d> XName XML element name for serialization. public static string XName { get; } Property Value string Methods GetAxisOffset(string, string) Reads one axis translation component of a frame ($P_UIFR[n,axis,TR] read side). X/Y/Z route into Frames; any other axis letter reads AxisOffsets with 0 as the allocated-but-unset default. G500 is always 0. Returns null only when coordId is not an allocated frame — the caller's lookup chain then falls through (vacant). public double? GetAxisOffset(string coordId, string axis) Parameters coordId string Frame G-code id (e.g. G54, G505). axis string Uppercase axis letter (e.g. X, C). Returns double? GetCoordinateOffset(string) Gets the offset for the given G-code coordinate id. Returns null when no offset is configured for that id by this provider (callers iterate the next provider, or fall back to Zero). public Vec3d GetCoordinateOffset(string coordId) Parameters coordId string Returns Vec3d MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetAxisOffset(string, string, double) Writes one axis translation component of a frame ($P_UIFR[n,axis,TR]=… write side). X/Y/Z replace the component inside Frames (a fresh Vec3d is installed — never in-place mutation, so aliased vectors stay unaffected); other axis letters land in AxisOffsets. G500 writes are ignored, mirroring SetCoordinateOffset(string, Vec3d). public void SetAxisOffset(string coordId, string axis, double value) Parameters coordId string Frame G-code id. axis string Uppercase axis letter. value double New translation component value. SetCoordinateOffset(string, Vec3d) Sets the offset for the given G-code coordinate id. public void SetCoordinateOffset(string coordId, Vec3d offset) Parameters coordId string offset Vec3d"
  },
  "api/Hi.NcParsers.Dependencys.Siemens.SiemensFrameTableProxy.html": {
    "href": "api/Hi.NcParsers.Dependencys.Siemens.SiemensFrameTableProxy.html",
    "title": "Class SiemensFrameTableProxy | HiAPI-C# 2025",
    "summary": "Class SiemensFrameTableProxy Namespace Hi.NcParsers.Dependencys.Siemens Assembly HiMech.dll Get-or-create INcDependencyProxy for SiemensFrameTable: a placeholder in the shared PipelineNcDependencyList that resolves the host project's own per-case settable work frames ($P_UIFR, G54–G57…). public sealed class SiemensFrameTableProxy : INcDependencyProxy, INcDependency, IMakeXmlSource Inheritance object SiemensFrameTableProxy Implements INcDependencyProxy INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods GetNcDependency() Takes the host's SiemensFrameTable (created during InitNcDependencyHost(INcDependencyListHost)). Returns null when no host is wired. public INcDependency GetNcDependency() Returns INcDependency InitNcDependencyHost(INcDependencyListHost) Wires the host and materializes the per-case SiemensFrameTable: when the host list has none, one is created and installed so it exists and is editable before any run. GetNcDependency() is then a pure take. Idempotent — an existing table is left untouched. public void InitNcDependencyHost(INcDependencyListHost host) Parameters host INcDependencyListHost MakeXmlSource(string, string, bool) Runtime-only proxy — the wired host and the resolved table are not persisted in the shared runner; serialization writes only the empty element. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.Siemens.SiemensGotoIterationDependency.html": {
    "href": "api/Hi.NcParsers.Dependencys.Siemens.SiemensGotoIterationDependency.html",
    "title": "Class SiemensGotoIterationDependency | HiAPI-C# 2025",
    "summary": "Class SiemensGotoIterationDependency Namespace Hi.NcParsers.Dependencys.Siemens Assembly HiMech.dll Watchdog for Siemens GOTOF/GOTOB jumps — the label-keyed sibling of the Fanuc FanucGotoIterationDependency, with the same “soft-cap + runtime counter + session-init ISessionResettable” shape. Kept per-brand (rather than widening the Fanuc dep's int-keyed bucket) for diagnostic clarity and because Siemens targets are named labels, not N-numbers. The counter key is (FileName, Label) where FileName is the source-level file path of the jump host (the relative form carried on FilePath). Source-level keying means multiple inline invocations of the same subprogram pool their counts, while two files each jumping to their own LBL1 stay isolated. Forward and backward jumps to the same label share one bucket — only the backward direction can loop, but a shared bucket keeps the accounting simple and the cap generous. The consuming syntax (SiemensGotoSyntax) counts after the condition gate and before the label scan; above MaxIterationsPerLabel the jump warns SiemensGoto--IterationLimitExceeded and falls through. A missing dependency disables the cap (Fanuc parity) — the brand preset wires one by default. public class SiemensGotoIterationDependency : INcDependency, IMakeXmlSource, ISessionResettable Inheritance object SiemensGotoIterationDependency Implements INcDependency IMakeXmlSource ISessionResettable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SiemensGotoIterationDependency() Initializes a new instance with the default limit and an empty counter. public SiemensGotoIterationDependency() SiemensGotoIterationDependency(XElement) Loads MaxIterationsPerLabel from XML produced by MakeXmlSource(string, string, bool); absent element falls back to DefaultMaxIterationsPerLabel. public SiemensGotoIterationDependency(XElement src) Parameters src XElement Root element named XName. Fields DefaultMaxIterationsPerLabel Default for MaxIterationsPerLabel — matches the Fanuc GOTO default: jumps are not the legitimate bulk-iteration primitive (the loop constructs are), so the cap stays tight. public const int DefaultMaxIterationsPerLabel = 1000 Field Value int Properties CountByLabel Per-target hit counter keyed by (FileName, Label). Runtime-only; not serialised. Cleared by OnSessionReset() on the session-init edge. public Dictionary<(string FileName, string Label), int> CountByLabel { get; } Property Value Dictionary<(string FileName, string Label), int> MaxIterationsPerLabel Soft cap on fired jumps for any single (FileName, Label) pair. Above this the host block emits SiemensGoto–IterationLimitExceeded and falls through. public int MaxIterationsPerLabel { get; set; } Property Value int XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. OnSessionReset() Clears CountByLabel; leaves MaxIterationsPerLabel untouched. public void OnSessionReset() Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.Siemens.SiemensLoopIterationDependency.html": {
    "href": "api/Hi.NcParsers.Dependencys.Siemens.SiemensLoopIterationDependency.html",
    "title": "Class SiemensLoopIterationDependency | HiAPI-C# 2025",
    "summary": "Class SiemensLoopIterationDependency Namespace Hi.NcParsers.Dependencys.Siemens Assembly HiMech.dll Watchdog shared by all four Siemens loop constructs (WHILE/ENDWHILE, FOR/ENDFOR, REPEAT/UNTIL, LOOP/ENDLOOP) — construct-neutral by design, unlike the Fanuc sibling (FanucWhileDoIterationDependency) which only has WHILE to guard. Same “soft-cap + runtime counter + session-init ISessionResettable” shape. Siemens loop constructs carry no LoopId, so the counter key is (FileName, BeginLineNo) — the loop-entry line recorded in the active frame identifies the construct uniquely within its file, and the file path isolates identically-numbered lines across files (and across inlined subprograms). The consuming syntax (SiemensLoopSyntax) counts at the back-jump step (the loop terminator / falsy UNTIL), so a loop whose condition is false from the outset consumes zero iterations. Above MaxIterationsPerLoop the terminator warns SiemensLoop--IterationLimitExceeded, pops the frame and falls through. A missing dependency disables the cap for the condition-bearing constructs (Fanuc parity) but hard-blocks the ENDLOOP back-jump — LOOP has no exit condition, so an uncapped back-jump would hang the pipeline deterministically. public class SiemensLoopIterationDependency : INcDependency, IMakeXmlSource, ISessionResettable Inheritance object SiemensLoopIterationDependency Implements INcDependency IMakeXmlSource ISessionResettable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SiemensLoopIterationDependency() Initializes a new instance with the default limit and an empty counter. public SiemensLoopIterationDependency() SiemensLoopIterationDependency(XElement) Loads MaxIterationsPerLoop from XML produced by MakeXmlSource(string, string, bool); absent element falls back to DefaultMaxIterationsPerLoop. public SiemensLoopIterationDependency(XElement src) Parameters src XElement Root element named XName. Fields DefaultMaxIterationsPerLoop Default for MaxIterationsPerLoop — matches the Fanuc WHILE default: loops are the legitimate iteration primitive (drill grids, calibration sweeps), so the cap is generous while still catching runaways in a tractable time. public const int DefaultMaxIterationsPerLoop = 10000 Field Value int Properties CountByLoop Per-loop hit counter keyed by (FileName, BeginLineNo). Runtime-only; not serialised. Cleared by OnSessionReset() on the session-init edge. public Dictionary<(string FileName, int BeginLineNo), int> CountByLoop { get; } Property Value Dictionary<(string FileName, int TargetN), int> MaxIterationsPerLoop Soft cap on back-jumps for any single (FileName, BeginLineNo) pair. Above this the terminator block emits SiemensLoop–IterationLimitExceeded, pops the frame and falls through. public int MaxIterationsPerLoop { get; set; } Property Value int XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. OnSessionReset() Clears CountByLoop; leaves MaxIterationsPerLoop untouched. public void OnSessionReset() Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.Siemens.SiemensMachineDataTable.html": {
    "href": "api/Hi.NcParsers.Dependencys.Siemens.SiemensMachineDataTable.html",
    "title": "Class SiemensMachineDataTable | HiAPI-C# 2025",
    "summary": "Class SiemensMachineDataTable Namespace Hi.NcParsers.Dependencys.Siemens Assembly HiMech.dll Siemens Sinumerik machine data table. Stores machine data (MD numbers) as system and per-axis parameters. MD10000–MD19999: General machine data. MD20000–MD29999: Axis-specific machine data. MD30000–MD39999: Axis-specific machine data (extended). Deliberately not ISessionResettable: machine data is control configuration a part program cannot mutate, so there is no session-scoped state to clear. public class SiemensMachineDataTable : ControllerParameterTableBase, IHomeMcConfig, IMachineAxisConfig, IRapidFeedrateConfig, IStrokeLimitConfig, ISpindleControlConfig, IMCodeDeclarationConfig, IToolChangeTriggerConfig, IIndexingPositionConfig, INcDependency, IMakeXmlSource Inheritance object ControllerParameterTableBase SiemensMachineDataTable Implements IHomeMcConfig IMachineAxisConfig IRapidFeedrateConfig IStrokeLimitConfig ISpindleControlConfig IMCodeDeclarationConfig IToolChangeTriggerConfig IIndexingPositionConfig INcDependency IMakeXmlSource Inherited Members ControllerParameterTableBase.GetLinearAxisRapidRate_mmdmin(string) ControllerParameterTableBase.GetRotaryAxisRapidRate_degdmin(string) ControllerParameterTableBase.SetLinearAxisRapidRate_mmdmin(string, double) ControllerParameterTableBase.SetRotaryAxisRapidRate_degdmin(string, double) ControllerParameterTableBase.GetPositiveLimit(string) ControllerParameterTableBase.GetNegativeLimit(string) ControllerParameterTableBase.SetPositiveLimit(string, double) ControllerParameterTableBase.SetNegativeLimit(string, double) ControllerParameterTableBase.SystemParams ControllerParameterTableBase.AxisParams ControllerParameterTableBase.IntAxisParams ControllerParameterTableBase.AxisParam(int) ControllerParameterTableBase.IntAxisParam(int) ControllerParameterTableBase.GetHomePosition(string) ControllerParameterTableBase.SetHomePosition(string, double) ControllerParameterTableBase.AxisNames ControllerParameterTableBase.IsRotaryAxis(string) ControllerParameterTableBase.SetAxis(string, AxisType) ControllerParameterTableBase.RemoveAxis(string) ControllerParameterTableBase.ConfigureRotaryAxis(string, double, double) ControllerParameterTableBase.MCodeDeclarations ControllerParameterTableBase.TryGetMCodeEffects(string, out MCodeEffects) ControllerParameterTableBase.DeclareMCode(string, MCodeEffects) ControllerParameterTableBase.RemoveMCodeDeclaration(string) ControllerParameterTableBase.SpindleDirectionCodes ControllerParameterTableBase.TryResolveDirection(string, out SpindleDirection) ControllerParameterTableBase.ConfigureSpindleDirectionCode(string, SpindleDirection) ControllerParameterTableBase.RemoveSpindleDirectionCode(string) ControllerParameterTableBase.ReadXml(XElement) ControllerParameterTableBase.WriteXml(string) ControllerParameterTableBase.CopyParamsTo(ControllerParameterTableBase) object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SiemensMachineDataTable() Initializes a new instance with empty machine data tables. public SiemensMachineDataTable() SiemensMachineDataTable(XElement) Initializes a new instance by deserializing from src. public SiemensMachineDataTable(XElement src) Parameters src XElement XML element produced by MakeXmlSource(string, string, bool). Fields MdAxisType MD30300: Axis type per axis (0=linear, 1=rotary, 2=spindle). public const int MdAxisType = 30300 Field Value int MdFixPointPos MD30600: Fixed point position per axis — the G75 target ($MA_FIX_POINT_POS). Fixed point 1 only; the Siemens per-axis array form (FP=2..4) is not modeled. public const int MdFixPointPos = 30600 Field Value int MdIndexAxAssignPosTab MD30500: Indexing table assignment per axis ($MA_INDEX_AX_ASSIGN_POS_TAB) — 0 = not an indexing axis, 1 = positions in IndexAxPosTab1, 2 = positions in IndexAxPosTab2, 3 = equidistant index intervals (MdIndexAxNumerator / MdIndexAxDenominator / MdIndexAxOffset). See IIndexingPositionConfig. public const int MdIndexAxAssignPosTab = 30500 Field Value int MdIndexAxDenominator MD30502: Equidistant indexing denominator per axis ($MA_INDEX_AX_DENOMINATOR) — on a modular rotary axis, the number of indexing positions per revolution. public const int MdIndexAxDenominator = 30502 Field Value int MdIndexAxNumerator MD30501: Equidistant indexing numerator per axis ($MA_INDEX_AX_NUMERATOR). Position spacing = numerator / denominator for non-modular axes; ignored on modular rotary axes, whose spacing is the 360° modulo range / MdIndexAxDenominator. public const int MdIndexAxNumerator = 30501 Field Value int MdIndexAxOffset MD30503: Absolute position of indexing position 1 per axis ($MA_INDEX_AX_OFFSET) for equidistant indexing. public const int MdIndexAxOffset = 30503 Field Value int MdMaxAxisVelocity MD32000: Max axis velocity per axis (mm/min or deg/min). public const int MdMaxAxisVelocity = 32000 Field Value int MdMaxSpindleSpeed MD35100: Maximum spindle speed (RPM). public const int MdMaxSpindleSpeed = 35100 Field Value int MdReferencePosition MD34010: Reference point position per axis. public const int MdReferencePosition = 34010 Field Value int MdStrokeLimitNeg MD36110: Negative stroke limit per axis. public const int MdStrokeLimitNeg = 36110 Field Value int MdStrokeLimitPos MD36100: Positive stroke limit per axis. public const int MdStrokeLimitPos = 36100 Field Value int MdToolChangeMCode MD22560: Tool change M function ($MC_TOOL_CHANGE_M_CODE, default 6). When the row is present, the named M code carries IsToolChange in the effective declaration view (overlaid at read time — see EffectiveMCodeDeclarations); when absent, only explicit MCodeDeclarations entries trigger a change. public const int MdToolChangeMCode = 22560 Field Value int MdToolChangeMode MD22550: Tool change mode ($MC_TOOL_CHANGE_MODE) — 0 = the T word itself performs the change (turret/lathe), 1 = an M function performs it while T only preselects. When the row is present it drives ToolWordTriggersChange; when absent the brand-neutral flag stands alone. public const int MdToolChangeMode = 22550 Field Value int OemAuxiliaryNote Note text for the OEM auxiliary M-codes the default preset declares note-only (M12/M13/M22/M23/M330/M331) — machine-specific codes recurring in real Siemens programs whose PLC behavior varies per machine and is not simulated. A note-only declaration keeps each occurrence visible as known-but-unmodeled (DeclaredMCode–UnmodeledEffects) instead of the unknown-code Parsing–Unconsumed warning; a machine table overrides the declaration with the actual effects when they are known. public const string OemAuxiliaryNote = \"machine-specific auxiliary function (OEM/PLC); the exact behavior depends on the machine\" Field Value string Properties AxisMd30300 MD30300: Axis type per axis. See AxisType. See AxisNames. public Dictionary<string, int> AxisMd30300 { get; set; } Property Value Dictionary<string, int> AxisMd30500 MD30500: Indexing table assignment per axis. See MdIndexAxAssignPosTab. public Dictionary<string, int> AxisMd30500 { get; set; } Property Value Dictionary<string, int> AxisMd30600 MD30600: Fixed point position per axis (fixed point 1 — the G75 target). See GetFixPointPosition(string). public Dictionary<string, double> AxisMd30600 { get; set; } Property Value Dictionary<string, double> AxisMd32000 MD32000: Max axis velocity per axis (mm/min or deg/min). See IRapidFeedrateConfig. public Dictionary<string, double> AxisMd32000 { get; set; } Property Value Dictionary<string, double> AxisMd34010 MD34010: Reference point position per axis. See IHomeMcConfig. public Dictionary<string, double> AxisMd34010 { get; set; } Property Value Dictionary<string, double> AxisTypeParamId Parameter/MD/MP number for axis type (linear/rotary/spindle). protected override int AxisTypeParamId { get; } Property Value int Default3Axis Default 3-axis Siemens milling machine. public static SiemensMachineDataTable Default3Axis { get; } Property Value SiemensMachineDataTable EffectiveMCodeDeclarations Overlays the MD22560 tool-change M function onto the declared M-codes: the named code gains IsToolChange (merged into a clone of its explicit declaration when one exists, so a note or coolant half is kept and the stored instance is never mutated). The overlay exists only in this read-time view — XML, MCodeDeclarations, and clones stay derivation-free and re-derive from the MD row. With no MD22560 row (or one already declared as a tool change) the stored dictionary is returned as-is, allocation-free. protected override IReadOnlyDictionary<string, MCodeEffects> EffectiveMCodeDeclarations { get; } Property Value IReadOnlyDictionary<string, MCodeEffects> IdAttributeName XML attribute name for the parameter ID (“ParamId”, “MdId”, “MpId”). protected override string IdAttributeName { get; } Property Value string IndexAxPosTab1 Indexing position table 1 (MD10910 $MN_INDEX_AX_POS_TAB_1), shared by every axis whose MdIndexAxAssignPosTab value is 1. Entry order is position-number order: entry [0] is indexing position 1. The used-length machine data (MD10900) is implied by the list count. Values follow the Siemens constraints (strictly ascending; within one revolution for modular rotary axes) — the lookups do not validate them. public List<double> IndexAxPosTab1 { get; set; } Property Value List<double> IndexAxPosTab2 Indexing position table 2 (MD10930 $MN_INDEX_AX_POS_TAB_2) — see IndexAxPosTab1; used-length MD10920 implied by the list count. public List<double> IndexAxPosTab2 { get; set; } Property Value List<double> MaxSpindleSpeed_rpm Maximum spindle speed in RPM. Delegates to Md35100. public double MaxSpindleSpeed_rpm { get; set; } Property Value double Md35100 MD35100: Maximum spindle speed (RPM). See MaxSpindleSpeed_rpm. public double Md35100 { get; set; } Property Value double RapidRateParamId Parameter/MD/MP number for rapid traverse rate per axis. Null if not defined for this controller brand. protected override int? RapidRateParamId { get; } Property Value int? ReferencePositionParamId Parameter/MD/MP number for reference position (G28 home). protected override int ReferencePositionParamId { get; } Property Value int StrokeLimitNegParamId Parameter/MD/MP number for negative stroke limit per axis. Null if not defined for this controller brand. protected override int? StrokeLimitNegParamId { get; } Property Value int? StrokeLimitPosParamId Parameter/MD/MP number for positive stroke limit per axis. Null if not defined for this controller brand. protected override int? StrokeLimitPosParamId { get; } Property Value int? ToolWordTriggersChange The T-word trigger, bound to MD22550 ($MC_TOOL_CHANGE_MODE) when that row is present: 0 = the T word performs the change, any other value = an M function does. An absent row falls back to the brand-neutral flag. The setter writes whichever storage is active, so an MD-configured table keeps the machine data authoritative (and visible in the native parameter view) while a table without the row behaves exactly like the other brands. public override bool ToolWordTriggersChange { get; set; } Property Value bool XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods DeepClone() Returns an independent deep copy of this table: the three parameter dictionaries, M-code declarations, and T-word trigger (via CopyParamsTo(ControllerParameterTableBase)) plus this class's indexing position tables (IndexAxPosTab1/IndexAxPosTab2). Used by SiemensMachineDataTableProxy to clone its fixed machine-config seed into a host that has no table yet. public SiemensMachineDataTable DeepClone() Returns SiemensMachineDataTable DescribeAxisParam(int) Per-axis double counterpart of DescribeSystemParam(int). Covers the role ids the base class consumes (reference position, rapid rate, stroke limits); brand subclasses may override for their own vocabulary or extra numbers. public override string DescribeAxisParam(int paramId) Parameters paramId int Brand-specific parameter/MD/MP number. Returns string DescribeIntAxisParam(int) Per-axis integer counterpart of DescribeSystemParam(int). Covers the axis-type id the base class consumes. public override string DescribeIntAxisParam(int paramId) Parameters paramId int Brand-specific parameter/MD/MP number. Returns string DescribeSystemParam(int) Short usage label for a well-known system parameter id, or null when the id has no modeled meaning (a raw pass-through row). Brand subclasses extend this with their own well-known numbers; the native parameter UI shows the label next to the raw id so an operator can tell the modeled parameters from free extras. public override string DescribeSystemParam(int paramId) Parameters paramId int Brand-specific parameter/MD/MP number. Returns string GetFixPointPosition(string) Fixed-point-1 position (MD30600) for the axis, or null when the axis has no configured fixed point — the G75 consumer then falls back to the reference position (GetHomePosition(string)). public double? GetFixPointPosition(string axisName) Parameters axisName string Returns double? GetIndexingPositionCount(string) Number of programmable indexing positions: the table length for table-assigned axes, the per-cycle position count for cyclic equidistant axes, MaxValue for unbounded (non-cyclic equidistant) axes, and 0 when the axis is not a usable indexing axis. public int GetIndexingPositionCount(string axisName) Parameters axisName string Axis name (e.g., “C”). Returns int IsIndexingAxis(string) True when the axis is configured as an indexing axis with a usable position table (a non-empty table, or a valid equidistant definition). An axis declared indexing but with an empty/invalid table reports false — the coded-position words then stay unrecognized (loud residue) instead of resolving against garbage. public bool IsIndexingAxis(string axisName) Parameters axisName string Axis name (e.g., “C”). Returns bool IsIndexingCyclic(string) True when position-number arithmetic wraps modulo GetIndexingPositionCount(string) — an indexing axis that is also a modular rotary axis (IsModularRotary(string)). Advancing past the last position continues at position 1. public bool IsIndexingCyclic(string axisName) Parameters axisName string Axis name (e.g., “C”). Returns bool MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public override XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory TryFindIndexingAnchor(string, double, out int, out bool) Locates an axis position relative to the indexing table for incremental (CIC) resolution: floorNumber is the number of the nearest indexing position at or below position (cyclically behind on cyclic axes; 0 when the position lies below the whole table on a non-cyclic axis), and exactlyOnPosition reports a match within PositionMatchTolerance. False when the axis is not a usable indexing axis. public bool TryFindIndexingAnchor(string axisName, double position, out int floorNumber, out bool exactlyOnPosition) Parameters axisName string Axis name (e.g., “C”). position double Current axis coordinate (degrees or mm); rotary values may lie outside one revolution and are normalized by the implementation. floorNumber int Number of the nearest indexing position at or (cyclically) below the given position. exactlyOnPosition bool True when the position sits on an indexing position within PositionMatchTolerance. Returns bool TryGetIndexingPosition(string, int, out double) Resolves a 1-based indexing position number to its axis coordinate. False when the axis is not a usable indexing axis or the number is outside [1, count]. public bool TryGetIndexingPosition(string axisName, int positionNumber, out double position) Parameters axisName string Axis name (e.g., “C”). positionNumber int 1-based indexing position number. position double Resolved axis coordinate (degrees or mm). Returns bool"
  },
  "api/Hi.NcParsers.Dependencys.Siemens.SiemensMachineDataTableProxy.html": {
    "href": "api/Hi.NcParsers.Dependencys.Siemens.SiemensMachineDataTableProxy.html",
    "title": "Class SiemensMachineDataTableProxy | HiAPI-C# 2025",
    "summary": "Class SiemensMachineDataTableProxy Namespace Hi.NcParsers.Dependencys.Siemens Assembly HiMech.dll Get-or-create INcDependencyProxy for SiemensMachineDataTable: a placeholder in the shared PipelineNcDependencyList that resolves the host project's own machine data table. Like the Fanuc-family parameter table, the Siemens machine data mixes machine config (axis types / reference positions / velocities / indexing tables) with per-project edits, so the proxy carries a fixed machine-config Seed that is serialized into the shared runner file. On wire, the host receives a deep clone of the seed only when it has no SiemensMachineDataTable yet; a loaded project's own full table wins, so a same-brand re-flash re-binds to the project's machine data instead of resetting it. The resolved host table is fully serialized on the project. The proxy deliberately does not implement the machine-config interfaces (IMachineAxisConfig, IIndexingPositionConfig, etc.) — every machine-config consumer must go through GetEffectiveNcDependencyList() so it sees the resolved host table, never this placeholder. public sealed class SiemensMachineDataTableProxy : INcDependencyProxy, INcDependency, IMakeXmlSource Inheritance object SiemensMachineDataTableProxy Implements INcDependencyProxy INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SiemensMachineDataTableProxy(SiemensMachineDataTable) Creates a proxy carrying seed as its machine-config seed, defaulting to Default3Axis. public SiemensMachineDataTableProxy(SiemensMachineDataTable seed = null) Parameters seed SiemensMachineDataTable The machine-config seed cloned into a fresh host. Properties Seed The fixed machine-config seed deep-cloned into a host that has no SiemensMachineDataTable yet. Carried on the shared runner and serialized into the runner file — never the per-case instance, which lives on the host (see GetNcDependency()). public SiemensMachineDataTable Seed { get; } Property Value SiemensMachineDataTable XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods GetNcDependency() Takes the host's SiemensMachineDataTable (created during InitNcDependencyHost(INcDependencyListHost)). Returns null when no host is wired. public INcDependency GetNcDependency() Returns INcDependency InitNcDependencyHost(INcDependencyListHost) Wires the host and materializes the host SiemensMachineDataTable: when the host list has none, a deep clone of Seed is installed so the machine data exists and is editable before any run. GetNcDependency() is then a pure take. Idempotent — an existing host table (a loaded project's) is left untouched. public void InitNcDependencyHost(INcDependencyListHost host) Parameters host INcDependencyListHost MakeXmlSource(string, string, bool) Serializes only the machine-config Seed — the wired host and the resolved host table are runtime-only and not persisted in the shared runner. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Rehydrates the carried Seed from the nested SiemensMachineDataTable element, falling back to Default3Axis when absent. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.Siemens.SiemensRParameterTable.html": {
    "href": "api/Hi.NcParsers.Dependencys.Siemens.SiemensRParameterTable.html",
    "title": "Class SiemensRParameterTable | HiAPI-C# 2025",
    "summary": "Class SiemensRParameterTable Namespace Hi.NcParsers.Dependencys.Siemens Assembly HiMech.dll Sinumerik R-parameter table (R0-R999). R parameters are the Siemens arithmetic-variable surface (R63=100.5, C=R61, R26=(558.5+14)/2); on real hardware they live in retentive memory (sized by MD28050) and survive program end and power cycles, so — like the Fanuc sibling RetainedCommonVariableTable — this table is not session-reset and is serialised into the project file. Reads flow through Get(string) (registered automatically because the table sits on the runner's effective NcDependencyList); writes flow through SiemensRParameterReadingSyntax, which consumes literal Parsing.Assignments.Rn entries after VariableEvaluatorSyntax has normalized expression RHS to literals. Vacant is represented by null: either the dictionary has no entry for the key, or the entry maps to null — both read identically. Real Sinumerik default-initialises every allocated R to 0, but a vacant read failing loud (Variable--Vacant via the evaluator) surfaces missing setup data instead of silently machining with 0. public class SiemensRParameterTable : INcDependency, IMakeXmlSource, IVariableLookup Inheritance object SiemensRParameterTable Implements INcDependency IMakeXmlSource IVariableLookup Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SiemensRParameterTable() Empty table. public SiemensRParameterTable() SiemensRParameterTable(XElement) Loads from XML produced by MakeXmlSource(string, string, bool). public SiemensRParameterTable(XElement src) Parameters src XElement Fields RParameterMax Inclusive upper bound of the R-parameter range (R999). Real machines size this by MD28050 MM_NUM_R_PARAM (often 100); 999 covers the extended ranges seen in the corpus (R400+) without machine data. public const int RParameterMax = 999 Field Value int RParameterMin Inclusive lower bound of the R-parameter range (R0). public const int RParameterMin = 0 Field Value int Properties Variables Backing store. Key = R-parameter number (e.g. 63 for R63). Value null = vacant; a missing key is also vacant. Keys are constrained to RParameterMin..RParameterMax; out-of-range writes are silently ignored. public Dictionary<int, double?> Variables { get; set; } Property Value Dictionary<int, double?> XName XML element name. public static string XName { get; } Property Value string Methods Get(string) Returns the value of the variable identified by key (e.g. \"#124\"), or null if vacant or unknown to this lookup. public double? Get(string key) Parameters key string Returns double? Remarks Routes Rn keys (canonical form produced by SiemensExpressionParser; a lowercase rn from a raw capture also resolves) to GetVariable(int); other keys return null so the evaluator's lookup chain falls through. GetVariable(int) Reads an R parameter. Returns null for vacant (either the entry is absent or stored as null). public double? GetVariable(int id) Parameters id int Parameter number in RParameterMin..RParameterMax. Returns double? MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetVariable(int, double?) Writes an R parameter. Pass null to set vacant. Ignores ids outside RParameterMin..RParameterMax. public void SetVariable(int id, double? value) Parameters id int Parameter number. value double? New value, or null for vacant."
  },
  "api/Hi.NcParsers.Dependencys.Siemens.SiemensRParameterTableProxy.html": {
    "href": "api/Hi.NcParsers.Dependencys.Siemens.SiemensRParameterTableProxy.html",
    "title": "Class SiemensRParameterTableProxy | HiAPI-C# 2025",
    "summary": "Class SiemensRParameterTableProxy Namespace Hi.NcParsers.Dependencys.Siemens Assembly HiMech.dll Get-or-create INcDependencyProxy for SiemensRParameterTable: a placeholder in the shared PipelineNcDependencyList that resolves the host project's own per-case R parameters (R0–R999). public sealed class SiemensRParameterTableProxy : INcDependencyProxy, INcDependency, IMakeXmlSource Inheritance object SiemensRParameterTableProxy Implements INcDependencyProxy INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods GetNcDependency() Takes the host's SiemensRParameterTable (created during InitNcDependencyHost(INcDependencyListHost)). Returns null when no host is wired. public INcDependency GetNcDependency() Returns INcDependency InitNcDependencyHost(INcDependencyListHost) Wires the host and materializes the per-case SiemensRParameterTable: when the host list has none, one is created and installed so it exists and is editable before any run. GetNcDependency() is then a pure take. Idempotent — an existing table is left untouched. public void InitNcDependencyHost(INcDependencyListHost host) Parameters host INcDependencyListHost MakeXmlSource(string, string, bool) Runtime-only proxy — the wired host and the resolved table are not persisted in the shared runner; serialization writes only the empty element. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.Siemens.SiemensToolEdgeOffset.html": {
    "href": "api/Hi.NcParsers.Dependencys.Siemens.SiemensToolEdgeOffset.html",
    "title": "Class SiemensToolEdgeOffset | HiAPI-C# 2025",
    "summary": "Class SiemensToolEdgeOffset Namespace Hi.NcParsers.Dependencys.Siemens Assembly HiMech.dll One Siemens cutting-edge offset row ($TC_DP fields for a (T, D) pair): geometry lengths L1/L2/L3 ($TC_DP3/4/5), radius ($TC_DP6) and the corresponding wear values ($TC_DP12/13/14/15) as typed properties (all mm), plus VerbatimDpFields for every other $TC_DP index — same split as SiemensMachineDataTable's well-known-MD properties over a generic parameter bag. A typed property means the simulation consumes the field; a bag entry means the value is stored and round-tripped but not interpreted. public class SiemensToolEdgeOffset Inheritance object SiemensToolEdgeOffset Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Length1_mm $TC_DP3 — geometry length 1 (typically Z), mm. public double Length1_mm { get; set; } Property Value double Length2_mm $TC_DP4 — geometry length 2 (typically X), mm. public double Length2_mm { get; set; } Property Value double Length3_mm $TC_DP5 — geometry length 3 (typically Y), mm. public double Length3_mm { get; set; } Property Value double Radius_mm $TC_DP6 — geometry radius, mm. public double Radius_mm { get; set; } Property Value double VerbatimDpFields $TC_DP fields the simulation does not consume, keyed by DP index (e.g. 1 = tool type, 2 = tip position, 7–11 = extended geometry, 16–20 = extended wear, 21–23 = base/adapter dimensions, 24 = clearance angle). Carried for round-trip fidelity so a full controller dump survives import → save → reload; never interpreted. The consumed indices (see IsConsumedDpIndex(int)) live in the typed properties and must not appear here — write through SetDpField(int, double) to keep that invariant. public Dictionary<int, double> VerbatimDpFields { get; set; } Property Value Dictionary<int, double> WearLength1_mm $TC_DP12 — wear length 1, mm. public double WearLength1_mm { get; set; } Property Value double WearLength2_mm $TC_DP13 — wear length 2, mm. public double WearLength2_mm { get; set; } Property Value double WearLength3_mm $TC_DP14 — wear length 3, mm. public double WearLength3_mm { get; set; } Property Value double WearRadius_mm $TC_DP15 — wear radius, mm. public double WearRadius_mm { get; set; } Property Value double Methods IsConsumedDpIndex(int) Whether the given $TC_DP index is consumed by the simulation and therefore stored as a typed property (3/4/5/6 geometry, 12/13/14/15 wear) rather than in VerbatimDpFields. public static bool IsConsumedDpIndex(int dpIndex) Parameters dpIndex int Returns bool SetDpField(int, double) Writes one $TC_DP field by DP index: consumed indices route to the typed properties, every other index lands verbatim in VerbatimDpFields — an importer can hand over a full controller dump without knowing which indices the simulation consumes. public void SetDpField(int dpIndex, double value) Parameters dpIndex int value double"
  },
  "api/Hi.NcParsers.Dependencys.Siemens.SiemensToolOffsetTable.html": {
    "href": "api/Hi.NcParsers.Dependencys.Siemens.SiemensToolOffsetTable.html",
    "title": "Class SiemensToolOffsetTable | HiAPI-C# 2025",
    "summary": "Class SiemensToolOffsetTable Namespace Hi.NcParsers.Dependencys.Siemens Assembly HiMech.dll Per-case Siemens tool offset table — the first concrete ISiemensToolOffsetConfig ($TC_DP model): one SiemensToolEdgeOffset row per (tool number T, cutting edge D), each carrying the three length components + radius with their wear counterparts, plus a verbatim bag for the remaining $TC_DP indices (round-tripped, not consumed — see VerbatimDpFields). Effective values are geometry + wear — Sinumerik wear ($TC_DP12..15) is additive; a worn-down tool carries a negative wear value. Unconfigured (T, D) pairs return 0 per the interface contract. Also carries the ToolNames map ($TC_TP2 analog, case-insensitive) so Siemens string tool calls (T=\"D8R1\") can resolve to the int-keyed act chain — consumed by ToolChangeSemantic. Per-case editable data — reaches the pipeline through SiemensToolOffsetTableProxy on the host's PerCaseNcDependencyList, never as a concrete instance baked into the shared runner. Deliberately separate from SiemensMachineDataTable (MD-prefixed machine-fixed OEM data) — same split rationale as SiemensFrameTable. public class SiemensToolOffsetTable : INcDependency, IMakeXmlSource, ISiemensToolOffsetConfig Inheritance object SiemensToolOffsetTable Implements INcDependency IMakeXmlSource ISiemensToolOffsetConfig Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SiemensToolOffsetTable() Initializes an empty table. public SiemensToolOffsetTable() SiemensToolOffsetTable(XElement) Initializes a new instance by deserializing from src. public SiemensToolOffsetTable(XElement src) Parameters src XElement XML element produced by MakeXmlSource(string, string, bool). Properties Edges Offset rows keyed by (tool number T, cutting edge D). public Dictionary<(int Tool, int Edge), SiemensToolEdgeOffset> Edges { get; set; } Property Value Dictionary<(int Tool, int Edge), SiemensToolEdgeOffset> ToolNames Tool name → tool number map ($TC_TP2 analog) used to resolve Siemens string tool calls (T=“name”). Case-insensitive. public Dictionary<string, int> ToolNames { get; set; } Property Value Dictionary<string, int> XName XML element name for serialization. public static string XName { get; } Property Value string Methods FindToolNumberByName(string) Resolves a Siemens string tool name (T=“name”) to its tool number via ToolNames; null when unmapped. public int? FindToolNumberByName(string toolName) Parameters toolName string Returns int? GetToolHeightOffset_mm(int, int) Gets the effective tool height offset in mm for a specific tool and cutting edge: $TC_DP3 (length 1, typically Z direction) plus its additive wear $TC_DP12 — Sinumerik wear values are added, a shortened tool carries negative wear. Returns 0 if the tool/edge is not configured. public double GetToolHeightOffset_mm(int toolNumber, int edgeNumber) Parameters toolNumber int Tool number (T). edgeNumber int Cutting edge number (D). Returns double GetToolLengthOffset_mm(int, int, int) Gets an additional length offset for the specified direction. directionIndex: 0 = L1 ($TC_DP3, Z), 1 = L2 ($TC_DP4, X), 2 = L3 ($TC_DP5, Y). Returns 0 if not configured. public double GetToolLengthOffset_mm(int toolNumber, int edgeNumber, int directionIndex) Parameters toolNumber int edgeNumber int directionIndex int Returns double GetToolRadiusOffset_mm(int, int) Gets the effective tool radius offset in mm for a specific tool and cutting edge: $TC_DP6 (radius) plus its additive wear $TC_DP15. Returns 0 if the tool/edge is not configured. public double GetToolRadiusOffset_mm(int toolNumber, int edgeNumber) Parameters toolNumber int Tool number (T). edgeNumber int Cutting edge number (D). Returns double MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory TryGetToolHeightOffset_mm(int, int, out double) Attempts to get the effective tool height offset in mm ($TC_DP3 plus additive wear $TC_DP12) for a specific tool and cutting edge. Returns false when the (tool, edge) pair has no configured row, so the caller can fall back to another source (e.g. the generic IToolOffsetConfig). This is the only reliable miss signal — 0.0 is a legal configured offset, so the zero returned by GetToolHeightOffset_mm(int, int) cannot distinguish a vacant row from a configured zero. public bool TryGetToolHeightOffset_mm(int toolNumber, int edgeNumber, out double offset_mm) Parameters toolNumber int Tool number (T). edgeNumber int Cutting edge number (D). offset_mm double The effective height offset; 0 on miss. Returns bool"
  },
  "api/Hi.NcParsers.Dependencys.Siemens.SiemensToolOffsetTableProxy.html": {
    "href": "api/Hi.NcParsers.Dependencys.Siemens.SiemensToolOffsetTableProxy.html",
    "title": "Class SiemensToolOffsetTableProxy | HiAPI-C# 2025",
    "summary": "Class SiemensToolOffsetTableProxy Namespace Hi.NcParsers.Dependencys.Siemens Assembly HiMech.dll Get-or-create INcDependencyProxy for SiemensToolOffsetTable: a placeholder in the shared PipelineNcDependencyList that resolves the host project's own per-case Siemens ($TC_DP) tool offset table. public sealed class SiemensToolOffsetTableProxy : INcDependencyProxy, INcDependency, IMakeXmlSource Inheritance object SiemensToolOffsetTableProxy Implements INcDependencyProxy INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods GetNcDependency() Takes the host's SiemensToolOffsetTable (created during InitNcDependencyHost(INcDependencyListHost)). Returns null when no host is wired. public INcDependency GetNcDependency() Returns INcDependency InitNcDependencyHost(INcDependencyListHost) Wires the host and materializes the per-case SiemensToolOffsetTable: when the host list has none, one is created and installed so it exists and is editable before any run. GetNcDependency() is then a pure take. Idempotent — an existing table is left untouched. public void InitNcDependencyHost(INcDependencyListHost host) Parameters host INcDependencyListHost MakeXmlSource(string, string, bool) Runtime-only proxy — the wired host and the resolved table are not persisted in the shared runner; serialization writes only the empty element. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.Siemens.html": {
    "href": "api/Hi.NcParsers.Dependencys.Siemens.html",
    "title": "Namespace Hi.NcParsers.Dependencys.Siemens | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.Dependencys.Siemens Classes SiemensFrameTable Sinumerik settable work coordinate frames ($P_UIFR[n]). Models G54–G57 (ISO-compatible), G505–G599 (extended Siemens), and G500 (cancel — always zero). On real Sinumerik, $P_UIFR is a frame array containing translation, rotation, scale and mirror per entry. HiNC currently consumes only the translation component, so this table stores Vec3d per id. $P_UIFR is NOT in the machine data table — therefore this is a separate dependency from SiemensMachineDataTable (which holds MD-prefixed OEM machine data such as MD30300 axis type, MD34010 reference position, etc.). Deliberately not ISessionResettable: settable frames are setting data on the control — a $P_UIFR write from the program survives reset and power-off, so a replayed session must see the values the previous run wrote. SiemensFrameTableProxy Get-or-create INcDependencyProxy for SiemensFrameTable: a placeholder in the shared PipelineNcDependencyList that resolves the host project's own per-case settable work frames ($P_UIFR, G54–G57…). SiemensGotoIterationDependency Watchdog for Siemens GOTOF/GOTOB jumps — the label-keyed sibling of the Fanuc FanucGotoIterationDependency, with the same “soft-cap + runtime counter + session-init ISessionResettable” shape. Kept per-brand (rather than widening the Fanuc dep's int-keyed bucket) for diagnostic clarity and because Siemens targets are named labels, not N-numbers. The counter key is (FileName, Label) where FileName is the source-level file path of the jump host (the relative form carried on FilePath). Source-level keying means multiple inline invocations of the same subprogram pool their counts, while two files each jumping to their own LBL1 stay isolated. Forward and backward jumps to the same label share one bucket — only the backward direction can loop, but a shared bucket keeps the accounting simple and the cap generous. The consuming syntax (SiemensGotoSyntax) counts after the condition gate and before the label scan; above MaxIterationsPerLabel the jump warns SiemensGoto--IterationLimitExceeded and falls through. A missing dependency disables the cap (Fanuc parity) — the brand preset wires one by default. SiemensLoopIterationDependency Watchdog shared by all four Siemens loop constructs (WHILE/ENDWHILE, FOR/ENDFOR, REPEAT/UNTIL, LOOP/ENDLOOP) — construct-neutral by design, unlike the Fanuc sibling (FanucWhileDoIterationDependency) which only has WHILE to guard. Same “soft-cap + runtime counter + session-init ISessionResettable” shape. Siemens loop constructs carry no LoopId, so the counter key is (FileName, BeginLineNo) — the loop-entry line recorded in the active frame identifies the construct uniquely within its file, and the file path isolates identically-numbered lines across files (and across inlined subprograms). The consuming syntax (SiemensLoopSyntax) counts at the back-jump step (the loop terminator / falsy UNTIL), so a loop whose condition is false from the outset consumes zero iterations. Above MaxIterationsPerLoop the terminator warns SiemensLoop--IterationLimitExceeded, pops the frame and falls through. A missing dependency disables the cap for the condition-bearing constructs (Fanuc parity) but hard-blocks the ENDLOOP back-jump — LOOP has no exit condition, so an uncapped back-jump would hang the pipeline deterministically. SiemensMachineDataTable Siemens Sinumerik machine data table. Stores machine data (MD numbers) as system and per-axis parameters. MD10000–MD19999: General machine data. MD20000–MD29999: Axis-specific machine data. MD30000–MD39999: Axis-specific machine data (extended). Deliberately not ISessionResettable: machine data is control configuration a part program cannot mutate, so there is no session-scoped state to clear. SiemensMachineDataTableProxy Get-or-create INcDependencyProxy for SiemensMachineDataTable: a placeholder in the shared PipelineNcDependencyList that resolves the host project's own machine data table. Like the Fanuc-family parameter table, the Siemens machine data mixes machine config (axis types / reference positions / velocities / indexing tables) with per-project edits, so the proxy carries a fixed machine-config Seed that is serialized into the shared runner file. On wire, the host receives a deep clone of the seed only when it has no SiemensMachineDataTable yet; a loaded project's own full table wins, so a same-brand re-flash re-binds to the project's machine data instead of resetting it. The resolved host table is fully serialized on the project. The proxy deliberately does not implement the machine-config interfaces (IMachineAxisConfig, IIndexingPositionConfig, etc.) — every machine-config consumer must go through GetEffectiveNcDependencyList() so it sees the resolved host table, never this placeholder. SiemensRParameterTable Sinumerik R-parameter table (R0-R999). R parameters are the Siemens arithmetic-variable surface (R63=100.5, C=R61, R26=(558.5+14)/2); on real hardware they live in retentive memory (sized by MD28050) and survive program end and power cycles, so — like the Fanuc sibling RetainedCommonVariableTable — this table is not session-reset and is serialised into the project file. Reads flow through Get(string) (registered automatically because the table sits on the runner's effective NcDependencyList); writes flow through SiemensRParameterReadingSyntax, which consumes literal Parsing.Assignments.Rn entries after VariableEvaluatorSyntax has normalized expression RHS to literals. Vacant is represented by null: either the dictionary has no entry for the key, or the entry maps to null — both read identically. Real Sinumerik default-initialises every allocated R to 0, but a vacant read failing loud (Variable--Vacant via the evaluator) surfaces missing setup data instead of silently machining with 0. SiemensRParameterTableProxy Get-or-create INcDependencyProxy for SiemensRParameterTable: a placeholder in the shared PipelineNcDependencyList that resolves the host project's own per-case R parameters (R0–R999). SiemensToolEdgeOffset One Siemens cutting-edge offset row ($TC_DP fields for a (T, D) pair): geometry lengths L1/L2/L3 ($TC_DP3/4/5), radius ($TC_DP6) and the corresponding wear values ($TC_DP12/13/14/15) as typed properties (all mm), plus VerbatimDpFields for every other $TC_DP index — same split as SiemensMachineDataTable's well-known-MD properties over a generic parameter bag. A typed property means the simulation consumes the field; a bag entry means the value is stored and round-tripped but not interpreted. SiemensToolOffsetTable Per-case Siemens tool offset table — the first concrete ISiemensToolOffsetConfig ($TC_DP model): one SiemensToolEdgeOffset row per (tool number T, cutting edge D), each carrying the three length components + radius with their wear counterparts, plus a verbatim bag for the remaining $TC_DP indices (round-tripped, not consumed — see VerbatimDpFields). Effective values are geometry + wear — Sinumerik wear ($TC_DP12..15) is additive; a worn-down tool carries a negative wear value. Unconfigured (T, D) pairs return 0 per the interface contract. Also carries the ToolNames map ($TC_TP2 analog, case-insensitive) so Siemens string tool calls (T=\"D8R1\") can resolve to the int-keyed act chain — consumed by ToolChangeSemantic. Per-case editable data — reaches the pipeline through SiemensToolOffsetTableProxy on the host's PerCaseNcDependencyList, never as a concrete instance baked into the shared runner. Deliberately separate from SiemensMachineDataTable (MD-prefixed machine-fixed OEM data) — same split rationale as SiemensFrameTable. SiemensToolOffsetTableProxy Get-or-create INcDependencyProxy for SiemensToolOffsetTable: a placeholder in the shared PipelineNcDependencyList that resolves the host project's own per-case Siemens ($TC_DP) tool offset table. Interfaces ISiemensToolOffsetConfig Siemens (840D/Sinumerik) tool offset configuration. Offsets are addressed by (tool number T, cutting edge D number), unlike IToolOffsetConfig where a single integer selects the row. Siemens stores up to 25 data fields per cutting edge ($TC_DP1..$TC_DP25), including three independent length components (L1/L2/L3 for Z/X/Y directions), radius, and corresponding wear values."
  },
  "api/Hi.NcParsers.Dependencys.StrokeLimitUtil.html": {
    "href": "api/Hi.NcParsers.Dependencys.StrokeLimitUtil.html",
    "title": "Class StrokeLimitUtil | HiAPI-C# 2025",
    "summary": "Class StrokeLimitUtil Namespace Hi.NcParsers.Dependencys Assembly HiMech.dll Load-time audit helpers for IStrokeLimitConfig: which machine-coordinate axes the chain has, and which of them the stroke limit check cannot judge because no limit is configured. Both checks — the per-block StrokeLimitCheckSemantic and the per-step CheckStrokeLimit(DVec3d, IProgress<IMessage>) — compare only axes that carry a limit, so a machine file without limits passes every position silently while EnableStrokeLimitCheck reads as on. The session begin reports that gap once through these helpers. public static class StrokeLimitUtil Inheritance object StrokeLimitUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields McAxisNames Machine-coordinate axis names, linear first then rotary. public static readonly string[] McAxisNames Field Value string[] Methods DescribeUnlimitedAxes(IEnumerable<string>, Func<string, double?>, Func<string, double?>) Describes the axes among axisNames that the stroke limit check cannot judge: an axis with neither end configured is listed by name, an axis with one end only is listed with the missing end (\"Z (no negative limit)\"). Empty when every axis has both ends. A limit of NaN or ±infinity counts as not configured (the legacy HardNcEnv boxes default to an infinite box). public static List<string> DescribeUnlimitedAxes(IEnumerable<string> axisNames, Func<string, double?> positiveLimit, Func<string, double?> negativeLimit) Parameters axisNames IEnumerable<string> The axes to audit, normally GetChainAxisNames(IXyzabcChain, bool). positiveLimit Func<string, double?> Positive-end limit per axis; null when not configured. negativeLimit Func<string, double?> Negative-end limit per axis; null when not configured. Returns List<string> GetChainAxisNames(IXyzabcChain, bool) The machine-coordinate axes chain actually has: an axis counts when a transformer is bound to its name (GetTransformerX() … GetTransformerC()). A three-axis chain yields X, Y, Z only; a null chain yields nothing. public static List<string> GetChainAxisNames(IXyzabcChain chain, bool linearOnly = false) Parameters chain IXyzabcChain The machine chain, or null. linearOnly bool When true, only the translation axes (X, Y, Z) are returned. A travel audit wants this: a linear axis always has a finite travel, so a missing limit is unambiguously a gap, while a rotary table that turns continuously legitimately has none and cannot be given one. Returns List<string>"
  },
  "api/Hi.NcParsers.Dependencys.Syntec.SyntecParameterTable.html": {
    "href": "api/Hi.NcParsers.Dependencys.Syntec.SyntecParameterTable.html",
    "title": "Class SyntecParameterTable | HiAPI-C# 2025",
    "summary": "Class SyntecParameterTable Namespace Hi.NcParsers.Dependencys.Syntec Assembly HiMech.dll Syntec controller parameter table. Stores system parameters (single value) and axis parameters (per-axis value) following Syntec Pr-prefixed parameter numbering. Syntec is largely Fanuc-compatible in parameter numbering, but some parameters differ in unit or interpretation. For example, Pr4002 (peck retraction) is stored in microns whereas Fanuc #4002 stores in mm. public class SyntecParameterTable : ControllerParameterTableBase, IHomeMcConfig, IMachineAxisConfig, IRapidFeedrateConfig, IStrokeLimitConfig, ISpindleControlConfig, IMCodeDeclarationConfig, IToolChangeTriggerConfig, ICannedCycleConfig, IIsoCoordinateConfig, INcDependency, IMakeXmlSource Inheritance object ControllerParameterTableBase SyntecParameterTable Implements IHomeMcConfig IMachineAxisConfig IRapidFeedrateConfig IStrokeLimitConfig ISpindleControlConfig IMCodeDeclarationConfig IToolChangeTriggerConfig ICannedCycleConfig IIsoCoordinateConfig INcDependency IMakeXmlSource Inherited Members ControllerParameterTableBase.GetLinearAxisRapidRate_mmdmin(string) ControllerParameterTableBase.GetRotaryAxisRapidRate_degdmin(string) ControllerParameterTableBase.SetLinearAxisRapidRate_mmdmin(string, double) ControllerParameterTableBase.SetRotaryAxisRapidRate_degdmin(string, double) ControllerParameterTableBase.GetPositiveLimit(string) ControllerParameterTableBase.GetNegativeLimit(string) ControllerParameterTableBase.SetPositiveLimit(string, double) ControllerParameterTableBase.SetNegativeLimit(string, double) ControllerParameterTableBase.DescribeIntAxisParam(int) ControllerParameterTableBase.SystemParams ControllerParameterTableBase.AxisParams ControllerParameterTableBase.IntAxisParams ControllerParameterTableBase.AxisParam(int) ControllerParameterTableBase.IntAxisParam(int) ControllerParameterTableBase.GetHomePosition(string) ControllerParameterTableBase.SetHomePosition(string, double) ControllerParameterTableBase.AxisNames ControllerParameterTableBase.IsRotaryAxis(string) ControllerParameterTableBase.SetAxis(string, AxisType) ControllerParameterTableBase.RemoveAxis(string) ControllerParameterTableBase.ConfigureRotaryAxis(string, double, double) ControllerParameterTableBase.MCodeDeclarations ControllerParameterTableBase.EffectiveMCodeDeclarations ControllerParameterTableBase.TryGetMCodeEffects(string, out MCodeEffects) ControllerParameterTableBase.DeclareMCode(string, MCodeEffects) ControllerParameterTableBase.RemoveMCodeDeclaration(string) ControllerParameterTableBase.ToolWordTriggersChange ControllerParameterTableBase.SpindleDirectionCodes ControllerParameterTableBase.TryResolveDirection(string, out SpindleDirection) ControllerParameterTableBase.ConfigureSpindleDirectionCode(string, SpindleDirection) ControllerParameterTableBase.RemoveSpindleDirectionCode(string) ControllerParameterTableBase.ReadXml(XElement) ControllerParameterTableBase.WriteXml(string) ControllerParameterTableBase.CopyParamsTo(ControllerParameterTableBase) object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks CutterCompensationType is shared with Fanuc because both follow the same ISO cutter compensation standard. Consider relocating to the shared Hi.NcParsers.Dependencys namespace if more brands need it. Constructors SyntecParameterTable() Initializes a new instance, seeding the ISO G54-G59 / G54.1 P-table coordinate offsets with their default values. public SyntecParameterTable() SyntecParameterTable(XElement) Initializes a new instance by deserializing from src. public SyntecParameterTable(XElement src) Parameters src XElement XML element produced by MakeXmlSource(string, string, bool). Fields PrAxisType Pr1006: Axis type per axis. See AxisType. public const int PrAxisType = 1006 Field Value int PrControlledAxes Pr1020: Number of controlled axes. public const int PrControlledAxes = 1020 Field Value int PrCutterCompType Pr5003: Cutter compensation startup type. See CutterCompensationType. public const int PrCutterCompType = 5003 Field Value int PrG54OffsetBase Pr5221: Base address (X) of G54 work coordinate offset. G54.Y at +1 (Pr5222), G54.Z at +2 (Pr5223). G55..G59 follow at stride 20. Syntec follows Fanuc-compatible numbering — see IsoCoordinateAddressMap. public const int PrG54OffsetBase = 5221 Field Value int PrG54p1P1OffsetBase Pr7001: Base address (X) of G54.1 P1 extended work coordinate offset. G54.1 P2..P48 follow at stride 20. See IsoCoordinateAddressMap. public const int PrG54p1P1OffsetBase = 7001 Field Value int PrMaxSpindleSpeed Pr3741: Maximum spindle speed (RPM). public const int PrMaxSpindleSpeed = 3741 Field Value int PrPeckRetraction Pr4002: G83 peck drilling retraction distance (microns). Syntec stores this value in microns; convert ×0.001 for mm. public const int PrPeckRetraction = 4002 Field Value int PrRapidRate Pr1420: Rapid traverse rate per axis (mm/min or deg/min). public const int PrRapidRate = 1420 Field Value int PrReferencePosition Pr1240: G28 first reference position per axis. public const int PrReferencePosition = 1240 Field Value int PrStrokeLimitNeg Pr1320: Negative stroke limit per axis (mm or deg). public const int PrStrokeLimitNeg = 1320 Field Value int PrStrokeLimitPos Pr1300: Positive stroke limit per axis (mm or deg). public const int PrStrokeLimitPos = 1300 Field Value int Properties AxisPr1006 Pr1006: Axis type per axis. See AxisType. See AxisNames. See IsRotaryAxis(string). public Dictionary<string, int> AxisPr1006 { get; set; } Property Value Dictionary<string, int> AxisPr1240 Pr1240: G28 first reference position per axis. See IHomeMcConfig. See GetHomePosition(string). See SetHomePosition(string, double). public Dictionary<string, double> AxisPr1240 { get; set; } Property Value Dictionary<string, double> AxisPr1420 Pr1420: Rapid traverse rate per axis (mm/min or deg/min). See IRapidFeedrateConfig. public Dictionary<string, double> AxisPr1420 { get; set; } Property Value Dictionary<string, double> AxisTypeParamId Parameter/MD/MP number for axis type (linear/rotary/spindle). protected override int AxisTypeParamId { get; } Property Value int ControlledAxisCount Number of controlled axes. Delegates to Pr1020. public int ControlledAxisCount { get; set; } Property Value int CoordinateIds Enumerates the G-code coordinate ids that this provider currently has data for. public IEnumerable<string> CoordinateIds { get; } Property Value IEnumerable<string> CutterCompType Cutter compensation startup type. Delegates to Pr5003. public CutterCompensationType CutterCompType { get; set; } Property Value CutterCompensationType Default3Axis Default 3-axis Syntec milling machine. public static SyntecParameterTable Default3Axis { get; } Property Value SyntecParameterTable IdAttributeName XML attribute name for the parameter ID (“ParamId”, “MdId”, “MpId”). protected override string IdAttributeName { get; } Property Value string MaxSpindleSpeed_rpm Maximum spindle speed in RPM. Delegates to Pr3741. public double MaxSpindleSpeed_rpm { get; set; } Property Value double PeckRetractionDistance_mm G83 peck drilling clearance distance above the previous stroke bottom before re-entering at feed (mm). public double PeckRetractionDistance_mm { get; } Property Value double Remarks Syntec Pr4002 stores peck retraction distance in microns. Multiply by 0.001 to convert to mm. Pr1020 Pr1020: Number of controlled axes. See ControlledAxisCount. public int Pr1020 { get; set; } Property Value int Pr3741 Pr3741: Maximum spindle speed (RPM). See MaxSpindleSpeed_rpm. public double Pr3741 { get; set; } Property Value double Pr5003 Pr5003: Cutter compensation startup type. See CutterCompType. public CutterCompensationType Pr5003 { get; set; } Property Value CutterCompensationType RapidRateParamId Parameter/MD/MP number for rapid traverse rate per axis. Null if not defined for this controller brand. protected override int? RapidRateParamId { get; } Property Value int? ReferencePositionParamId Parameter/MD/MP number for reference position (G28 home). protected override int ReferencePositionParamId { get; } Property Value int StrokeLimitNegParamId Parameter/MD/MP number for negative stroke limit per axis. Null if not defined for this controller brand. protected override int? StrokeLimitNegParamId { get; } Property Value int? StrokeLimitPosParamId Parameter/MD/MP number for positive stroke limit per axis. Null if not defined for this controller brand. protected override int? StrokeLimitPosParamId { get; } Property Value int? XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods DeepClone() Returns an independent deep copy of this table (all three parameter dictionaries cloned). Used by SyntecParameterTableProxy to clone its fixed machine-config seed into a host that has no table yet. public SyntecParameterTable DeepClone() Returns SyntecParameterTable DescribeAxisParam(int) Per-axis double counterpart of DescribeSystemParam(int). Covers the role ids the base class consumes (reference position, rapid rate, stroke limits); brand subclasses may override for their own vocabulary or extra numbers. public override string DescribeAxisParam(int paramId) Parameters paramId int Brand-specific parameter/MD/MP number. Returns string DescribeSystemParam(int) Short usage label for a well-known system parameter id, or null when the id has no modeled meaning (a raw pass-through row). Brand subclasses extend this with their own well-known numbers; the native parameter UI shows the label next to the raw id so an operator can tell the modeled parameters from free extras. public override string DescribeSystemParam(int paramId) Parameters paramId int Brand-specific parameter/MD/MP number. Returns string GetCoordinateOffset(string) Gets the offset for the given G-code coordinate id. Returns null when no offset is configured for that id by this provider (callers iterate the next provider, or fall back to Zero). public Vec3d GetCoordinateOffset(string coordId) Parameters coordId string Returns Vec3d MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public override XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetCoordinateOffset(string, Vec3d) Sets the offset for the given G-code coordinate id. public void SetCoordinateOffset(string coordId, Vec3d offset) Parameters coordId string offset Vec3d"
  },
  "api/Hi.NcParsers.Dependencys.Syntec.SyntecParameterTableProxy.html": {
    "href": "api/Hi.NcParsers.Dependencys.Syntec.SyntecParameterTableProxy.html",
    "title": "Class SyntecParameterTableProxy | HiAPI-C# 2025",
    "summary": "Class SyntecParameterTableProxy Namespace Hi.NcParsers.Dependencys.Syntec Assembly HiMech.dll Get-or-create INcDependencyProxy for SyntecParameterTable: the Syntec sibling of FanucParameterTableProxy. Like Fanuc, the Syntec parameter table mixes machine config with per-case work-coordinate offsets, so the proxy carries a fixed machine-config Seed serialized into the shared runner file. On wire, the host receives a deep clone of the seed only when it has no SyntecParameterTable yet; a loaded project's own full table wins. The proxy does not implement the machine-config interfaces — consumers go through GetEffectiveNcDependencyList(). public sealed class SyntecParameterTableProxy : INcDependencyProxy, INcDependency, IMakeXmlSource Inheritance object SyntecParameterTableProxy Implements INcDependencyProxy INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SyntecParameterTableProxy(SyntecParameterTable) Creates a proxy carrying seed as its machine-config seed, defaulting to Default3Axis. public SyntecParameterTableProxy(SyntecParameterTable seed = null) Parameters seed SyntecParameterTable The machine-config seed cloned into a fresh host. Properties Seed The fixed machine-config seed deep-cloned into a host that has no SyntecParameterTable yet. Carried on the shared runner and serialized into the runner file — never the per-case instance, which lives on the host (see GetNcDependency()). public SyntecParameterTable Seed { get; } Property Value SyntecParameterTable XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods GetNcDependency() Takes the host's SyntecParameterTable (created during InitNcDependencyHost(INcDependencyListHost)). Returns null when no host is wired. public INcDependency GetNcDependency() Returns INcDependency InitNcDependencyHost(INcDependencyListHost) Wires the host and materializes the host SyntecParameterTable: when the host list has none, a deep clone of Seed is installed so machine config + per-case coordinates exist and are editable before any run. GetNcDependency() is then a pure take. Idempotent — an existing host table (a loaded project's) is left untouched. public void InitNcDependencyHost(INcDependencyListHost host) Parameters host INcDependencyListHost MakeXmlSource(string, string, bool) Serializes only the machine-config Seed — the wired host and the resolved host table are runtime-only and not persisted in the shared runner. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Rehydrates the carried Seed from the nested SyntecParameterTable element, falling back to Default3Axis when absent. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.Syntec.html": {
    "href": "api/Hi.NcParsers.Dependencys.Syntec.html",
    "title": "Namespace Hi.NcParsers.Dependencys.Syntec | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.Dependencys.Syntec Classes SyntecParameterTable Syntec controller parameter table. Stores system parameters (single value) and axis parameters (per-axis value) following Syntec Pr-prefixed parameter numbering. Syntec is largely Fanuc-compatible in parameter numbering, but some parameters differ in unit or interpretation. For example, Pr4002 (peck retraction) is stored in microns whereas Fanuc #4002 stores in mm. SyntecParameterTableProxy Get-or-create INcDependencyProxy for SyntecParameterTable: the Syntec sibling of FanucParameterTableProxy. Like Fanuc, the Syntec parameter table mixes machine config with per-case work-coordinate offsets, so the proxy carries a fixed machine-config Seed serialized into the shared runner file. On wire, the host receives a deep clone of the seed only when it has no SyntecParameterTable yet; a loaded project's own full table wins. The proxy does not implement the machine-config interfaces — consumers go through GetEffectiveNcDependencyList()."
  },
  "api/Hi.NcParsers.Dependencys.SystemWired.FileIndexCounterDependency.html": {
    "href": "api/Hi.NcParsers.Dependencys.SystemWired.FileIndexCounterDependency.html",
    "title": "Class FileIndexCounterDependency | HiAPI-C# 2025",
    "summary": "Class FileIndexCounterDependency Namespace Hi.NcParsers.Dependencys.SystemWired Assembly HiMech.dll Per-session monotonically-increasing file index allocator. Holds the counter as a private field; Allocate() returns the next unused value and increments. OnSessionReset() rewinds to 0 — the owning RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) invokes it via the ISessionResettable sweep on the same edge that initializes a fresh NcRunnerSessionState, so a controller power-reset clears both the syntax-piece pipeline and this counter in lock-step. Two consumers share one allocator: RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) allocates one index per top-level NC file that streams through the runner. SubProgramCallSyntax allocates a fresh index for each inlined subprogram invocation, including each L repetition — distinct indices ensure (FileIndex, LineIndex) pairs stay unique across overlapping subprogram line ranges. Holding the counter on this dependency rather than on NcRunnerSessionState avoids a duplicate source-of-truth: the dep is the single seam through which syntaxes reach the counter, and there is no third reader that would benefit from session-state visibility. public class FileIndexCounterDependency : INcDependency, IMakeXmlSource, ISessionResettable Inheritance object FileIndexCounterDependency Implements INcDependency IMakeXmlSource ISessionResettable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FileIndexCounterDependency() Initializes a new instance with the counter at 0. public FileIndexCounterDependency() Properties XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods Allocate() Returns the next unused file index and post-increments the counter. First call after construction or OnSessionReset() returns 0. public int Allocate() Returns int MakeXmlSource(string, string, bool) Runtime-only dependency — the live counter value is per-session and not meaningful to persist; serialization writes only the empty element so the dependency survives an XML round-trip with the counter implicitly reset to 0. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement OnSessionReset() Rewinds the counter to 0. Called by RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) via the ISessionResettable sweep on the same edge that initializes a fresh session pipeline so a single brand-preset runner can be reused across sessions without leaking file indices from the previous session. public void OnSessionReset() Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.SystemWired.MachiningServiceDependency.html": {
    "href": "api/Hi.NcParsers.Dependencys.SystemWired.MachiningServiceDependency.html",
    "title": "Class MachiningServiceDependency | HiAPI-C# 2025",
    "summary": "Class MachiningServiceDependency Namespace Hi.NcParsers.Dependencys.SystemWired Assembly HiMech.dll Exposes the full IMachiningService surface to NC pipeline components — currently provided for client-authored syntaxes / semantics that need broad host access (machining equipment, session, tool house, time mapping, …). The built-in CSV pipeline does not consume this dependency; it uses the narrower StepPropertyAccessDictionaryDependency instead. public class MachiningServiceDependency : INcDependency, IMakeXmlSource Inheritance object MachiningServiceDependency Implements INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MachiningServiceDependency() Initializes a new instance with no ServiceProvider; the host wires one before queries. public MachiningServiceDependency() MachiningServiceDependency(Func<IMachiningService>) Initializes a new instance with the given ServiceProvider. public MachiningServiceDependency(Func<IMachiningService> provider) Parameters provider Func<IMachiningService> Delegate that resolves the live service at lookup time. Properties Service The live machining service, or null when ServiceProvider is unset or returns null. public IMachiningService Service { get; } Property Value IMachiningService ServiceProvider Runtime provider for the machining service. Null provider or null return means the host is not wired; consumers must null-check. public Func<IMachiningService> ServiceProvider { get; set; } Property Value Func<IMachiningService> XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Runtime-only dependency — the provider is wired per host and not meaningful to persist; serialization writes only the empty element so the dependency survives an XML round-trip. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.SystemWired.MappingAnchorDependency.html": {
    "href": "api/Hi.NcParsers.Dependencys.SystemWired.MappingAnchorDependency.html",
    "title": "Class MappingAnchorDependency | HiAPI-C# 2025",
    "summary": "Class MappingAnchorDependency Namespace Hi.NcParsers.Dependencys.SystemWired Assembly HiMech.dll Narrow NC-pipeline dependency that lets a CSV semantic convert an absolute controller instant to a run-relative timecode against the project mapping anchor, without reaching the whole IMachiningService surface (cf. MachiningServiceDependency). The host wires ToTimecodeProvider to TimeMapping.ToTimecode, whose set-once ??= seeds (lazily builds) the anchor on first use. Runtime-only: the provider is wired per host and not persisted; serialization writes only the empty element so the dependency survives an XML round-trip. public class MappingAnchorDependency : INcDependency, IMakeXmlSource Inheritance object MappingAnchorDependency Implements INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MappingAnchorDependency() Initializes a new instance with no provider; the host wires one before queries. public MappingAnchorDependency() Properties ToTimecodeProvider Runtime provider for the anchor converter (TimeMapping.ToTimecode). Null provider means the host is not wired; consumers must null-check and fall back to the legacy time-of-day. public Func<DateTime, TimeSpan> ToTimecodeProvider { get; set; } Property Value Func<DateTime, TimeSpan> XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToTimecode(DateTime) Converts instant to a run-relative timecode via the wired anchor, or null when no provider is wired. public TimeSpan? ToTimecode(DateTime instant) Parameters instant DateTime Returns TimeSpan?"
  },
  "api/Hi.NcParsers.Dependencys.SystemWired.NcKinematicsDependency.html": {
    "href": "api/Hi.NcParsers.Dependencys.SystemWired.NcKinematicsDependency.html",
    "title": "Class NcKinematicsDependency | HiAPI-C# 2025",
    "summary": "Class NcKinematicsDependency Namespace Hi.NcParsers.Dependencys.SystemWired Assembly HiMech.dll Provides IMachineKinematics as an INcDependency for SoftNcRunner.PipelineNcDependencyList. The actual kinematics instance is resolved at runtime via KinematicsProvider. This supports scenarios where the machine tool is loaded or changed after the runner is configured (e.g., XML config loaded first, kinematics assigned later). Consumed by G53p1RotaryPositionSyntax, IsoG68p2TiltSyntax, and McLinearMotionSemantic via dependencyList.OfType<IMachineKinematics>(). public class NcKinematicsDependency : INcDependency, IMakeXmlSource, IMachineKinematics Inheritance object NcKinematicsDependency Implements INcDependency IMakeXmlSource IMachineKinematics Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NcKinematicsDependency() Initializes a new instance with no KinematicsProvider; assign one before the runner queries kinematics. public NcKinematicsDependency() NcKinematicsDependency(Func<IMachineKinematics>) Initializes a new instance with the given KinematicsProvider. public NcKinematicsDependency(Func<IMachineKinematics> provider) Parameters provider Func<IMachineKinematics> Delegate that resolves the live IMachineKinematics at lookup time. Properties KinematicsOrNull Non-throwing probe: the live kinematics instance, or null when the provider is unwired or resolves to null (e.g. the machining chain is a ClMillingDevice, so no XyzabcSolver exists). Lets a syntax/semantic that supports both CL and MC chains branch on availability instead of catching InvalidOperationException from the IMachineKinematics members. public IMachineKinematics KinematicsOrNull { get; } Property Value IMachineKinematics KinematicsProvider Runtime provider for the kinematics instance. Null provider or null return means kinematics is not yet available. public Func<IMachineKinematics> KinematicsProvider { get; set; } Property Value Func<IMachineKinematics> ProgramZeroToPnOrNull The program-zero → Pn transform resolved via ProgramZeroToPnProvider, or null when unwired/unavailable; consumers fall back to identity (workpiece frame ≡ Pn frame). public Mat4d ProgramZeroToPnOrNull { get; } Property Value Mat4d ProgramZeroToPnProvider Runtime provider for the rigid transform from program-zero (workpiece) coordinates to the kinematic Pn frame, for pipelines whose source positions live in the workpiece frame (the NX CLSF pipeline). NC G-code pipelines leave it unwired — their program→MC mapping is carried per block by work-offset transform sections instead. The host wires it from the equipment topology (MachiningEquipmentUtil.GetProgramToPnMat4d); the provider is resolved per call so a re-aligned workpiece is picked up without rewiring. public Func<Mat4d> ProgramZeroToPnProvider { get; set; } Property Value Func<Mat4d> XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. McAbcToMat(Vec3d) Converts machine ABC coordinates to a tilt matrix. the tilt matrix is the transformation matrix from table to attacher. public Mat4d McAbcToMat(Vec3d mcAbc_rad) Parameters mcAbc_rad Vec3d The machine ABC coordinates in radians Returns Mat4d The tilt matrix McToMat(DVec3d) Converts machine coordinates to an attacher matrix. public Mat4d McToMat(DVec3d mcXyzabc) Parameters mcXyzabc DVec3d The machine coordinates Returns Mat4d The attacher matrix McToPn(DVec3d) Machine coordinate to tool attacher Pn (Point and Normal). The Pn is from table buckle to tool attacher. public DVec3d McToPn(DVec3d mcXyzabc) Parameters mcXyzabc DVec3d machine coordinate. ABC is in radian. Returns DVec3d tool attacher Pn (Point and Normal) OrientationToMcAbc(Mat4d, out Vec3d) Converts a tilt matrix to machine ABC coordinates. the tilt matrix is the transformation matrix from table to attacher. the solution only fit the orientation part of the tiltMat. public bool OrientationToMcAbc(Mat4d tiltMat, out Vec3d mcAbc_rad) Parameters tiltMat Mat4d The tilt matrix to convert mcAbc_rad Vec3d Output parameter that will contain the machine ABC coordinates in radians Returns bool Whether the conversion was successful OrientationToMcAbc(Vec3d, out Vec3d) Converts a target tool axial direction (endpoint orientation) to machine ABC coordinates. Only the axial alignment is constrained; rotation about the tool axis is free. Use this in place of OrientationToMcAbc(Mat4d, out Vec3d) when the rotation about the tool axis is irrelevant (e.g. G53.1 rotary positioning). The axial-only solve avoids the redundant 6-target full-matrix constraint and is more likely to converge for tilt configurations such as G68.2 I180 J90 K0. public bool OrientationToMcAbc(Vec3d toolAxialNormal, out Vec3d mcAbc_rad) Parameters toolAxialNormal Vec3d Target tool axial direction in table coordinates (the third row of the tilt matrix; e.g. AxialNormal). mcAbc_rad Vec3d Output machine ABC coordinates in radians. Returns bool Whether the conversion was successful. PnToMc(DVec3d, out DVec3d) Tool attacher Pn (Point and Normal) to machine coordinate. The Pn is from table buckle to tool attacher. public bool PnToMc(DVec3d pn, out DVec3d mcXyzabc_rad) Parameters pn DVec3d tool attacher Pn (Point and Normal) mcXyzabc_rad DVec3d machine coordinate (ABC in radian) Returns bool whether conversion succeeded Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.SystemWired.NcLineSourceDependency.html": {
    "href": "api/Hi.NcParsers.Dependencys.SystemWired.NcLineSourceDependency.html",
    "title": "Class NcLineSourceDependency | HiAPI-C# 2025",
    "summary": "Class NcLineSourceDependency Namespace Hi.NcParsers.Dependencys.SystemWired Assembly HiMech.dll In-memory line source for NC “files” with no disk backing — inline NC-code plays whose FilePath is a command-title pseudo-path (e.g. “NC Code”). Control-flow re-segmentation (WHILE reverse jump, backward GOTO, M99 P{seq} caller re-entry — every LabelScanUtil scan) re-reads the host file by path; an inline play's pseudo-path never exists on disk, so without this source those jumps fall through (loops that do not loop) or error with a *FileNotFound diagnostic. RunNc(string, string) registers the play's raw lines under its pseudo-path before running; LabelScanUtil consults this source first and only falls back to disk. Entries persist for the runner's lifetime, the latest registration of a path winning — deliberately NOT ISessionResettable: the session-reset sweep runs inside the first RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) of a fresh session, which would wipe the registration made moments earlier for that very play. A registered pseudo-path shadows an identically-named disk file during re-segmentation, so inline command titles should not mirror real project-relative NC paths. public class NcLineSourceDependency : INcDependency, IMakeXmlSource Inheritance object NcLineSourceDependency Implements INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NcLineSourceDependency() Initializes a new instance with no registered sources. public NcLineSourceDependency() Properties XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods Contains(string) Whether path has a registered line source. public bool Contains(string path) Parameters path string Returns bool MakeXmlSource(string, string, bool) Runtime-only dependency — registrations are per-play and not meaningful to persist; serialization writes only the empty element so the dependency survives an XML round-trip with the map implicitly empty. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Register(string, string[]) Registers (or overwrites) the line content served for path. No-op on a null/empty path or null lines. public void Register(string path, string[] lines) Parameters path string lines string[] TryGetLines(string, out string[]) Gets the registered line content for path; returns whether a registration exists. public bool TryGetLines(string path, out string[] lines) Parameters path string lines string[] Returns bool"
  },
  "api/Hi.NcParsers.Dependencys.SystemWired.ProjectFolderDependency.html": {
    "href": "api/Hi.NcParsers.Dependencys.SystemWired.ProjectFolderDependency.html",
    "title": "Class ProjectFolderDependency | HiAPI-C# 2025",
    "summary": "Class ProjectFolderDependency Namespace Hi.NcParsers.Dependencys.SystemWired Assembly HiMech.dll Exposes the absolute base directory of the project that owns this runner. Resolved at runtime via BaseDirectoryProvider; the host (e.g. LocalProjectService, a test harness) wires the provider to its known project root after the runner is constructed, because SoftNcRunner itself does not retain the baseDirectory argument it sees during XML deserialization. Consumed by syntaxes that need to resolve a project-relative path to an absolute file system location — e.g. SubProgramCallSyntax for O<n> subprogram lookup under InternalFolder. Reading FilePath is not a substitute: that path is relative and resolving it via Path.GetFullPath would anchor against the process working directory, not the project root. public class ProjectFolderDependency : INcDependency, IMakeXmlSource Inheritance object ProjectFolderDependency Implements INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ProjectFolderDependency() Initializes a new instance with no BaseDirectoryProvider; the host assigns one before queries. public ProjectFolderDependency() ProjectFolderDependency(Func<string>) Initializes a new instance with the given BaseDirectoryProvider. public ProjectFolderDependency(Func<string> provider) Parameters provider Func<string> Delegate that resolves the absolute base directory at lookup time. Properties BaseDirectory The live absolute base directory, or null when BaseDirectoryProvider is unset or returns null. public string BaseDirectory { get; } Property Value string BaseDirectoryProvider Runtime provider for the absolute project base directory. Public so cross-assembly hosts (e.g. LocalProjectService in HiNc) can wire it after the runner is constructed — same host-wired posture as KinematicsProvider. Null provider or null return means the host has not configured a base directory yet — consumers should treat this as a configuration error and surface a diagnostic rather than silently falling back. public Func<string> BaseDirectoryProvider { get; set; } Property Value Func<string> XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Runtime-only dependency — the BaseDirectoryProvider is wired per-host and is not meaningful to persist; serialization writes only the empty element so the dependency survives an XML round-trip. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.SystemWired.SegmenterDependency.html": {
    "href": "api/Hi.NcParsers.Dependencys.SystemWired.SegmenterDependency.html",
    "title": "Class SegmenterDependency | HiAPI-C# 2025",
    "summary": "Class SegmenterDependency Namespace Hi.NcParsers.Dependencys.SystemWired Assembly HiMech.dll Exposes the active ISegmenter to syntaxes that need to re-segment auxiliary NC text mid-pipeline (e.g., SubProgramCallSyntax reading an O<n> subprogram file and re-using the host runner's segmenter so the inlined blocks are split with the same rules). The actual segmenter is resolved at runtime via Hi.NcParsers.Dependencys.SystemWired.SegmenterDependency.SegmenterProvider; RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) wires the provider to its own Segmenter at the start of each session run, so this dependency can sit in PipelineNcDependencyList without participating in XML serialization (see MakeXmlSource(string, string, bool)). public class SegmenterDependency : INcDependency, IMakeXmlSource Inheritance object SegmenterDependency Implements INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SegmenterDependency() Initializes a new instance with no Hi.NcParsers.Dependencys.SystemWired.SegmenterDependency.SegmenterProvider; the host runner assigns one before queries. public SegmenterDependency() SegmenterDependency(Func<ISegmenter>) Initializes a new instance with the given Hi.NcParsers.Dependencys.SystemWired.SegmenterDependency.SegmenterProvider. public SegmenterDependency(Func<ISegmenter> provider) Parameters provider Func<ISegmenter> Delegate that resolves the live ISegmenter at lookup time. Properties Segmenter The live segmenter, or null when Hi.NcParsers.Dependencys.SystemWired.SegmenterDependency.SegmenterProvider is unset or returns null. public ISegmenter Segmenter { get; } Property Value ISegmenter XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Runtime-only dependency — the Hi.NcParsers.Dependencys.SystemWired.SegmenterDependency.SegmenterProvider is wired per session and is not meaningful to persist; serialization writes only the empty element so the dependency survives an XML round-trip. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.SystemWired.SentenceIndexCounterDependency.html": {
    "href": "api/Hi.NcParsers.Dependencys.SystemWired.SentenceIndexCounterDependency.html",
    "title": "Class SentenceIndexCounterDependency | HiAPI-C# 2025",
    "summary": "Class SentenceIndexCounterDependency Namespace Hi.NcParsers.Dependencys.SystemWired Assembly HiMech.dll Per-session monotonically-increasing SentenceIndex allocator. Holds the counter as a private field; Allocate() returns the next unused value and increments. OnSessionReset() rewinds to 0 — the owning RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) invokes it via the ISessionResettable sweep on the same edge that initializes a fresh NcRunnerSessionState, so a controller power-reset clears both the syntax-piece pipeline and this counter in lock-step. This dependency exists to fix the sentence-index double-booking bug: before it, the host file's lazy enumerator numbered pieces from layers[0].Count captured at file-append time while subprogram / macro / control-flow re-segmentation numbered from layers[0].Last.Value.SentenceIndex + 1 — two independent sequences that overlap as soon as a call is inlined mid-stream (host blocks after M98 and the inlined body shared the same indices). With this counter, GetSyntaxPieces(ISegmenter, List<INcDependency>, IEnumerable<IndexedFileLine>, int, NcDiagnosticProgress, CancellationToken) allocates one value per piece at materialization time, which the lazy pipeline pulls in execution order — indices are session-globally unique and strictly increasing along the executed stream, at the cost of no longer being contiguous per file (eager label scans discard their pre-label prefix, leaving gaps). Values are never negative, preserving the -1 \"not in pipeline\" sentinel used by SentenceIndex and SentenceIndex. When this dependency is absent from the pipeline list, GetSyntaxPieces(ISegmenter, List<INcDependency>, IEnumerable<IndexedFileLine>, int, NcDiagnosticProgress, CancellationToken) falls back to the caller-supplied begin-index numbering — the legacy colliding behavior. Only code-built runners can hit that fallback: XML rehydration back-fills a missing instance (the SoftNcRunner XML constructor's system-wired back-fill), because saves that predate this dependency never self-heal by round-tripping — re-saving stamps a new ApiVersion on the same incomplete list. public class SentenceIndexCounterDependency : INcDependency, IMakeXmlSource, ISessionResettable Inheritance object SentenceIndexCounterDependency Implements INcDependency IMakeXmlSource ISessionResettable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SentenceIndexCounterDependency() Initializes a new instance with the counter at 0. public SentenceIndexCounterDependency() Properties XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods Allocate() Returns the next unused sentence index and post-increments the counter. First call after construction or OnSessionReset() returns 0. public int Allocate() Returns int MakeXmlSource(string, string, bool) Runtime-only dependency — the live counter value is per-session and not meaningful to persist; serialization writes only the empty element so the dependency survives an XML round-trip with the counter implicitly reset to 0. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement OnSessionReset() Rewinds the counter to 0. Called by RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) via the ISessionResettable sweep on the same edge that initializes a fresh session pipeline so a single brand-preset runner can be reused across sessions without leaking sentence indices from the previous session. public void OnSessionReset() Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.SystemWired.StepPropertyAccessDictionaryDependency.html": {
    "href": "api/Hi.NcParsers.Dependencys.SystemWired.StepPropertyAccessDictionaryDependency.html",
    "title": "Class StepPropertyAccessDictionaryDependency | HiAPI-C# 2025",
    "summary": "Class StepPropertyAccessDictionaryDependency Namespace Hi.NcParsers.Dependencys.SystemWired Assembly HiMech.dll Exposes the host's step-variable registry to NC pipeline components (today: CsvRowSyntax) as a narrow IStepPropertyAccessHost surface. The provider is wired by the host (e.g. LocalProjectService) so the dependency does not carry strong references to host types; this lets the runner be created before the host is fully constructed and reused across project loads. A sibling MachiningServiceDependency exposes the broader IMachiningService surface to client-authored syntaxes. The two dependencies are independent — production hosts typically wire both providers to the same backing object, but a test fixture can supply just this narrow one. public class StepPropertyAccessDictionaryDependency : INcDependency, IMakeXmlSource Inheritance object StepPropertyAccessDictionaryDependency Implements INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors StepPropertyAccessDictionaryDependency() Initializes a new instance with no HostProvider; the host wires one before queries. public StepPropertyAccessDictionaryDependency() StepPropertyAccessDictionaryDependency(Func<IStepPropertyAccessHost>) Initializes a new instance with the given HostProvider. public StepPropertyAccessDictionaryDependency(Func<IStepPropertyAccessHost> provider) Parameters provider Func<IStepPropertyAccessHost> Delegate that resolves the live host at lookup time. Properties Host The live host, or null when HostProvider is unset or returns null. public IStepPropertyAccessHost Host { get; } Property Value IStepPropertyAccessHost HostProvider Runtime provider for the host. Null provider or null return means the host is not wired (e.g. the dependency sits in a runner that runs in a unit-test fixture without a real project service). Consumers must null-check before use. public Func<IStepPropertyAccessHost> HostProvider { get; set; } Property Value Func<IStepPropertyAccessHost> XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Runtime-only dependency — the provider is wired per host and not meaningful to persist; serialization writes only the empty element so the dependency survives an XML round-trip. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.SystemWired.SyntaxPieceLayerDependency.html": {
    "href": "api/Hi.NcParsers.Dependencys.SystemWired.SyntaxPieceLayerDependency.html",
    "title": "Class SyntaxPieceLayerDependency | HiAPI-C# 2025",
    "summary": "Class SyntaxPieceLayerDependency Namespace Hi.NcParsers.Dependencys.SystemWired Assembly HiMech.dll Exposes the per-session SyntaxPiece layer chain (one LazyLinkedList<T> per pipeline stage, owned by NcRunnerSessionState) to syntaxes that need to inject additional source pieces mid-pipeline — most notably SubProgramCallSyntax, which inlines a subprogram file's blocks back into layers[0] immediately after the M98 host node so the entire syntax pipeline naturally re-processes them. The actual layer list is resolved at runtime via Hi.NcParsers.Dependencys.SystemWired.SyntaxPieceLayerDependency.LayersProvider; RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) wires the provider to the active session's SyntaxPieceLayers at the start of each call. Index 0 is the source layer (init seed + sentence-derived pieces); indices 1..N are post-NcSyntax layers — same convention as NcRunnerSessionState. public class SyntaxPieceLayerDependency : INcDependency, IMakeXmlSource Inheritance object SyntaxPieceLayerDependency Implements INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SyntaxPieceLayerDependency() Initializes a new instance with no Hi.NcParsers.Dependencys.SystemWired.SyntaxPieceLayerDependency.LayersProvider; the host runner assigns one before queries. public SyntaxPieceLayerDependency() SyntaxPieceLayerDependency(Func<List<LazyLinkedList<SyntaxPiece>>>) Initializes a new instance with the given Hi.NcParsers.Dependencys.SystemWired.SyntaxPieceLayerDependency.LayersProvider. public SyntaxPieceLayerDependency(Func<List<LazyLinkedList<SyntaxPiece>>> provider) Parameters provider Func<List<LazyLinkedList<SyntaxPiece>>> Delegate that resolves the live layer chain at lookup time. Properties Layers The live layer chain, or null when Hi.NcParsers.Dependencys.SystemWired.SyntaxPieceLayerDependency.LayersProvider is unset or returns null. Layer 0 is the source layer; layers 1..N are post-NcSyntax layers. public List<LazyLinkedList<SyntaxPiece>> Layers { get; } Property Value List<LazyLinkedList<SyntaxPiece>> XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Runtime-only dependency — the Hi.NcParsers.Dependencys.SystemWired.SyntaxPieceLayerDependency.LayersProvider is wired per session and is not meaningful to persist; serialization writes only the empty element so the dependency survives an XML round-trip. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.SystemWired.ToolHouseDependency.html": {
    "href": "api/Hi.NcParsers.Dependencys.SystemWired.ToolHouseDependency.html",
    "title": "Class ToolHouseDependency | HiAPI-C# 2025",
    "summary": "Class ToolHouseDependency Namespace Hi.NcParsers.Dependencys.SystemWired Assembly HiMech.dll Exposes the project's MachiningToolHouse to NC pipeline components — the narrow counterpart of MachiningServiceDependency for syntaxes / semantics that only look up or register tools (e.g. the CLSF pipeline's TLDATA-driven tool creation). public class ToolHouseDependency : INcDependency, IMakeXmlSource Inheritance object ToolHouseDependency Implements INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ToolHouseDependency() Initializes a new instance with no ToolHouseProvider; the host wires one before queries. public ToolHouseDependency() ToolHouseDependency(Func<MachiningToolHouse>) Initializes a new instance with the given ToolHouseProvider. public ToolHouseDependency(Func<MachiningToolHouse> provider) Parameters provider Func<MachiningToolHouse> Delegate that resolves the live tool house at lookup time. Properties ToolHouse The live tool house, or null when ToolHouseProvider is unset or returns null. public MachiningToolHouse ToolHouse { get; } Property Value MachiningToolHouse ToolHouseProvider Runtime provider for the tool house. Null provider or null return means the host is not wired; consumers must null-check. public Func<MachiningToolHouse> ToolHouseProvider { get; set; } Property Value Func<MachiningToolHouse> XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Runtime-only dependency — the provider is wired per host and not meaningful to persist; serialization writes only the empty element so the dependency survives an XML round-trip. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Dependencys.SystemWired.html": {
    "href": "api/Hi.NcParsers.Dependencys.SystemWired.html",
    "title": "Namespace Hi.NcParsers.Dependencys.SystemWired | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.Dependencys.SystemWired Classes FileIndexCounterDependency Per-session monotonically-increasing file index allocator. Holds the counter as a private field; Allocate() returns the next unused value and increments. OnSessionReset() rewinds to 0 — the owning RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) invokes it via the ISessionResettable sweep on the same edge that initializes a fresh NcRunnerSessionState, so a controller power-reset clears both the syntax-piece pipeline and this counter in lock-step. Two consumers share one allocator: RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) allocates one index per top-level NC file that streams through the runner. SubProgramCallSyntax allocates a fresh index for each inlined subprogram invocation, including each L repetition — distinct indices ensure (FileIndex, LineIndex) pairs stay unique across overlapping subprogram line ranges. Holding the counter on this dependency rather than on NcRunnerSessionState avoids a duplicate source-of-truth: the dep is the single seam through which syntaxes reach the counter, and there is no third reader that would benefit from session-state visibility. MachiningServiceDependency Exposes the full IMachiningService surface to NC pipeline components — currently provided for client-authored syntaxes / semantics that need broad host access (machining equipment, session, tool house, time mapping, …). The built-in CSV pipeline does not consume this dependency; it uses the narrower StepPropertyAccessDictionaryDependency instead. MappingAnchorDependency Narrow NC-pipeline dependency that lets a CSV semantic convert an absolute controller instant to a run-relative timecode against the project mapping anchor, without reaching the whole IMachiningService surface (cf. MachiningServiceDependency). The host wires ToTimecodeProvider to TimeMapping.ToTimecode, whose set-once ??= seeds (lazily builds) the anchor on first use. Runtime-only: the provider is wired per host and not persisted; serialization writes only the empty element so the dependency survives an XML round-trip. NcKinematicsDependency Provides IMachineKinematics as an INcDependency for SoftNcRunner.PipelineNcDependencyList. The actual kinematics instance is resolved at runtime via KinematicsProvider. This supports scenarios where the machine tool is loaded or changed after the runner is configured (e.g., XML config loaded first, kinematics assigned later). Consumed by G53p1RotaryPositionSyntax, IsoG68p2TiltSyntax, and McLinearMotionSemantic via dependencyList.OfType<IMachineKinematics>(). NcLineSourceDependency In-memory line source for NC “files” with no disk backing — inline NC-code plays whose FilePath is a command-title pseudo-path (e.g. “NC Code”). Control-flow re-segmentation (WHILE reverse jump, backward GOTO, M99 P{seq} caller re-entry — every LabelScanUtil scan) re-reads the host file by path; an inline play's pseudo-path never exists on disk, so without this source those jumps fall through (loops that do not loop) or error with a *FileNotFound diagnostic. RunNc(string, string) registers the play's raw lines under its pseudo-path before running; LabelScanUtil consults this source first and only falls back to disk. Entries persist for the runner's lifetime, the latest registration of a path winning — deliberately NOT ISessionResettable: the session-reset sweep runs inside the first RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) of a fresh session, which would wipe the registration made moments earlier for that very play. A registered pseudo-path shadows an identically-named disk file during re-segmentation, so inline command titles should not mirror real project-relative NC paths. ProjectFolderDependency Exposes the absolute base directory of the project that owns this runner. Resolved at runtime via BaseDirectoryProvider; the host (e.g. LocalProjectService, a test harness) wires the provider to its known project root after the runner is constructed, because SoftNcRunner itself does not retain the baseDirectory argument it sees during XML deserialization. Consumed by syntaxes that need to resolve a project-relative path to an absolute file system location — e.g. SubProgramCallSyntax for O<n> subprogram lookup under InternalFolder. Reading FilePath is not a substitute: that path is relative and resolving it via Path.GetFullPath would anchor against the process working directory, not the project root. SegmenterDependency Exposes the active ISegmenter to syntaxes that need to re-segment auxiliary NC text mid-pipeline (e.g., SubProgramCallSyntax reading an O<n> subprogram file and re-using the host runner's segmenter so the inlined blocks are split with the same rules). The actual segmenter is resolved at runtime via Hi.NcParsers.Dependencys.SystemWired.SegmenterDependency.SegmenterProvider; RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) wires the provider to its own Segmenter at the start of each session run, so this dependency can sit in PipelineNcDependencyList without participating in XML serialization (see MakeXmlSource(string, string, bool)). SentenceIndexCounterDependency Per-session monotonically-increasing SentenceIndex allocator. Holds the counter as a private field; Allocate() returns the next unused value and increments. OnSessionReset() rewinds to 0 — the owning RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) invokes it via the ISessionResettable sweep on the same edge that initializes a fresh NcRunnerSessionState, so a controller power-reset clears both the syntax-piece pipeline and this counter in lock-step. This dependency exists to fix the sentence-index double-booking bug: before it, the host file's lazy enumerator numbered pieces from layers[0].Count captured at file-append time while subprogram / macro / control-flow re-segmentation numbered from layers[0].Last.Value.SentenceIndex + 1 — two independent sequences that overlap as soon as a call is inlined mid-stream (host blocks after M98 and the inlined body shared the same indices). With this counter, GetSyntaxPieces(ISegmenter, List<INcDependency>, IEnumerable<IndexedFileLine>, int, NcDiagnosticProgress, CancellationToken) allocates one value per piece at materialization time, which the lazy pipeline pulls in execution order — indices are session-globally unique and strictly increasing along the executed stream, at the cost of no longer being contiguous per file (eager label scans discard their pre-label prefix, leaving gaps). Values are never negative, preserving the -1 \"not in pipeline\" sentinel used by SentenceIndex and SentenceIndex. When this dependency is absent from the pipeline list, GetSyntaxPieces(ISegmenter, List<INcDependency>, IEnumerable<IndexedFileLine>, int, NcDiagnosticProgress, CancellationToken) falls back to the caller-supplied begin-index numbering — the legacy colliding behavior. Only code-built runners can hit that fallback: XML rehydration back-fills a missing instance (the SoftNcRunner XML constructor's system-wired back-fill), because saves that predate this dependency never self-heal by round-tripping — re-saving stamps a new ApiVersion on the same incomplete list. StepPropertyAccessDictionaryDependency Exposes the host's step-variable registry to NC pipeline components (today: CsvRowSyntax) as a narrow IStepPropertyAccessHost surface. The provider is wired by the host (e.g. LocalProjectService) so the dependency does not carry strong references to host types; this lets the runner be created before the host is fully constructed and reused across project loads. A sibling MachiningServiceDependency exposes the broader IMachiningService surface to client-authored syntaxes. The two dependencies are independent — production hosts typically wire both providers to the same backing object, but a test fixture can supply just this narrow one. SyntaxPieceLayerDependency Exposes the per-session SyntaxPiece layer chain (one LazyLinkedList<T> per pipeline stage, owned by NcRunnerSessionState) to syntaxes that need to inject additional source pieces mid-pipeline — most notably SubProgramCallSyntax, which inlines a subprogram file's blocks back into layers[0] immediately after the M98 host node so the entire syntax pipeline naturally re-processes them. The actual layer list is resolved at runtime via Hi.NcParsers.Dependencys.SystemWired.SyntaxPieceLayerDependency.LayersProvider; RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) wires the provider to the active session's SyntaxPieceLayers at the start of each call. Index 0 is the source layer (init seed + sentence-derived pieces); indices 1..N are post-NcSyntax layers — same convention as NcRunnerSessionState. ToolHouseDependency Exposes the project's MachiningToolHouse to NC pipeline components — the narrow counterpart of MachiningServiceDependency for syntaxes / semantics that only look up or register tools (e.g. the CLSF pipeline's TLDATA-driven tool creation)."
  },
  "api/Hi.NcParsers.Dependencys.html": {
    "href": "api/Hi.NcParsers.Dependencys.html",
    "title": "Namespace Hi.NcParsers.Dependencys | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.Dependencys Classes CncBrandDependency Explicit CNC controller brand identifier carried in PipelineNcDependencyList. Use ncDependencyList.OfType<CncBrandDependency>().FirstOrDefault() to retrieve the brand. ControllerParameterTableBase Base class for brand-specific controller parameter tables. Provides shared data structures, XML IO, and IHomeMcConfig IMachineAxisConfig implementations. Subclasses define brand-specific parameter numbers, XML attribute names, and derived convenience properties. HeidenhainDatumTable Heidenhain datum preset and datum shift tables. CYCL DEF 247 Q339=N reads from DatumPresetTable, CYCL DEF 7 #N reads from DatumShiftTable. Each table maps an integer ID (1–20) to a Vec3d offset. On real Heidenhain controllers, preset and datum tables are separate disk files (e.g. TNC:\\table\\preset.pr, *.d) — distinct from MP-prefixed Machine Parameters (held by HeidenhainParameterTable). HiNC mirrors that separation by keeping this dependency independent of HeidenhainParameterTable. Implements IIsoCoordinateConfig by mapping the ISO/DIN G54–G59 codes to preset rows 1–6, the conventional Heidenhain compatibility mapping for ISO/DIN programs running on a Heidenhain. HeidenhainDatumTableProxy Get-or-create INcDependencyProxy for HeidenhainDatumTable: a placeholder in the shared PipelineNcDependencyList that resolves the host project's own per-case datum preset / datum shift tables. IsoCoordinateAddressMap Fanuc-style ISO coordinate parameter address mapping. G54–G59 → #5221+ (stride 20, three consecutive numbers per entry for X/Y/Z), G54.1 P1–P48 → #7001+ (stride 20). Shared between FanucParameterTable (which calls these “ParamId”) and SyntecParameterTable (which calls them “PrId”) because both follow the same numeric scheme. MCodeEffects What one machine-declared M-code does. Real-machine OEM M-codes are frequently composite — e.g. an M13 that means “spindle CW + flood coolant on” — so a declaration carries every effect the code performs rather than a single meaning, and additionally an UnmodeledNote for the parts this simulation does not model. Declaring only the known parts and staying loud about the rest keeps a composite code from being half-consumed silently. Stored per machine in MCodeDeclarations and consumed by MCodeExpansionSyntax, which expands the declared code into the canonical ISO flags the regular consumers already understand. StrokeLimitUtil Load-time audit helpers for IStrokeLimitConfig: which machine-coordinate axes the chain has, and which of them the stroke limit check cannot judge because no limit is configured. Both checks — the per-block StrokeLimitCheckSemantic and the per-step CheckStrokeLimit(DVec3d, IProgress<IMessage>) — compare only axes that carry a limit, so a machine file without limits passes every position silently while EnableStrokeLimitCheck reads as on. The session begin reports that gap once through these helpers. Interfaces IBlockSkipConfig Runtime state of the controller's Block Delete / Block Skip switches. Present in PipelineNcDependencyList exposes this to the runner so that blocks whose head carries / or /N (parsed by BlockSkipSyntax into BlockSkip) are skipped at semantic time. Layers are 1..9; Layer 1 corresponds to the bare / prefix. Controllers (Fanuc / Syntec / Mazak / Siemens) let each layer be toggled independently via panel switches or system parameters. When this dependency is absent from PipelineNcDependencyList, no block is skipped (safest default: simulate the full machining). The syntax still consumes the / prefix so no UnparsedText--Remaining diagnostic is produced. ICannedCycleConfig Canned cycle configuration parameters. Implemented by brand-specific parameter tables (e.g., FanucParameterTable for Fanuc #4002, SyntecParameterTable for Syntec Pr4002) and by FallbackConfig as a safety net. Siemens and Heidenhain specify peck clearance per-call (CYCLE83 parameter / CYCL DEF), so their tables do not implement this interface. The FallbackConfig provides the default value in those cases. IHomeMcConfig G28 first reference position (home machine coordinate) per axis. IIndexingPositionConfig Indexing-axis position table: maps 1-based indexing position numbers to axis coordinates for axes that only take up discrete stations (Hirth couplings, indexing rotary tables, turret-style workholders). Consumed by the coded-position coordinate functions (Siemens CAC()/CIC()/CDC()/CACP()/CACN() — unwrapped by SiemensAcIcSyntax, resolved by McAbcSyntax / IncrementalResolveSyntax via CodedPositionUtil). Implemented by SiemensMachineDataTable using the Siemens machine data (MD30500 $MA_INDEX_AX_ASSIGN_POS_TAB per axis; global tables MD10910/MD10930; equidistant MD30501–MD30503). Positions are expressed in the axis' native units (degrees for rotary, mm for linear) in the coordinate frame the axis word itself is written in — machine coordinates for rotary words, program coordinates for linear words. Position numbering is 1-based: number 1 is the first table entry (the Siemens machine-data help and alarm texts count this way; the 0-based value range printed in some programming-manual editions describes the machine-data array index, not the programmable number). IIsoCoordinateConfig ISO work coordinate offset provider. Maps a G-code work coordinate id (e.g. “G54”, “G59.2”, “G54.1P1”) to a machine-coordinate offset Vec3d. Implementations include IsoCoordinateTable (brand-agnostic standalone storage), FanucParameterTable / SyntecParameterTable (parameter-table integration via real Fanuc/Syntec parameter numbers #5221+ for G54–G59 and #7001+ for G54.1 P1–P48), SiemensFrameTable (Sinumerik $P_UIFR frames), and HeidenhainDatumTable (Heidenhain preset rows). IMCodeDeclarationConfig Machine-declared M-code map: what each machine-specific (OEM/PLC) M-code does, as MCodeEffects — possibly several effects per code (tool change, spindle direction, coolant) plus a note for behavior this simulation does not model. Consumed by MCodeExpansionSyntax, which expands declared codes into the canonical ISO flags ahead of the regular consumers. Machine-level (per-case parameter table) rather than brand vocabulary — implemented by ControllerParameterTableBase, alongside the narrower ISpindleControlConfig face over the same storage. IMachineAxisConfig Machine axis configuration: which axes exist and their types. Compatible with Fanuc, Siemens, Heidenhain, Mazak, Okuma. INcDependency Marker interface for objects that participate in the NC dependency list resolved by the soft-NC runtime. INcDependencyListHost Hosts a per-case INcDependency list that INcDependencyProxy placeholders in a shared SoftNcRunner resolve their data against. Implemented by the object owning both the shared runner and the varied setting data — e.g. MachiningProject. INcDependencyProxy An INcDependency placeholder that resolves the real dependency lazily at pipeline-build time instead of carrying the data itself. Lets a shared SoftNcRunner hold only the fixed pipeline logic while the frequently-varied data lives on the owning INcDependencyListHost (e.g. a MachiningProject). \"Maker and taker\": GetNcDependency() either constructs the dependency on demand (maker) or fetches one from the host wired by InitNcDependencyHost(INcDependencyListHost) (taker). A get-or-create proxy does both — it takes the host's instance when present and otherwise makes one, installing it into the host list so it persists and is editable per case. A proxy may carry runtime-only state (the wired host, a memoized resolved dependency). That state is host-wired per run and MUST NOT be written by MakeXmlSource(string, string, bool) — same runtime-only posture as ProjectFolderDependency. IPowerResettable Marks an INcDependency that holds volatile state which must be cleared when the controller performs a power reset (power off then on). Implementers should clear only the volatile subset they own (e.g. Fanuc common volatile macro variables #100-#499), and leave persistent state untouched (e.g. #500-#999, controller parameters). Call-frame local state (Fanuc #1-#33, Heidenhain Q200-Q1199) is NOT in scope — that lives in the SyntaxPiece JSON dataflow and is bounded by call activation, not power cycle. IRapidFeedrateConfig Provides per-axis rapid traverse feedrate for motion semantics. Implemented by ControllerParameterTableBase using brand-specific parameter numbers (e.g., Fanuc #1420, Siemens MD32000, Heidenhain MP1010). ISpindleControlConfig Machine-specific spindle control codes: maps custom spindle direction M-codes to SpindleDirection — e.g., an ultrasonic spindle started by M203 (CW) and stopped by M205 (STOP) instead of ISO M03/M05. Consulted by SpindleSpeedSyntax in addition to the built-in ISO defaults (M03/M04/M05), which always stay in effect; a configured code wins over its ISO meaning when both match. Machine-level (per-case parameter table) rather than brand vocabulary — implemented by ControllerParameterTableBase as a spindle-direction face over its MCodeDeclarations storage (the multi-effect IMCodeDeclarationConfig map), so one code is never half-recognized by two separate maps. IStrokeLimitConfig Per-axis stroke (travel) limits. Unit is mm for linear axes, deg for rotary axes. Implemented by ControllerParameterTableBase using brand-specific parameter numbers (e.g., Fanuc #1300/#1320, Siemens MD36100/MD36110, Heidenhain MP420/MP430). IToolChangeTriggerConfig Machine-level tool-change trigger mode. Machining centers with a magazine treat a bare T word as pre-selection only (the magazine rotates, no feed axis moves) and change the tool on the trigger M-code; lathes/turret machines index the turret — and thereby change the tool — on the T word itself. Real controllers declare this per machine (e.g. Siemens MD22550 $MC_TOOL_CHANGE_MODE, where 0 means the T word performs the change). Consulted by ToolChangeSyntax; machine-level (per-case parameter table) rather than brand vocabulary — implemented by ControllerParameterTableBase. Custom trigger M-codes are the separate IMCodeDeclarationConfig concern (IsToolChange). IToolOffsetConfig Tool offset configuration indexed by a single integer offset number. Applies to Fanuc (H/D numbers), Heidenhain (tool number), Mazak, Okuma, and other ISO-compatible controllers where one integer selects the offset row. For Siemens (840D/Sinumerik) where offsets are addressed by (tool number, cutting edge D number), see ISiemensToolOffsetConfig. IToolingMcConfig Machine position axes move to during tool change (M06). Enums AxisType Axis type: linear (translation), rotary (rotation), or spindle (speed/positioning dual mode)."
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.CallStackUtil.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.CallStackUtil.html",
    "title": "Class CallStackUtil | HiAPI-C# 2025",
    "summary": "Class CallStackUtil Namespace Hi.NcParsers.EvaluationSyntaxs Assembly HiMech.dll Push / pop helpers for the per-block CallStack section. Both produce a fresh deep-cloned JsonObject ready to stamp onto an inlined piece (push site) or onto an M99 return block (pop site); the caller is responsible for deep-cloning again if it distributes the same stamp across multiple pieces of an L-repetition. Pairs with ModalCarrySyntax at the Logic stage: explicit push / pop writes seed the section at frame boundaries, ModalCarry copies it forward to every block in between so each block is self-contained for cache-dump readers and downstream consumers (notably M99 P{seq} reading the top frame's CallerFilePath). public static class CallStackUtil Inheritance object CallStackUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods BuildPoppedCallStack(JsonObject) Builds the post-pop CallStack section to stamp onto an M99 return block. Reads the M99 block's currently-carried stack, deep-clones it, and drops the top frame. Returns null when there was no frame to pop (M99 in main file with no caller — the runner treats this as program-end via the implicit fall-through; no stamp is needed). public static JsonObject BuildPoppedCallStack(JsonObject hostJson) Parameters hostJson JsonObject The M99 block's JSON object (post-carry, before this pop runs). Returns JsonObject BuildPushedCallStack(JsonObject, string) Builds the post-push CallStack section to stamp onto every inlined-body piece of a call. Reads the host block's current stack (defaulting to empty when absent — main-frame caller), deep-clones it, and appends a new CallFrame whose CallerFilePath records where the call originated. The returned JsonObject can be safely deep-cloned by the caller for each piece in an L-repetition. public static JsonObject BuildPushedCallStack(JsonObject hostJson, string callerFilePath) Parameters hostJson JsonObject The call-host block's JSON object. callerFilePath string Project-relative path of the host file (typically FilePath on the host piece). Returns JsonObject GetTopCallerFilePath(JsonObject) Returns the top frame's CallerFilePath from the given block's CallStack section, or null when the stack is empty or absent (block is in the main frame). public static string GetTopCallerFilePath(JsonObject hostJson) Parameters hostJson JsonObject Returns string"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.EvalResult.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.EvalResult.html",
    "title": "Struct EvalResult | HiAPI-C# 2025",
    "summary": "Struct EvalResult Namespace Hi.NcParsers.EvaluationSyntaxs.Evaluation Assembly HiMech.dll Outcome of evaluating an NcExpr. Either a successful numeric value, or a failure with an error code matching the diagnostic catalogue used by reading / evaluator syntaxes. public readonly record struct EvalResult : IEquatable<EvalResult> Implements IEquatable<EvalResult> Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors EvalResult(double?, string, string) Outcome of evaluating an NcExpr. Either a successful numeric value, or a failure with an error code matching the diagnostic catalogue used by reading / evaluator syntaxes. public EvalResult(double? Value, string ErrorCode, string ErrorMessage) Parameters Value double? ErrorCode string ErrorMessage string Properties ErrorCode public string ErrorCode { get; init; } Property Value string ErrorMessage public string ErrorMessage { get; init; } Property Value string IsSuccess true when ErrorCode is null. public bool IsSuccess { get; } Property Value bool Value public double? Value { get; init; } Property Value double? Methods Failure(string, string) Failed evaluation with a diagnostic code and message. public static EvalResult Failure(string errorCode, string errorMessage) Parameters errorCode string errorMessage string Returns EvalResult Success(double) Successful evaluation. public static EvalResult Success(double value) Parameters value double Returns EvalResult"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.IRuntimeVariableLookup.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.IRuntimeVariableLookup.html",
    "title": "Interface IRuntimeVariableLookup | HiAPI-C# 2025",
    "summary": "Interface IRuntimeVariableLookup Namespace Hi.NcParsers.EvaluationSyntaxs.Evaluation Assembly HiMech.dll Stateless variable lookup that needs per-block runtime context — the current SyntaxPiece node (for Previous traceback into runtime-state sections like MachineCoordinateState / ProgramXyz) and the dependency list (so the lookup can read from sibling dependencies without holding a static reference). Distinguished from IVariableLookup: that one is for long-lived dependencies that already hold their own data (parameter tables, tool-offset wrappers, retained-variable tables) and need no block context. IRuntimeVariableLookup is for context-sensitive resolutions configured declaratively on RuntimeVariableLookups. Implementations should be brand-specific (e.g. Fanuc #5001-#5043 position reads) and return null for keys outside their range so the evaluator's chain can fall through to the next lookup. Implementations are XML-serialised as part of VariableEvaluatorSyntax's round-trip: each impl exposes a static XName, registers itself with Generators, and implements MakeXmlSource(string, string, bool). Since impls are stateless, the typical body is just an empty element carrying the type name; brand identity is restored by XFactory dispatch. public interface IRuntimeVariableLookup : IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods Get(string, LazyLinkedListNode<SyntaxPiece>, IReadOnlyList<INcDependency>) Returns the value of the variable identified by key in the context of node and dependencies, or null if the key is outside this lookup's range or the value is vacant. double? Get(string key, LazyLinkedListNode<SyntaxPiece> node, IReadOnlyList<INcDependency> dependencies) Parameters key string node LazyLinkedListNode<SyntaxPiece> dependencies IReadOnlyList<INcDependency> Returns double?"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.IVariableLookup.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.IVariableLookup.html",
    "title": "Interface IVariableLookup | HiAPI-C# 2025",
    "summary": "Interface IVariableLookup Namespace Hi.NcParsers.EvaluationSyntaxs.Evaluation Assembly HiMech.dll Resolves a Custom Macro B variable reference to its current numeric value, or null for vacant (Fanuc <vacant>) and out-of-scope alike. The key is the raw source token — Fanuc \"#124\", Heidenhain \"Q1\", Siemens \"R1\" — so the interface itself is brand-agnostic. Implementations are typically narrow (one per id range / per brand prefix) and parse the prefix locally; chain them at the call site by trying each in priority order until one returns a non-null value. A returned null is treated by NcExpressionEvaluator as vacant and surfaces as a Variable--Vacant failure when the value is consumed in arithmetic context. public interface IVariableLookup Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods Get(string) Returns the value of the variable identified by key (e.g. \"#124\"), or null if vacant or unknown to this lookup. double? Get(string key) Parameters key string Returns double?"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.LocalVariableLookup.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.LocalVariableLookup.html",
    "title": "Class LocalVariableLookup | HiAPI-C# 2025",
    "summary": "Class LocalVariableLookup Namespace Hi.NcParsers.EvaluationSyntaxs.Evaluation Assembly HiMech.dll Reads Fanuc-style local macro variables (#1-#33) from Vars.Local on the current SyntaxPiece JSON, falling back to the immediately previous block when they share the same MacroFrame id. Self-gates the id range so the evaluator's RuntimeVariableLookups chain can fall through to the next lookup for out-of-range keys. Two-step lookup (mirrors VolatileVariableLookup): the current block sees writes that FanucMacroCallSyntax stamped at inline time (the call-line argument bindings) and writes that FanucLocalVariableReadingSyntax applied on this block before the lookup runs; the previous block (frame-checked) supplies body-internal writes from the prior block in the same macro frame. Looking past the previous block is unnecessary because the reader carries forward block-by-block within a frame. Frame isolation via MacroFrame: a previous block whose frame id differs from the current block's is skipped — a macro body's body-internal locals are invisible to the caller after return, and the caller's main-frame locals are invisible inside the macro. M98/M198 subprogram inlining (SubProgramCallSyntax) deliberately does not stamp MacroFrame on its inlined blocks, so the callee inherits the caller's frame and sees the caller's locals — matching real Fanuc M98 semantics. Stateless and dependency-free — instances are interchangeable. public class LocalVariableLookup : IRuntimeVariableLookup, IMakeXmlSource Inheritance object LocalVariableLookup Implements IRuntimeVariableLookup IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors LocalVariableLookup() Default constructor. public LocalVariableLookup() LocalVariableLookup(XElement) Loads from an XML element produced by MakeXmlSource(string, string, bool). Stateless — no fields to deserialise. public LocalVariableLookup(XElement src) Parameters src XElement Fields LocalMax Inclusive upper bound of the macro-local range (#33). public const int LocalMax = 33 Field Value int LocalMin Inclusive lower bound of the macro-local range (#1). public const int LocalMin = 1 Field Value int Properties XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Get(string, LazyLinkedListNode<SyntaxPiece>, IReadOnlyList<INcDependency>) Returns the value of the variable identified by key in the context of node and dependencies, or null if the key is outside this lookup's range or the value is vacant. public double? Get(string key, LazyLinkedListNode<SyntaxPiece> node, IReadOnlyList<INcDependency> dependencies) Parameters key string node LazyLinkedListNode<SyntaxPiece> dependencies IReadOnlyList<INcDependency> Returns double? MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcBinaryExpr.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcBinaryExpr.html",
    "title": "Class NcBinaryExpr | HiAPI-C# 2025",
    "summary": "Class NcBinaryExpr Namespace Hi.NcParsers.EvaluationSyntaxs.Evaluation Assembly HiMech.dll Binary operation on two operands. Covers arithmetic (+ - * / / MOD), comparison (EQ NE GT GE LT LE, yielding 1.0 / 0.0), and logical bitwise (AND OR XOR, operands truncated to long). public sealed record NcBinaryExpr : NcExpr, IEquatable<NcExpr>, IEquatable<NcBinaryExpr> Inheritance object NcExpr NcBinaryExpr Implements IEquatable<NcExpr> IEquatable<NcBinaryExpr> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NcBinaryExpr(NcBinaryOp, NcExpr, NcExpr) Binary operation on two operands. Covers arithmetic (+ - * / / MOD), comparison (EQ NE GT GE LT LE, yielding 1.0 / 0.0), and logical bitwise (AND OR XOR, operands truncated to long). public NcBinaryExpr(NcBinaryOp Op, NcExpr Left, NcExpr Right) Parameters Op NcBinaryOp Left NcExpr Right NcExpr Properties Left public NcExpr Left { get; init; } Property Value NcExpr Op public NcBinaryOp Op { get; init; } Property Value NcBinaryOp Right public NcExpr Right { get; init; } Property Value NcExpr"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcBinaryOp.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcBinaryOp.html",
    "title": "Enum NcBinaryOp | HiAPI-C# 2025",
    "summary": "Enum NcBinaryOp Namespace Hi.NcParsers.EvaluationSyntaxs.Evaluation Assembly HiMech.dll Binary operators allowed in Fanuc Custom Macro B value expressions. public enum NcBinaryOp Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Add = 0 a + b. And = 11 a AND b — bitwise AND on operands truncated to long. Non-finite or out-of-range operands surface Arithmetic–MathError. Divide = 3 a / b. Eq = 5 a EQ b — equal; yields 1.0 (true) or 0.0 (false). Ge = 8 a GE b — greater than or equal; yields 1.0 or 0.0. Gt = 7 a GT b — greater than; yields 1.0 or 0.0. Le = 10 a LE b — less than or equal; yields 1.0 or 0.0. Lt = 9 a LT b — less than; yields 1.0 or 0.0. Mod = 4 a MOD b (truncated remainder, sign of a). Multiply = 2 a * b. Ne = 6 a NE b — not equal; yields 1.0 or 0.0. Or = 12 a OR b — bitwise OR on operands truncated to long. Non-finite or out-of-range operands surface Arithmetic–MathError. Subtract = 1 a - b. Xor = 13 a XOR b — bitwise XOR on operands truncated to long. Non-finite or out-of-range operands surface Arithmetic–MathError."
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcExpr.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcExpr.html",
    "title": "Class NcExpr | HiAPI-C# 2025",
    "summary": "Class NcExpr Namespace Hi.NcParsers.EvaluationSyntaxs.Evaluation Assembly HiMech.dll AST root for a Fanuc Custom Macro B value expression. Concrete leaves and combinators sit alongside NcExpressionParser; walking is the job of NcExpressionEvaluator. public abstract record NcExpr : IEquatable<NcExpr> Inheritance object NcExpr Implements IEquatable<NcExpr> Derived NcBinaryExpr NcFunctionExpr NcIndirectVariableExpr NcLiteralExpr NcUnaryExpr NcVariableExpr Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcExpressionDialect.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcExpressionDialect.html",
    "title": "Enum NcExpressionDialect | HiAPI-C# 2025",
    "summary": "Enum NcExpressionDialect Namespace Hi.NcParsers.EvaluationSyntaxs.Evaluation Assembly HiMech.dll Selects which brand expression grammar a syntax parses value expressions with. All dialects produce the same NcExpr AST and are evaluated by the shared NcExpressionEvaluator — the dialect only decides tokenization/grammar (Fanuc #nnn + brackets vs Siemens Rn/named/$ + parentheses). public enum NcExpressionDialect Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Fanuc = 1 Fanuc Custom Macro B grammar (NcExpressionParser). Heidenhain = 3 Heidenhain klartext FN grammar (HeidenhainExpressionParser). None = 0 No expression grammar wired — capture syntaxes keep their legacy lexical RHS boundary (regex + TerminateWords). Not a valid value for Dialect, which always evaluates with a concrete grammar. Siemens = 2 Sinumerik grammar (SiemensExpressionParser)."
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcExpressionDialectUtil.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcExpressionDialectUtil.html",
    "title": "Class NcExpressionDialectUtil | HiAPI-C# 2025",
    "summary": "Class NcExpressionDialectUtil Namespace Hi.NcParsers.EvaluationSyntaxs.Evaluation Assembly HiMech.dll Dispatch helpers over NcExpressionDialect so shared syntaxes (VariableEvaluatorSyntax, the assignment/tag capture syntaxes) stay brand-agnostic: they hold a dialect value and route through here instead of hard-coding a parser type. public static class NcExpressionDialectUtil Inheritance object NcExpressionDialectUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods IsVariableKey(NcExpressionDialect, string) Cheap validity gate for variable keys entering the evaluator's lookup chain — rejects obviously-non-variable keys before the chain walk. Keys are produced by the dialect's own parser, so this is defensive. public static bool IsVariableKey(NcExpressionDialect dialect, string key) Parameters dialect NcExpressionDialect key string Returns bool MakePrefixParser(NcExpressionDialect) Materializes a dialect into the optional longest-valid-prefix hook the capture helpers take (GrabTagEqualsValue(ref string, IEnumerable<string>, ExpressionPrefixParser) / GrabTagAssignment(ref string, IEnumerable<string>, string, IEnumerable<string>, ExpressionPrefixParser)); null for None and for dialects without prefix support (legacy lexical capture). public static ExpressionPrefixParser MakePrefixParser(NcExpressionDialect dialect) Parameters dialect NcExpressionDialect Returns ExpressionPrefixParser TryParse(NcExpressionDialect, string, out NcExpr, out string) Full-string parse in the given dialect (the whole source must be one expression). None always fails — callers on the None path never parse. public static bool TryParse(NcExpressionDialect dialect, string source, out NcExpr expr, out string error) Parameters dialect NcExpressionDialect source string expr NcExpr error string Returns bool TryParsePrefix(NcExpressionDialect, string, out int) Longest-valid-prefix parse for parser-delimited RHS capture. Only dialects that support prefix parsing return true; the Fanuc dialect keeps its lexical capture (no known ambiguity to fix) and reports false so callers use their legacy boundary. public static bool TryParsePrefix(NcExpressionDialect dialect, string source, out int consumedLength) Parameters dialect NcExpressionDialect source string consumedLength int Returns bool VariableRefRegex(NcExpressionDialect) Regex matching this dialect's variable-reference tokens inside a raw RHS string. Used only for best-effort same-block forward-reference detection (VariableEvaluator–SameBlockForwardReference); expression evaluation itself goes through the dialect parser. The Siemens pattern covers R-parameters only — named/$ same-block forward references are vanishingly rare in CAM output and go unwarned. public static Regex VariableRefRegex(NcExpressionDialect dialect) Parameters dialect NcExpressionDialect Returns Regex"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcExpressionEvaluator.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcExpressionEvaluator.html",
    "title": "Class NcExpressionEvaluator | HiAPI-C# 2025",
    "summary": "Class NcExpressionEvaluator Namespace Hi.NcParsers.EvaluationSyntaxs.Evaluation Assembly HiMech.dll Walks an NcExpr AST and produces an EvalResult. Resolves #nnn via an IVariableLookup; built-in function names are matched case-insensitively against a fixed table. Phase-1 supports: SIN COS TAN ASIN ACOS ATAN SQRT ABS ROUND FIX FUP LN EXP POW. Trigonometric arguments and results are in degrees, matching Fanuc Custom Macro B convention. Unknown function names surface as UnsupportedFunctionCode; arity mismatches as ArgumentMismatchCode; division / MOD by zero and domain errors (e.g. SQRT[-1]) as MathErrorCode; vacant operands as VacantErrorCode. Numeric domain & type conventions. All values are IEEE 754 double — there is no separate bool / int type at runtime. Comparison ops (EQ NE GT GE LT LE) yield 1.0 (true) or 0.0 (false), using strict double equality / ordering (NaN compares as IEEE specifies — NaN EQ NaN is 0.0). Logical ops (AND OR XOR) truncate each operand to a 64-bit signed integer (Truncate(double) then cast to long) before applying the bitwise operation; non-finite or out-of-range operands surface MathErrorCode rather than silently wrapping. Truthiness at caller-side IF / WHILE gates is value != 0 — any non-zero value (bit, float, comparator result) is true. public sealed class NcExpressionEvaluator Inheritance object NcExpressionEvaluator Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields ArgumentMismatchCode Diagnostic code for built-in functions called with the wrong number of arguments. public const string ArgumentMismatchCode = \"BuiltinFunction--ArgumentMismatch\" Field Value string MathErrorCode Diagnostic code for division / MOD by zero and domain errors. public const string MathErrorCode = \"Arithmetic--MathError\" Field Value string UnsupportedFunctionCode Diagnostic code for unrecognised built-in function names. public const string UnsupportedFunctionCode = \"BuiltinFunction--Unsupported\" Field Value string VacantErrorCode Diagnostic code emitted when an evaluated #nnn is vacant. public const string VacantErrorCode = \"Variable--Vacant\" Field Value string Methods Evaluate(NcExpr, IVariableLookup) Evaluates expr against variables. public EvalResult Evaluate(NcExpr expr, IVariableLookup variables) Parameters expr NcExpr variables IVariableLookup Returns EvalResult"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcExpressionParser.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcExpressionParser.html",
    "title": "Class NcExpressionParser | HiAPI-C# 2025",
    "summary": "Class NcExpressionParser Namespace Hi.NcParsers.EvaluationSyntaxs.Evaluation Assembly HiMech.dll Recursive-descent parser for Fanuc Custom Macro B value expressions. Pure: takes a string, produces an NcExpr AST. Performs no variable lookup and no evaluation. Grammar (lowest precedence at top): expr := or-expr or-expr := and-expr (('OR' | 'XOR') and-expr)* and-expr := cmp-expr ('AND' cmp-expr)* cmp-expr := add-expr (('EQ' | 'NE' | 'GT' | 'GE' | 'LT' | 'LE') add-expr)* add-expr := term (('+' | '-') term)* term := factor (('*' | '/' | 'MOD') factor)* factor := ('+' | '-')? primary primary := number | '#' integer | '#' '[' expr ']' | '[' expr ']' | ident '[' arglist ']' ('/' '[' expr ']')? arglist := expr (',' expr)* Function names and keyword operators (MOD, EQ NE GT GE LT LE, AND OR XOR) are case-insensitive (SIN = sin, EQ = eq); each keyword requires a non-identifier character on its right boundary so EQ1 is not the EQ operator followed by 1. Whitespace is skipped between tokens. The '/' '[' expr ']' tail captures the dual-bracket form Fanuc uses for ATAN[a]/[b]; non-ATAN callers that happen to use it produce a function with an extra arg, which the evaluator rejects with an arity error. Operator precedence intentionally puts boolean / logical layers below arithmetic so #1 + 1 GT 0 parses as (#1 + 1) GT 0 and #1 GT 0 AND #2 LT 10 parses as (#1 GT 0) AND (#2 LT 10), matching the Fanuc Custom Macro B spec for IF [..] GOTO / IF [..] THEN / WHILE [..] DO conditions. public sealed class NcExpressionParser Inheritance object NcExpressionParser Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods TryParse(string, out NcExpr, out string) Parses source. On success, expr is the AST and error is null. On failure, expr is null and error describes the syntax problem. public static bool TryParse(string source, out NcExpr expr, out string error) Parameters source string expr NcExpr error string Returns bool"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcFunctionExpr.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcFunctionExpr.html",
    "title": "Class NcFunctionExpr | HiAPI-C# 2025",
    "summary": "Class NcFunctionExpr Namespace Hi.NcParsers.EvaluationSyntaxs.Evaluation Assembly HiMech.dll Built-in function call like SIN[x], SQRT[x], ATAN[a]/[b]. public sealed record NcFunctionExpr : NcExpr, IEquatable<NcExpr>, IEquatable<NcFunctionExpr> Inheritance object NcExpr NcFunctionExpr Implements IEquatable<NcExpr> IEquatable<NcFunctionExpr> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NcFunctionExpr(string, IReadOnlyList<NcExpr>) Built-in function call like SIN[x], SQRT[x], ATAN[a]/[b]. public NcFunctionExpr(string Name, IReadOnlyList<NcExpr> Args) Parameters Name string Args IReadOnlyList<NcExpr> Properties Args public IReadOnlyList<NcExpr> Args { get; init; } Property Value IReadOnlyList<NcExpr> Name public string Name { get; init; } Property Value string"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcIndirectVariableExpr.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcIndirectVariableExpr.html",
    "title": "Class NcIndirectVariableExpr | HiAPI-C# 2025",
    "summary": "Class NcIndirectVariableExpr Namespace Hi.NcParsers.EvaluationSyntaxs.Evaluation Assembly HiMech.dll Indirect variable reference #[expr]. The inner expression is evaluated and truncated toward zero to obtain an integer; the lookup key is then Prefix concatenated with that integer (e.g. Prefix=\"#\", computed 124 → \"#124\"). public sealed record NcIndirectVariableExpr : NcExpr, IEquatable<NcExpr>, IEquatable<NcIndirectVariableExpr> Inheritance object NcExpr NcIndirectVariableExpr Implements IEquatable<NcExpr> IEquatable<NcIndirectVariableExpr> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NcIndirectVariableExpr(string, NcExpr) Indirect variable reference #[expr]. The inner expression is evaluated and truncated toward zero to obtain an integer; the lookup key is then Prefix concatenated with that integer (e.g. Prefix=\"#\", computed 124 → \"#124\"). public NcIndirectVariableExpr(string Prefix, NcExpr Index) Parameters Prefix string Index NcExpr Properties Index public NcExpr Index { get; init; } Property Value NcExpr Prefix public string Prefix { get; init; } Property Value string"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcLiteralExpr.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcLiteralExpr.html",
    "title": "Class NcLiteralExpr | HiAPI-C# 2025",
    "summary": "Class NcLiteralExpr Namespace Hi.NcParsers.EvaluationSyntaxs.Evaluation Assembly HiMech.dll Numeric literal (e.g. 1.5, 15., .5, 1e-3). public sealed record NcLiteralExpr : NcExpr, IEquatable<NcExpr>, IEquatable<NcLiteralExpr> Inheritance object NcExpr NcLiteralExpr Implements IEquatable<NcExpr> IEquatable<NcLiteralExpr> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NcLiteralExpr(double) Numeric literal (e.g. 1.5, 15., .5, 1e-3). public NcLiteralExpr(double Value) Parameters Value double Properties Value public double Value { get; init; } Property Value double"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcUnaryExpr.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcUnaryExpr.html",
    "title": "Class NcUnaryExpr | HiAPI-C# 2025",
    "summary": "Class NcUnaryExpr Namespace Hi.NcParsers.EvaluationSyntaxs.Evaluation Assembly HiMech.dll Unary + or - applied to an operand. public sealed record NcUnaryExpr : NcExpr, IEquatable<NcExpr>, IEquatable<NcUnaryExpr> Inheritance object NcExpr NcUnaryExpr Implements IEquatable<NcExpr> IEquatable<NcUnaryExpr> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NcUnaryExpr(NcUnaryOp, NcExpr) Unary + or - applied to an operand. public NcUnaryExpr(NcUnaryOp Op, NcExpr Operand) Parameters Op NcUnaryOp Operand NcExpr Properties Op public NcUnaryOp Op { get; init; } Property Value NcUnaryOp Operand public NcExpr Operand { get; init; } Property Value NcExpr"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcUnaryOp.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcUnaryOp.html",
    "title": "Enum NcUnaryOp | HiAPI-C# 2025",
    "summary": "Enum NcUnaryOp Namespace Hi.NcParsers.EvaluationSyntaxs.Evaluation Assembly HiMech.dll Unary operators allowed in Fanuc Custom Macro B value expressions. public enum NcUnaryOp Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Minus = 1 Negation: -expr. Plus = 0 Identity: +expr."
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcVariableExpr.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.NcVariableExpr.html",
    "title": "Class NcVariableExpr | HiAPI-C# 2025",
    "summary": "Class NcVariableExpr Namespace Hi.NcParsers.EvaluationSyntaxs.Evaluation Assembly HiMech.dll Direct variable reference; Key is the raw source token (e.g. \"#124\") passed verbatim to Get(string). public sealed record NcVariableExpr : NcExpr, IEquatable<NcExpr>, IEquatable<NcVariableExpr> Inheritance object NcExpr NcVariableExpr Implements IEquatable<NcExpr> IEquatable<NcVariableExpr> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NcVariableExpr(string) Direct variable reference; Key is the raw source token (e.g. \"#124\") passed verbatim to Get(string). public NcVariableExpr(string Key) Parameters Key string Properties Key public string Key { get; init; } Property Value string"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.VolatileVariableLookup.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.VolatileVariableLookup.html",
    "title": "Class VolatileVariableLookup | HiAPI-C# 2025",
    "summary": "Class VolatileVariableLookup Namespace Hi.NcParsers.EvaluationSyntaxs.Evaluation Assembly HiMech.dll Reads Fanuc-style non-retained common variables (#100-#499) from Vars.Volatile. Self-gates the id range so the evaluator's RuntimeVariableLookups chain can fall through to the next lookup for out-of-range keys. Single-step lookup: VolatileVariableReadingSyntax already dict-merges every block's Vars.Volatile into the next block, so the entry — if it exists — must be on the current block (when this lookup runs after the reader) or on the immediately previous block (when this lookup runs before the reader on the same block, which is the Fanuc preset's order — evaluator first, reader second). No arbitrary walk-back: such a walk would be defensive overkill given the reader's carry guarantee. Stateless and dependency-free — instances are interchangeable. Reads stay decoupled from the reader (read side here; write side in the reader). public class VolatileVariableLookup : IRuntimeVariableLookup, IMakeXmlSource Inheritance object VolatileVariableLookup Implements IRuntimeVariableLookup IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors VolatileVariableLookup() Default constructor. public VolatileVariableLookup() VolatileVariableLookup(XElement) Loads from an XML element produced by MakeXmlSource(string, string, bool). Stateless — no fields to deserialise. public VolatileVariableLookup(XElement src) Parameters src XElement Properties XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Get(string, LazyLinkedListNode<SyntaxPiece>, IReadOnlyList<INcDependency>) Returns the value of the variable identified by key in the context of node and dependencies, or null if the key is outside this lookup's range or the value is vacant. public double? Get(string key, LazyLinkedListNode<SyntaxPiece> node, IReadOnlyList<INcDependency> dependencies) Parameters key string node LazyLinkedListNode<SyntaxPiece> dependencies IReadOnlyList<INcDependency> Returns double? MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Evaluation.html",
    "title": "Namespace Hi.NcParsers.EvaluationSyntaxs.Evaluation | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.EvaluationSyntaxs.Evaluation Classes LocalVariableLookup Reads Fanuc-style local macro variables (#1-#33) from Vars.Local on the current SyntaxPiece JSON, falling back to the immediately previous block when they share the same MacroFrame id. Self-gates the id range so the evaluator's RuntimeVariableLookups chain can fall through to the next lookup for out-of-range keys. Two-step lookup (mirrors VolatileVariableLookup): the current block sees writes that FanucMacroCallSyntax stamped at inline time (the call-line argument bindings) and writes that FanucLocalVariableReadingSyntax applied on this block before the lookup runs; the previous block (frame-checked) supplies body-internal writes from the prior block in the same macro frame. Looking past the previous block is unnecessary because the reader carries forward block-by-block within a frame. Frame isolation via MacroFrame: a previous block whose frame id differs from the current block's is skipped — a macro body's body-internal locals are invisible to the caller after return, and the caller's main-frame locals are invisible inside the macro. M98/M198 subprogram inlining (SubProgramCallSyntax) deliberately does not stamp MacroFrame on its inlined blocks, so the callee inherits the caller's frame and sees the caller's locals — matching real Fanuc M98 semantics. Stateless and dependency-free — instances are interchangeable. NcBinaryExpr Binary operation on two operands. Covers arithmetic (+ - * / / MOD), comparison (EQ NE GT GE LT LE, yielding 1.0 / 0.0), and logical bitwise (AND OR XOR, operands truncated to long). NcExpr AST root for a Fanuc Custom Macro B value expression. Concrete leaves and combinators sit alongside NcExpressionParser; walking is the job of NcExpressionEvaluator. NcExpressionDialectUtil Dispatch helpers over NcExpressionDialect so shared syntaxes (VariableEvaluatorSyntax, the assignment/tag capture syntaxes) stay brand-agnostic: they hold a dialect value and route through here instead of hard-coding a parser type. NcExpressionEvaluator Walks an NcExpr AST and produces an EvalResult. Resolves #nnn via an IVariableLookup; built-in function names are matched case-insensitively against a fixed table. Phase-1 supports: SIN COS TAN ASIN ACOS ATAN SQRT ABS ROUND FIX FUP LN EXP POW. Trigonometric arguments and results are in degrees, matching Fanuc Custom Macro B convention. Unknown function names surface as UnsupportedFunctionCode; arity mismatches as ArgumentMismatchCode; division / MOD by zero and domain errors (e.g. SQRT[-1]) as MathErrorCode; vacant operands as VacantErrorCode. Numeric domain & type conventions. All values are IEEE 754 double — there is no separate bool / int type at runtime. Comparison ops (EQ NE GT GE LT LE) yield 1.0 (true) or 0.0 (false), using strict double equality / ordering (NaN compares as IEEE specifies — NaN EQ NaN is 0.0). Logical ops (AND OR XOR) truncate each operand to a 64-bit signed integer (Truncate(double) then cast to long) before applying the bitwise operation; non-finite or out-of-range operands surface MathErrorCode rather than silently wrapping. Truthiness at caller-side IF / WHILE gates is value != 0 — any non-zero value (bit, float, comparator result) is true. NcExpressionParser Recursive-descent parser for Fanuc Custom Macro B value expressions. Pure: takes a string, produces an NcExpr AST. Performs no variable lookup and no evaluation. Grammar (lowest precedence at top): expr := or-expr or-expr := and-expr (('OR' | 'XOR') and-expr)* and-expr := cmp-expr ('AND' cmp-expr)* cmp-expr := add-expr (('EQ' | 'NE' | 'GT' | 'GE' | 'LT' | 'LE') add-expr)* add-expr := term (('+' | '-') term)* term := factor (('*' | '/' | 'MOD') factor)* factor := ('+' | '-')? primary primary := number | '#' integer | '#' '[' expr ']' | '[' expr ']' | ident '[' arglist ']' ('/' '[' expr ']')? arglist := expr (',' expr)* Function names and keyword operators (MOD, EQ NE GT GE LT LE, AND OR XOR) are case-insensitive (SIN = sin, EQ = eq); each keyword requires a non-identifier character on its right boundary so EQ1 is not the EQ operator followed by 1. Whitespace is skipped between tokens. The '/' '[' expr ']' tail captures the dual-bracket form Fanuc uses for ATAN[a]/[b]; non-ATAN callers that happen to use it produce a function with an extra arg, which the evaluator rejects with an arity error. Operator precedence intentionally puts boolean / logical layers below arithmetic so #1 + 1 GT 0 parses as (#1 + 1) GT 0 and #1 GT 0 AND #2 LT 10 parses as (#1 GT 0) AND (#2 LT 10), matching the Fanuc Custom Macro B spec for IF [..] GOTO / IF [..] THEN / WHILE [..] DO conditions. NcFunctionExpr Built-in function call like SIN[x], SQRT[x], ATAN[a]/[b]. NcIndirectVariableExpr Indirect variable reference #[expr]. The inner expression is evaluated and truncated toward zero to obtain an integer; the lookup key is then Prefix concatenated with that integer (e.g. Prefix=\"#\", computed 124 → \"#124\"). NcLiteralExpr Numeric literal (e.g. 1.5, 15., .5, 1e-3). NcUnaryExpr Unary + or - applied to an operand. NcVariableExpr Direct variable reference; Key is the raw source token (e.g. \"#124\") passed verbatim to Get(string). VolatileVariableLookup Reads Fanuc-style non-retained common variables (#100-#499) from Vars.Volatile. Self-gates the id range so the evaluator's RuntimeVariableLookups chain can fall through to the next lookup for out-of-range keys. Single-step lookup: VolatileVariableReadingSyntax already dict-merges every block's Vars.Volatile into the next block, so the entry — if it exists — must be on the current block (when this lookup runs after the reader) or on the immediately previous block (when this lookup runs before the reader on the same block, which is the Fanuc preset's order — evaluator first, reader second). No arbitrary walk-back: such a walk would be defensive overkill given the reader's carry guarantee. Stateless and dependency-free — instances are interchangeable. Reads stay decoupled from the reader (read side here; write side in the reader). Structs EvalResult Outcome of evaluating an NcExpr. Either a successful numeric value, or a failure with an error code matching the diagnostic catalogue used by reading / evaluator syntaxes. Interfaces IRuntimeVariableLookup Stateless variable lookup that needs per-block runtime context — the current SyntaxPiece node (for Previous traceback into runtime-state sections like MachineCoordinateState / ProgramXyz) and the dependency list (so the lookup can read from sibling dependencies without holding a static reference). Distinguished from IVariableLookup: that one is for long-lived dependencies that already hold their own data (parameter tables, tool-offset wrappers, retained-variable tables) and need no block context. IRuntimeVariableLookup is for context-sensitive resolutions configured declaratively on RuntimeVariableLookups. Implementations should be brand-specific (e.g. Fanuc #5001-#5043 position reads) and return null for keys outside their range so the evaluator's chain can fall through to the next lookup. Implementations are XML-serialised as part of VariableEvaluatorSyntax's round-trip: each impl exposes a static XName, registers itself with Generators, and implements MakeXmlSource(string, string, bool). Since impls are stateless, the typical body is just an empty element carrying the type name; brand identity is restored by XFactory dispatch. IVariableLookup Resolves a Custom Macro B variable reference to its current numeric value, or null for vacant (Fanuc <vacant>) and out-of-scope alike. The key is the raw source token — Fanuc \"#124\", Heidenhain \"Q1\", Siemens \"R1\" — so the interface itself is brand-agnostic. Implementations are typically narrow (one per id range / per brand prefix) and parse the prefix locally; chain them at the call site by trying each in priority order until one returns a non-null value. A returned null is treated by NcExpressionEvaluator as vacant and surfaces as a Variable--Vacant failure when the value is consumed in arithmetic context. Enums NcBinaryOp Binary operators allowed in Fanuc Custom Macro B value expressions. NcExpressionDialect Selects which brand expression grammar a syntax parses value expressions with. All dialects produce the same NcExpr AST and are evaluated by the shared NcExpressionEvaluator — the dialect only decides tokenization/grammar (Fanuc #nnn + brackets vs Siemens Rn/named/$ + parentheses). NcUnaryOp Unary operators allowed in Fanuc Custom Macro B value expressions."
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.FanucConditionReader.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.FanucConditionReader.html",
    "title": "Class FanucConditionReader | HiAPI-C# 2025",
    "summary": "Class FanucConditionReader Namespace Hi.NcParsers.EvaluationSyntaxs.Fanuc Assembly HiMech.dll Shared polymorphic reader for Fanuc Custom Macro B conditional gate expressions (IF [...] GOTO, IF [...] THEN, WHILE [...] DO m). The condition node is read post-evaluation — VariableEvaluatorSyntax's pass-2 tree walk has already substituted the original expression string with a numeric JsonValue when evaluation succeeded; this helper maps that node to a tri-state truthy outcome plus a display form for diagnostics. Three states, mapping directly to the ConditionEvaluated: true | false | null stamp shape used by all three consumers (see FanucGotoSyntax, FanucIfThenSyntax, and the WHILE-loop syntax): Truthy = true — node is a finite non-zero numeric; gate fires. Truthy = false — node is a finite numeric equal to zero; gate falls through silently. Truthy = null — node is null, still a string (evaluator failed), or non-finite double (NaN / ±∞); gate falls through and the caller emits its own <Syntax>--ConditionNotEvaluated warning. The Display form is the human-readable expression text for diagnostic messages. For resolved numerics it is the value formatted via InvariantCulture; for unresolved strings it is the original expression text. Diagnostics build their own message text — the helper just provides the source string so the caller can compose \"IF [<Display>] GOTO ...\" etc. Callers typically DeepClone() the original node before passing in here, then again before stamping back, so removing the parsing section and writing the host-level stamp can happen in any order without dangling references. public static class FanucConditionReader Inheritance object FanucConditionReader Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods ReadCondition(JsonNode) Maps a post-evaluation condition JsonNode to a display string + tri-state truthy outcome. See class XmlDoc for the three states' definitions. public static (string Display, bool? Truthy) ReadCondition(JsonNode node) Parameters node JsonNode Returns (string Display, bool? Truthy)"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.FanucGotoSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.FanucGotoSyntax.html",
    "title": "Class FanucGotoSyntax | HiAPI-C# 2025",
    "summary": "Class FanucGotoSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Fanuc Assembly HiMech.dll Resolves Fanuc Custom Macro B GOTO control flow. Triggered by Parsing.FanucGoto (written by FanucGotoParsingSyntax); decides whether to fire, and on fire calls ReplaceSource(IEnumerable<T>) on layers[0] with the re-segmented file content starting at the matching N{target} label. The host block stays materialised (so cache dumps still see the GOTO call site); execution naturally continues from the new source once the pipeline pulls the next block. Both unconditional GOTO <n> and conditional IF [<expr>] GOTO <n> are implemented. The conditional form leans on VariableEvaluatorSyntax's pass-2 tree walk to substitute Parsing.FanucGoto.Condition with a numeric JsonValue when the expression evaluates successfully — ReadCondition(JsonNode) then reads the node polymorphically. Truthy non-zero fires the redirect; zero falls through silently; a still-string (unresolved) Condition emits FanucGoto--ConditionNotEvaluated and falls through. Pipeline placement: tail of the Fanuc / Mazak / Syntec Evaluation bundle. Must run after VariableEvaluatorSyntax so any #<var> in the target N (e.g. GOTO #1) has been substituted to a literal in Parsing.FanucGoto.N. Reader syntaxes (VolatileVariableReadingSyntax etc.) are independent — they touch Parsing.Assignments, not Parsing.FanucGoto. Label scanning uses two hosted helper syntaxes — CommentSyntax and IndexSyntax — applied to each candidate block in turn so the predicate IndexNote.Number == target matches the same way the Parsing bundle would. Both are XML-IO-able so API customers can swap them (e.g. for a controller variant using ;-style comments or a different head symbol). Defaults match Fanuc: QuoteCommentSyntax and HeadIndexSyntax with the \"N\" symbol. public class FanucGotoSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object FanucGotoSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FanucGotoSyntax() Parameterless instance with default helper syntaxes. public FanucGotoSyntax() FanucGotoSyntax(XElement, string, IProgress<IMessage>) Loads hosted helper syntaxes from XML produced by MakeXmlSource(string, string, bool). The <LabelProbeSyntaxes> wrapper contains one child element per probe syntax in source order; an absent wrapper falls back to the default list. public FanucGotoSyntax(XElement src, string baseDirectory, IProgress<IMessage> progress) Parameters src XElement Root element named XName. baseDirectory string Project base directory propagated to child XFactory calls. progress IProgress<IMessage> Diagnostic sink propagated to child factories. Properties LabelProbeSyntaxes Ordered list of helper syntaxes run on each candidate block during the label scan before the IndexNote.Number == target predicate is checked. The defaults match Fanuc — QuoteCommentSyntax strips parenthesised comments so a commented-out (N100) never matches, then HeadIndexSyntax with symbol “N” extracts the head index into IndexNote.Number. Exposed as a list (rather than two fixed properties) so API customers can insert additional probe syntaxes — for example a TailCommentSyntax for ;-style end-of-block comments alongside the parenthesised form, or a BlockSkipSyntax to skip /-prefixed blocks from the label-scan results. Order matters: comment-strippers before the head-index parser, the index parser last (so its output reflects the post-strip text). public List<ISituNcSyntax> LabelProbeSyntaxes { get; set; } Property Value List<ISituNcSyntax> Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.FanucIfThenSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.FanucIfThenSyntax.html",
    "title": "Class FanucIfThenSyntax | HiAPI-C# 2025",
    "summary": "Class FanucIfThenSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Fanuc Assembly HiMech.dll Resolves Fanuc Custom Macro B IF [<cond>] THEN <body> single-block conditionals. Triggered by Parsing.FanucIfThen (written by FanucIfThenParsingSyntax); reads the now-resolved Condition node, decides whether to fire, and on fire lifts the parsing-stage PendingAssignments sub-object into the canonical Parsing.Assignments bucket so the brand-specific reader syntaxes downstream route each entry to its store the same way they would handle an unconditional #nnn = <literal> on a normal block. Unlike FanucGotoSyntax there is no source splice, no label scan, no iteration watchdog — the spec restricts the body to the current block. The host block is preserved either way (the stamped FanucIfThen section on the host's top-level JSON keeps the IF-THEN call site visible to cache dumps and diagnostics, with Applied flipped true only on a successful fire). Pipeline placement: in the Evaluation bundle after VariableEvaluatorSyntax (so the Condition expression has been substituted in place by pass-2 tree walk, and each PendingAssignments RHS string has been evaluated to a numeric JsonValue) and before the reader syntaxes (VolatileVariableReadingSyntax, RetainedCommonVariableReadingSyntax, FanucLocalVariableReadingSyntax, FanucSystemControlVariableSyntax) — that ordering lets the lifted entries reach the readers as if they had been written by TagAssignmentSyntax on a normal block. Three condition outcomes mirror the FanucGotoSyntax.ReadCondition shape: Truthy non-zero → lift assignments, stamp Applied=true. Truthy zero → fall through silently, Applied=false. Truthy null (evaluator failed, condition still a string or non-finite) → warn FanucIfThen--ConditionNotEvaluated, do not lift, Applied=false. A truthy condition with no PendingAssignments (body did not parse as one or more assignments — e.g. a G-code body, currently unsupported) warns FanucIfThen--UnsupportedBody and falls through. public class FanucIfThenSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object FanucIfThenSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FanucIfThenSyntax() Parameterless instance (no XML state). public FanucIfThenSyntax() FanucIfThenSyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public FanucIfThenSyntax(XElement src) Parameters src XElement Root element named XName. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.FanucLocalVariableReadingSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.FanucLocalVariableReadingSyntax.html",
    "title": "Class FanucLocalVariableReadingSyntax | HiAPI-C# 2025",
    "summary": "Class FanucLocalVariableReadingSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Fanuc Assembly HiMech.dll Routes literal-RHS assignments to Fanuc-style local macro variables (#1-#33) from Parsing.Assignments into Vars.Local on the current block, carrying the previous block's Vars.Local dict forward when both blocks share the same MacroFrame id. Mirrors VolatileVariableReadingSyntax for the #100-#499 range, with two differences: Carry is gated by MacroFrame equality, so a caller block after a G65 return does not inherit the macro body's final locals. Writes outside a macro frame (a main-program block doing #11 = 5) emit LocalVariable--MainFrameWriteUnsupported and consume the assignment without persisting — real Fanuc allows main-frame local writes but this simulator only tracks locals inside G65/G66 call frames; surfacing the gap as a diagnostic is more informative than a silent UnconsumedCheckSyntax hit. Pipeline placement: Evaluation bundle, after VariableEvaluatorSyntax (so any expression RHS such as #11 = #1 + 1 has already been normalised to a literal by the time this reader runs) and after the other range readers (RetainedCommonVariableReadingSyntax, VolatileVariableReadingSyntax) so they all share a similar Reader-stage shape. Only literal numeric RHS values are consumed here; non-literal entries (which can only persist if VariableEvaluatorSyntax failed to resolve them) are left untouched and surface via the evaluator's own VariableExpression--Unevaluated diagnostic plus UnconsumedCheckSyntax. public class FanucLocalVariableReadingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object FanucLocalVariableReadingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FanucLocalVariableReadingSyntax() Default constructor. public FanucLocalVariableReadingSyntax() FanucLocalVariableReadingSyntax(XElement) Loads from XML produced by MakeXmlSource(string, string, bool); no state. public FanucLocalVariableReadingSyntax(XElement src) Parameters src XElement Fields LocalMax Inclusive upper bound of the local range (#33). public const int LocalMax = 33 Field Value int LocalMin Inclusive lower bound of the local range (#1). public const int LocalMin = 1 Field Value int Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.FanucMacroArgumentMap.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.FanucMacroArgumentMap.html",
    "title": "Class FanucMacroArgumentMap | HiAPI-C# 2025",
    "summary": "Class FanucMacroArgumentMap Namespace Hi.NcParsers.EvaluationSyntaxs.Fanuc Assembly HiMech.dll Fanuc Custom Macro B Type-I argument-letter map: which call-line letter binds to which Vars.Local id (#1-#26) inside the macro body. Reserved letters (G, L, N, O, P) are absent — they are consumed by the call itself, not passed through. Used by FanucMacroCallSyntax (G65, one-shot) and FanucModalMacroSyntax (G66, modal) to translate the argument letters captured by G65Syntax / G66Syntax into the #nnn bindings the macro body's expression evaluator can read. public static class FanucMacroArgumentMap Inheritance object FanucMacroArgumentMap Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields Map Fanuc Custom Macro B Type-I letter-to-local-id map. Single-value per letter; Type-II's repeating I_J_K_ array binding is not modelled here. public static readonly IReadOnlyDictionary<string, int> Map Field Value IReadOnlyDictionary<string, int>"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.FanucMacroCallSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.FanucMacroCallSyntax.html",
    "title": "Class FanucMacroCallSyntax | HiAPI-C# 2025",
    "summary": "Class FanucMacroCallSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Fanuc Assembly HiMech.dll Inlines a Fanuc Custom Macro B one-shot call (G65 P_ L_ [letter value …]) into the source layer and binds the call-line argument letters to Vars.Local #1-#26 per the Type-I map (see FanucMacroArgumentMap). Every inlined block carries the binding dict, a clone of the FanucMacroCall diagnostic record, and a MacroFrame id stamp — so LocalVariableLookup resolves arg references in a single-block lookup, a cache dump landing on any block immediately shows which call it belongs to, and downstream FanucLocalVariableReadingSyntax carries body-internal #1-#33 writes forward only within the same frame. The host block itself records FanucMacroCall but stays in the caller's frame (no MacroFrame stamp) and emits no motion act; after the macro body's last inlined block the pipeline continues naturally into the caller's next block (the inlined pieces sit ahead of the host block's successor in layers[0]). Frame isolation works on two layers. Statically, caller blocks have no MacroFrame stamp (frame id 0 by Get(JsonObject)), so the inlined frame ids (allocated fresh per L-repetition) never collide with main. Dynamically, LocalVariableLookup and FanucLocalVariableReadingSyntax compare frame ids before carrying any Vars.Local entry across a block boundary — a macro body's body-internal writes therefore stay inside the macro and never leak back into the caller's frame. Filename lookup mirrors SubProgramCallSyntax: O{P:D4}.NC, O{P}.NC, O{P:D4}, O{P}, {P:D4}.NC, {P}.NC — first match wins. The lookup root is InternalFolder (G65 has no \"external storage\" variant; M198's external root is M98/M198-only). L > 1 inlines the same macro L times in series. Each repetition is a fresh segmentation pass (so each block gets its own SyntaxPiece JSON object — the downstream pipeline mutates JSON in place and would clobber sibling repetitions if instances were shared) and gets a fresh FileIndex (so (FileIndex, LineIndex) pairs stay unique across the L-copies of the same source lines). Pipeline placement: ahead of SubProgramCallSyntax inside the Fanuc Evaluation BundleSyntax so a hypothetical G65 P_ + M98 P_ on the same block expands the G65 macro first (would be an unusual but legal composition). Detection is on the Parsing.G65 sub-object written by G65Syntax (a ParameterizedFlagSyntax) — the keyword \"G65\" never reaches Parsing.Flags because the parameterized match has already consumed the text by the time NumberedFlagSyntax runs. public class FanucMacroCallSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object FanucMacroCallSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FanucMacroCallSyntax() Parameterless instance for bundle composition (no XML state). public FanucMacroCallSyntax() FanucMacroCallSyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public FanucMacroCallSyntax(XElement src) Parameters src XElement Root element named XName. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.FanucModalMacroSyntax.SyntaxPhase.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.FanucModalMacroSyntax.SyntaxPhase.html",
    "title": "Enum FanucModalMacroSyntax.SyntaxPhase | HiAPI-C# 2025",
    "summary": "Enum FanucModalMacroSyntax.SyntaxPhase Namespace Hi.NcParsers.EvaluationSyntaxs.Fanuc Assembly HiMech.dll Identifies which pipeline phase the instance runs in. The two values correspond to the Evaluation-bundle and PostLogic-bundle registrations of this same syntax class. public enum FanucModalMacroSyntax.SyntaxPhase Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Expansion = 1 PostLogic phase: on every motion-producing block (signalled by MotionEvent presence) that sits inside an active G66 modal AND lives in the main frame (MacroFrame == 0), inlines the modal macro body — same call mechanism as FanucMacroCallSyntax. Setup = 0 Evaluation phase: captures G66 setup / G67 cancel edges into FanucModalMacro and carries the section forward block-to-block."
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.FanucModalMacroSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.FanucModalMacroSyntax.html",
    "title": "Class FanucModalMacroSyntax | HiAPI-C# 2025",
    "summary": "Class FanucModalMacroSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Fanuc Assembly HiMech.dll Handles Fanuc Custom Macro B modal-call lifecycle (G66 setup, G67 cancel, and per-motion-block implicit macro invocation). The same class is registered twice in the pipeline via Phase — once in the Evaluation bundle (Setup, captures G66/G67 edges and carries the FanucModalMacro state block-to-block) and once in the PostLogic bundle (Expansion, on every motion block within an active G66 modal, inlines the macro body via the same mechanism FanucMacroCallSyntax uses). Keeping both phases in one class makes the pairing visually explicit: readers see \"G66 in one file\" and the two methods (DoSetup, DoExpansion) make the lifecycle obvious. The two factory helpers (Setup, Expansion) mirror the ModalCarrySyntax.Logic / .PostLogic pattern already in the codebase. public class FanucModalMacroSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object FanucModalMacroSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FanucModalMacroSyntax() Parameterless instance (defaults to Setup). public FanucModalMacroSyntax() FanucModalMacroSyntax(XElement) XML ctor. Reads <Phase> child element; legacy project files without it default to Setup (the pre-expansion behaviour). public FanucModalMacroSyntax(XElement src) Parameters src XElement Root element named XName. Properties Expansion Factory: PostLogic-bundle instance that performs implicit motion-block expansion. public static FanucModalMacroSyntax Expansion { get; } Property Value FanucModalMacroSyntax Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string Phase Pipeline phase this instance runs in. Defaults to Setup. public FanucModalMacroSyntax.SyntaxPhase Phase { get; set; } Property Value FanucModalMacroSyntax.SyntaxPhase Setup Factory: Evaluation-bundle instance that handles G66/G67 setup + carry. public static FanucModalMacroSyntax Setup { get; } Property Value FanucModalMacroSyntax XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.FanucSystemControlVariableSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.FanucSystemControlVariableSyntax.html",
    "title": "Class FanucSystemControlVariableSyntax | HiAPI-C# 2025",
    "summary": "Class FanucSystemControlVariableSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Fanuc Assembly HiMech.dll Consumes Fanuc-style system-control variable assignments (#3000-#3999) — alarm trigger (#3000), millisecond and hour clocks (#3001 / #3002), single-block / feed-hold bypass flags (#3003 / #3004), pause-with-message (#3006), mirror-image flags (#3007), date / time (#3011 / #3012), tool-life data (#3030 / #3032), etc. Every id in this range is a controller-side state variable — its authoritative value lives on the real hardware (RTC, alarm bus, override switches, …) and an NC write at most triggers a side effect (clock reset, alarm raise, message-pause prompt). Offline simulation has none of that machinery, so this syntax does not emulate the effect. Instead it: records the literal write on the block JSON under Vars.SystemControl (round-trip and cache-dump visibility); emits a FanucSystemControl--Unsupported UnsupportedMessage(ISentenceCarrier, string, string, object) so the user knows the assignment was recognised but its controller-side effect is not simulated. Message-severity (not Warning) because these writes are safe no-ops offline — every consumed assignment would emit a Warning per block, which would be noisy without signalling anything the user must act on; removes the entry from Parsing.Assignments so it does not re-surface as a generic Parsing--Unconsumed diagnostic. The dictionary carries forward block-by-block (same dict-merge pattern as VolatileVariableReadingSyntax) so a downstream consumer can read the most recent recorded value via SyntaxPiece linkage. Only literal numeric RHS values are consumed; non-literal RHS (e.g. #3002 = #500) is left in Parsing.Assignments for VariableEvaluatorSyntax to resolve, mirroring the retained / volatile reading syntaxes. Fanuc-family only — Siemens uses named system variables ($AC_TIME, $A_DAY, …) and Heidenhain uses FN18: SYSREAD; neither flows through Parsing.Assignments.#nnn. public class FanucSystemControlVariableSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object FanucSystemControlVariableSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FanucSystemControlVariableSyntax() Default constructor. public FanucSystemControlVariableSyntax() FanucSystemControlVariableSyntax(XElement) Loads from an XML element produced by MakeXmlSource(string, string, bool). No state to deserialise. public FanucSystemControlVariableSyntax(XElement src) Parameters src XElement Fields SystemControlMax Inclusive upper bound of the system-control range (#3999). public const int SystemControlMax = 3999 Field Value int SystemControlMin Inclusive lower bound of the system-control range (#3000). public const int SystemControlMin = 3000 Field Value int UnsupportedDiagId Diagnostic id emitted for every consumed #3000-#3999 assignment — recognised by the parser, ignored by simulation. public const string UnsupportedDiagId = \"FanucSystemControl--Unsupported\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.FanucWhileDoSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.FanucWhileDoSyntax.html",
    "title": "Class FanucWhileDoSyntax | HiAPI-C# 2025",
    "summary": "Class FanucWhileDoSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Fanuc Assembly HiMech.dll Resolves Fanuc Custom Macro B WHILE [..] DO m ... END m bounded loops. Two phrases dispatched by Term: WHILE [..] DO m — entry: reads the resolved condition via FanucConditionReader, manages the per-LoopId frame in the top-level WhileFrames dict, and either falls through (truthy) or forward-jumps past the matching END m (falsy / unresolved). END m — terminator: unconditionally reverse-jumps to the WHILE block recorded in WhileFrames[LoopId].BeginLineNo so the next iteration re-evaluates the entry condition. Increments the per-loop iteration counter on FanucWhileDoIterationDependency; suppresses the redirect above MaxIterationsPerLoopId. WhileFrames carrier. The top-level WhileFrames JSON section is a JsonObject keyed by LoopId-as-string whose values are { BeginLineNo: int }. Frames are pushed when a WHILE block first encounters a truthy condition with no existing frame for that LoopId; popped when the condition becomes falsy or unresolved; otherwise carried forward unchanged by ModalCarrySyntax's Logic tracked-key list. Nested loops with distinct LoopIds coexist in the same dict; same-LoopId nesting (spec-undefined) overwrites and is not given special handling. Pipeline placement. Evaluation bundle, after the variable readers (defensive — WHILE/END blocks per spec do not carry assignments, but the placement is consistent with GOTO). Must run after VariableEvaluatorSyntax so the condition string has been substituted to numeric. Forward scan to matching END m uses the anchored LabelScanUtil overload with ForwardFromAnchor from the WHILE host line — sequential loops reuse LoopIds, so only candidates below the host line may match. The probe runs the brand-default FanucWhileDoParsingSyntax on each candidate, predicate matches on Parsing.FanucWhileDo.Term == \"END\" && LoopId == target. Reverse scan to WHILE BeginLineNo does not need a label predicate — the BeginLineNo is a known file-line index recorded in the active frame, so the END side re-segments the file from the top and returns the slice starting at the first piece whose CharIndexSegment.Begin.LineIndex matches. public class FanucWhileDoSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object FanucWhileDoSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks Worked Example — Three-iteration WHILE [..] DO m ... END m Given this Custom Macro B source: #100 = 0 WHILE [#100 LT 3] DO 1 #100 = #100 + 1 END 1 X5 Each block flows through the runtime as below. The WhileFrames lifeline represents the per-block active-loop state carried block-to-block by the modal-carry pipeline; the END block consults it to find the WHILE line to reverse-jump to. The runaway-loop counter ticks on every successful END reverse-jump and suppresses further jumps above the configured iteration limit. sequenceDiagram participant W as WHILE block participant B as body participant E as END block participant X as X5 participant F as WhileFrames Note over F: empty Note over W: iter 1: cond=true (0 LT 3) W->>F: push {LoopId 1, BeginLineNo} W->>B: fall through B->>E: Note over E: counter 0 to 1 (≤Max) E-->>W: reverse jump Note over W: iter 2: cond=true (1 LT 3) Note over W,F: frame exists, skip push W->>B: fall through B->>E: Note over E: counter 1 to 2 (≤Max) E-->>W: reverse jump Note over W: iter 3: cond=true (2 LT 3) W->>B: B->>E: Note over E: counter 2 to 3 (≤Max) E-->>W: reverse jump Note over W: iter 4: cond=false (3 LT 3) W->>F: pop LoopId 1 Note over W: forward jump past END W->>X: After the loop exits, X5 executes with #100 = 3 in Vars.Volatile. Constructors FanucWhileDoSyntax() Parameterless instance. public FanucWhileDoSyntax() FanucWhileDoSyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public FanucWhileDoSyntax(XElement src) Parameters src XElement Fields BeginLineNoKey Schema field inside each WhileFrames entry: the WHILE block's file-line index. public const string BeginLineNoKey = \"BeginLineNo\" Field Value string WhileFramesKey Top-level JSON key for the active-loop frame dict. public const string WhileFramesKey = \"WhileFrames\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Fanuc.html",
    "title": "Namespace Hi.NcParsers.EvaluationSyntaxs.Fanuc | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.EvaluationSyntaxs.Fanuc Classes FanucConditionReader Shared polymorphic reader for Fanuc Custom Macro B conditional gate expressions (IF [...] GOTO, IF [...] THEN, WHILE [...] DO m). The condition node is read post-evaluation — VariableEvaluatorSyntax's pass-2 tree walk has already substituted the original expression string with a numeric JsonValue when evaluation succeeded; this helper maps that node to a tri-state truthy outcome plus a display form for diagnostics. Three states, mapping directly to the ConditionEvaluated: true | false | null stamp shape used by all three consumers (see FanucGotoSyntax, FanucIfThenSyntax, and the WHILE-loop syntax): Truthy = true — node is a finite non-zero numeric; gate fires. Truthy = false — node is a finite numeric equal to zero; gate falls through silently. Truthy = null — node is null, still a string (evaluator failed), or non-finite double (NaN / ±∞); gate falls through and the caller emits its own <Syntax>--ConditionNotEvaluated warning. The Display form is the human-readable expression text for diagnostic messages. For resolved numerics it is the value formatted via InvariantCulture; for unresolved strings it is the original expression text. Diagnostics build their own message text — the helper just provides the source string so the caller can compose \"IF [<Display>] GOTO ...\" etc. Callers typically DeepClone() the original node before passing in here, then again before stamping back, so removing the parsing section and writing the host-level stamp can happen in any order without dangling references. FanucGotoSyntax Resolves Fanuc Custom Macro B GOTO control flow. Triggered by Parsing.FanucGoto (written by FanucGotoParsingSyntax); decides whether to fire, and on fire calls ReplaceSource(IEnumerable<T>) on layers[0] with the re-segmented file content starting at the matching N{target} label. The host block stays materialised (so cache dumps still see the GOTO call site); execution naturally continues from the new source once the pipeline pulls the next block. Both unconditional GOTO <n> and conditional IF [<expr>] GOTO <n> are implemented. The conditional form leans on VariableEvaluatorSyntax's pass-2 tree walk to substitute Parsing.FanucGoto.Condition with a numeric JsonValue when the expression evaluates successfully — ReadCondition(JsonNode) then reads the node polymorphically. Truthy non-zero fires the redirect; zero falls through silently; a still-string (unresolved) Condition emits FanucGoto--ConditionNotEvaluated and falls through. Pipeline placement: tail of the Fanuc / Mazak / Syntec Evaluation bundle. Must run after VariableEvaluatorSyntax so any #<var> in the target N (e.g. GOTO #1) has been substituted to a literal in Parsing.FanucGoto.N. Reader syntaxes (VolatileVariableReadingSyntax etc.) are independent — they touch Parsing.Assignments, not Parsing.FanucGoto. Label scanning uses two hosted helper syntaxes — CommentSyntax and IndexSyntax — applied to each candidate block in turn so the predicate IndexNote.Number == target matches the same way the Parsing bundle would. Both are XML-IO-able so API customers can swap them (e.g. for a controller variant using ;-style comments or a different head symbol). Defaults match Fanuc: QuoteCommentSyntax and HeadIndexSyntax with the \"N\" symbol. FanucIfThenSyntax Resolves Fanuc Custom Macro B IF [<cond>] THEN <body> single-block conditionals. Triggered by Parsing.FanucIfThen (written by FanucIfThenParsingSyntax); reads the now-resolved Condition node, decides whether to fire, and on fire lifts the parsing-stage PendingAssignments sub-object into the canonical Parsing.Assignments bucket so the brand-specific reader syntaxes downstream route each entry to its store the same way they would handle an unconditional #nnn = <literal> on a normal block. Unlike FanucGotoSyntax there is no source splice, no label scan, no iteration watchdog — the spec restricts the body to the current block. The host block is preserved either way (the stamped FanucIfThen section on the host's top-level JSON keeps the IF-THEN call site visible to cache dumps and diagnostics, with Applied flipped true only on a successful fire). Pipeline placement: in the Evaluation bundle after VariableEvaluatorSyntax (so the Condition expression has been substituted in place by pass-2 tree walk, and each PendingAssignments RHS string has been evaluated to a numeric JsonValue) and before the reader syntaxes (VolatileVariableReadingSyntax, RetainedCommonVariableReadingSyntax, FanucLocalVariableReadingSyntax, FanucSystemControlVariableSyntax) — that ordering lets the lifted entries reach the readers as if they had been written by TagAssignmentSyntax on a normal block. Three condition outcomes mirror the FanucGotoSyntax.ReadCondition shape: Truthy non-zero → lift assignments, stamp Applied=true. Truthy zero → fall through silently, Applied=false. Truthy null (evaluator failed, condition still a string or non-finite) → warn FanucIfThen--ConditionNotEvaluated, do not lift, Applied=false. A truthy condition with no PendingAssignments (body did not parse as one or more assignments — e.g. a G-code body, currently unsupported) warns FanucIfThen--UnsupportedBody and falls through. FanucLocalVariableReadingSyntax Routes literal-RHS assignments to Fanuc-style local macro variables (#1-#33) from Parsing.Assignments into Vars.Local on the current block, carrying the previous block's Vars.Local dict forward when both blocks share the same MacroFrame id. Mirrors VolatileVariableReadingSyntax for the #100-#499 range, with two differences: Carry is gated by MacroFrame equality, so a caller block after a G65 return does not inherit the macro body's final locals. Writes outside a macro frame (a main-program block doing #11 = 5) emit LocalVariable--MainFrameWriteUnsupported and consume the assignment without persisting — real Fanuc allows main-frame local writes but this simulator only tracks locals inside G65/G66 call frames; surfacing the gap as a diagnostic is more informative than a silent UnconsumedCheckSyntax hit. Pipeline placement: Evaluation bundle, after VariableEvaluatorSyntax (so any expression RHS such as #11 = #1 + 1 has already been normalised to a literal by the time this reader runs) and after the other range readers (RetainedCommonVariableReadingSyntax, VolatileVariableReadingSyntax) so they all share a similar Reader-stage shape. Only literal numeric RHS values are consumed here; non-literal entries (which can only persist if VariableEvaluatorSyntax failed to resolve them) are left untouched and surface via the evaluator's own VariableExpression--Unevaluated diagnostic plus UnconsumedCheckSyntax. FanucMacroArgumentMap Fanuc Custom Macro B Type-I argument-letter map: which call-line letter binds to which Vars.Local id (#1-#26) inside the macro body. Reserved letters (G, L, N, O, P) are absent — they are consumed by the call itself, not passed through. Used by FanucMacroCallSyntax (G65, one-shot) and FanucModalMacroSyntax (G66, modal) to translate the argument letters captured by G65Syntax / G66Syntax into the #nnn bindings the macro body's expression evaluator can read. FanucMacroCallSyntax Inlines a Fanuc Custom Macro B one-shot call (G65 P_ L_ [letter value …]) into the source layer and binds the call-line argument letters to Vars.Local #1-#26 per the Type-I map (see FanucMacroArgumentMap). Every inlined block carries the binding dict, a clone of the FanucMacroCall diagnostic record, and a MacroFrame id stamp — so LocalVariableLookup resolves arg references in a single-block lookup, a cache dump landing on any block immediately shows which call it belongs to, and downstream FanucLocalVariableReadingSyntax carries body-internal #1-#33 writes forward only within the same frame. The host block itself records FanucMacroCall but stays in the caller's frame (no MacroFrame stamp) and emits no motion act; after the macro body's last inlined block the pipeline continues naturally into the caller's next block (the inlined pieces sit ahead of the host block's successor in layers[0]). Frame isolation works on two layers. Statically, caller blocks have no MacroFrame stamp (frame id 0 by Get(JsonObject)), so the inlined frame ids (allocated fresh per L-repetition) never collide with main. Dynamically, LocalVariableLookup and FanucLocalVariableReadingSyntax compare frame ids before carrying any Vars.Local entry across a block boundary — a macro body's body-internal writes therefore stay inside the macro and never leak back into the caller's frame. Filename lookup mirrors SubProgramCallSyntax: O{P:D4}.NC, O{P}.NC, O{P:D4}, O{P}, {P:D4}.NC, {P}.NC — first match wins. The lookup root is InternalFolder (G65 has no \"external storage\" variant; M198's external root is M98/M198-only). L > 1 inlines the same macro L times in series. Each repetition is a fresh segmentation pass (so each block gets its own SyntaxPiece JSON object — the downstream pipeline mutates JSON in place and would clobber sibling repetitions if instances were shared) and gets a fresh FileIndex (so (FileIndex, LineIndex) pairs stay unique across the L-copies of the same source lines). Pipeline placement: ahead of SubProgramCallSyntax inside the Fanuc Evaluation BundleSyntax so a hypothetical G65 P_ + M98 P_ on the same block expands the G65 macro first (would be an unusual but legal composition). Detection is on the Parsing.G65 sub-object written by G65Syntax (a ParameterizedFlagSyntax) — the keyword \"G65\" never reaches Parsing.Flags because the parameterized match has already consumed the text by the time NumberedFlagSyntax runs. FanucModalMacroSyntax Handles Fanuc Custom Macro B modal-call lifecycle (G66 setup, G67 cancel, and per-motion-block implicit macro invocation). The same class is registered twice in the pipeline via Phase — once in the Evaluation bundle (Setup, captures G66/G67 edges and carries the FanucModalMacro state block-to-block) and once in the PostLogic bundle (Expansion, on every motion block within an active G66 modal, inlines the macro body via the same mechanism FanucMacroCallSyntax uses). Keeping both phases in one class makes the pairing visually explicit: readers see \"G66 in one file\" and the two methods (DoSetup, DoExpansion) make the lifecycle obvious. The two factory helpers (Setup, Expansion) mirror the ModalCarrySyntax.Logic / .PostLogic pattern already in the codebase. FanucSystemControlVariableSyntax Consumes Fanuc-style system-control variable assignments (#3000-#3999) — alarm trigger (#3000), millisecond and hour clocks (#3001 / #3002), single-block / feed-hold bypass flags (#3003 / #3004), pause-with-message (#3006), mirror-image flags (#3007), date / time (#3011 / #3012), tool-life data (#3030 / #3032), etc. Every id in this range is a controller-side state variable — its authoritative value lives on the real hardware (RTC, alarm bus, override switches, …) and an NC write at most triggers a side effect (clock reset, alarm raise, message-pause prompt). Offline simulation has none of that machinery, so this syntax does not emulate the effect. Instead it: records the literal write on the block JSON under Vars.SystemControl (round-trip and cache-dump visibility); emits a FanucSystemControl--Unsupported UnsupportedMessage(ISentenceCarrier, string, string, object) so the user knows the assignment was recognised but its controller-side effect is not simulated. Message-severity (not Warning) because these writes are safe no-ops offline — every consumed assignment would emit a Warning per block, which would be noisy without signalling anything the user must act on; removes the entry from Parsing.Assignments so it does not re-surface as a generic Parsing--Unconsumed diagnostic. The dictionary carries forward block-by-block (same dict-merge pattern as VolatileVariableReadingSyntax) so a downstream consumer can read the most recent recorded value via SyntaxPiece linkage. Only literal numeric RHS values are consumed; non-literal RHS (e.g. #3002 = #500) is left in Parsing.Assignments for VariableEvaluatorSyntax to resolve, mirroring the retained / volatile reading syntaxes. Fanuc-family only — Siemens uses named system variables ($AC_TIME, $A_DAY, …) and Heidenhain uses FN18: SYSREAD; neither flows through Parsing.Assignments.#nnn. FanucWhileDoSyntax Resolves Fanuc Custom Macro B WHILE [..] DO m ... END m bounded loops. Two phrases dispatched by Term: WHILE [..] DO m — entry: reads the resolved condition via FanucConditionReader, manages the per-LoopId frame in the top-level WhileFrames dict, and either falls through (truthy) or forward-jumps past the matching END m (falsy / unresolved). END m — terminator: unconditionally reverse-jumps to the WHILE block recorded in WhileFrames[LoopId].BeginLineNo so the next iteration re-evaluates the entry condition. Increments the per-loop iteration counter on FanucWhileDoIterationDependency; suppresses the redirect above MaxIterationsPerLoopId. WhileFrames carrier. The top-level WhileFrames JSON section is a JsonObject keyed by LoopId-as-string whose values are { BeginLineNo: int }. Frames are pushed when a WHILE block first encounters a truthy condition with no existing frame for that LoopId; popped when the condition becomes falsy or unresolved; otherwise carried forward unchanged by ModalCarrySyntax's Logic tracked-key list. Nested loops with distinct LoopIds coexist in the same dict; same-LoopId nesting (spec-undefined) overwrites and is not given special handling. Pipeline placement. Evaluation bundle, after the variable readers (defensive — WHILE/END blocks per spec do not carry assignments, but the placement is consistent with GOTO). Must run after VariableEvaluatorSyntax so the condition string has been substituted to numeric. Forward scan to matching END m uses the anchored LabelScanUtil overload with ForwardFromAnchor from the WHILE host line — sequential loops reuse LoopIds, so only candidates below the host line may match. The probe runs the brand-default FanucWhileDoParsingSyntax on each candidate, predicate matches on Parsing.FanucWhileDo.Term == \"END\" && LoopId == target. Reverse scan to WHILE BeginLineNo does not need a label predicate — the BeginLineNo is a known file-line index recorded in the active frame, so the END side re-segments the file from the top and returns the slice starting at the first piece whose CharIndexSegment.Begin.LineIndex matches. Enums FanucModalMacroSyntax.SyntaxPhase Identifies which pipeline phase the instance runs in. The two values correspond to the Evaluation-bundle and PostLogic-bundle registrations of this same syntax class."
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Heidenhain.HeidenhainExpressionParser.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Heidenhain.HeidenhainExpressionParser.html",
    "title": "Class HeidenhainExpressionParser | HiAPI-C# 2025",
    "summary": "Class HeidenhainExpressionParser Namespace Hi.NcParsers.EvaluationSyntaxs.Heidenhain Assembly HiMech.dll Recursive-descent parser for Heidenhain klartext FN value expressions. Produces the same NcExpr AST as the Fanuc NcExpressionParser so NcExpressionEvaluator is reused unchanged. Pure: no variable lookup, no evaluation. Grammar (lowest precedence at top): expr := add-expr add-expr := term (('+' | '-') term)* term := factor (('*' | '/' | 'DIV') factor)* factor := ('+' | '-')? primary primary := number | '(' expr ')' | 'Q' digits | 'QR' digits | 'QL' digits | 'QS' digits | func primary → prefix form \"SQRT 4\" (FN 5) | func '(' arglist ')' → paren form \"SQRT(Q2)\" Dialect notes: Q-family tokens are canonicalised to uppercase (q1 → Q1) so Parsing.Assignments keys, table lookups and same-block references agree. (Caveat shared with the Siemens R canonicalisation: a lowercase-captured Assignments key keeps its raw spelling in the evaluator's same-block dictionary, so a later same-block reference resolves to the pre-block value instead — klartext posts emit uppercase, corpus-zero.) DIV is the FN 4 division spelling (FN 4: Q4 = +8 DIV +Q2) and maps onto the shared divide operator. Function names are limited to the klartext math vocabulary (SQRT SIN COS TAN ASIN ACOS ATAN ABS INT FRAC SGN NEG LN LOG EXP); INT normalises to the evaluator's FIX (truncate toward zero), names the shared evaluator lacks (FRAC/SGN/NEG/LOG) parse fine and fail soft at evaluation. Any other identifier is a parse error — klartext has no named variables, and rejecting bare words keeps the evaluator's Parsing-tree pass from touching non-expression strings (MM, MAX, tool-axis letters). Comparison/logical operators are deliberately absent: FN 9–12 jump conditions are pre-normalised by HeidenhainGotoParsingSyntax into separate value operands plus a shared comparison word — never parsed here. public sealed class HeidenhainExpressionParser Inheritance object HeidenhainExpressionParser Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods TryParse(string, out NcExpr, out string) Parses source requiring the whole string to be consumed. On success, expr is the AST and error is null. On failure, expr is null and error describes the syntax problem. public static bool TryParse(string source, out NcExpr expr, out string error) Parameters source string expr NcExpr error string Returns bool TryParsePrefix(string, out NcExpr, out int, out string) Parses the longest valid expression prefix of source. On success, consumedLength is the number of leading characters that form the expression (trailing text from that offset on is the caller's to keep, e.g. as remaining UnparsedText). Fails only when not even a prefix parses — callers fall back to their legacy lexical capture in that case. This is the parser-delimited RHS boundary for Q1 = Q1 - 1-style assignments (whitespace inside the expression, trailing non-expression words split correctly). public static bool TryParsePrefix(string source, out NcExpr expr, out int consumedLength, out string error) Parameters source string expr NcExpr consumedLength int error string Returns bool"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Heidenhain.HeidenhainGotoSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Heidenhain.HeidenhainGotoSyntax.html",
    "title": "Class HeidenhainGotoSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainGotoSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Heidenhain Assembly HiMech.dll Resolves Heidenhain FN 9–12 conditional jumps — the FanucGotoSyntax pattern with klartext LBL targets and a structural condition. Triggered by Parsing.HeidenhainGoto (written by HeidenhainGotoParsingSyntax); decides whether to fire, and on fire calls ReplaceSource(IEnumerable<T>) on layers[0] with the re-segmented file content starting at the target label line (inclusive — the definition marker is consumed by HeidenhainSubProgramReturnSyntax downstream). The condition is compared here, not by the expression grammar: the parsing owner pre-normalised the statement into two value operands plus a shared comparison word (the P2 decision that keeps the Heidenhain dialect free of comparison/logical layers). Each operand is read polymorphically — numeric (typed at capture for literals, or substituted in place by VariableEvaluatorSyntax for resolved Q references) fires the comparison; a still-string operand means unresolved (the FN 18 SYSREAD target staying vacant is the designed source) and the jump warns HeidenhainGoto--ConditionNotEvaluated and falls through — no fabricated values, both endings stay fail-soft. The label scan is whole-file first-match through the runner's own segmenter (SegmenterDependency) with the P4 call-path probe stack — klartext has no direction mnemonic and a TNC label is unique per program, so the anchored directional overloads would add a distinction the language does not have. Numeric labels canonicalize (\"01\" ≡ 1); GOTO LBL 0 targets the end-of-subprogram sentinel and is refused (HeidenhainGoto--Lbl0Target, the HeidenhainSubProgramCallSyntax precedent). Jumps hosted inside a P4 inlined body (CALL LBL/CALL PGM splice or a REP section pass) are recognized but not simulated — the redirect would discard the pending inline tail (HeidenhainGoto--InlinedContextUnsupported, the Siemens P5 guard). Pipeline placement: tail of the Heidenhain Evaluation bundle, after VariableEvaluatorSyntax (operand substitution) and the Q reader. The HeidenhainGotoIterationDependency watchdog caps fired jumps per (file, label); a missing watchdog disables the cap (Fanuc parity). public class HeidenhainGotoSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainGotoSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainGotoSyntax() Parameterless instance with default probe syntaxes. public HeidenhainGotoSyntax() HeidenhainGotoSyntax(XElement, string, IProgress<IMessage>) Loads hosted probe syntaxes from XML produced by MakeXmlSource(string, string, bool). The <LabelProbeSyntaxes> wrapper contains one child element per probe syntax in source order; an absent wrapper falls back to the default list. public HeidenhainGotoSyntax(XElement src, string baseDirectory, IProgress<IMessage> progress) Parameters src XElement Root element named XName. baseDirectory string Project base directory propagated to child XFactory calls. progress IProgress<IMessage> Diagnostic sink propagated to child factories. Properties LabelProbeSyntaxes Ordered list of helper syntaxes run on each candidate block during the label scan before the predicate is checked. Defaults match the P4 call-path probe stack of HeidenhainSubProgramCallSyntax: HeidenhainTildeTrimSyntax (strip ~ continuation heads), TailCommentSyntax with \";\" (a commented-out label never matches), HeadIndexSyntax with the bare klartext block-number symbol, then HeidenhainLblSyntax (whose definition regex excludes the CALL LBL and GOTO LBL spellings — a jump line is never a candidate). Order matters: strippers first, label parser last. public List<ISituNcSyntax> LabelProbeSyntaxes { get; set; } Property Value List<ISituNcSyntax> Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Heidenhain.HeidenhainQParameterReadingSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Heidenhain.HeidenhainQParameterReadingSyntax.html",
    "title": "Class HeidenhainQParameterReadingSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainQParameterReadingSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Heidenhain Assembly HiMech.dll Obtains values for Heidenhain Q parameters by consuming literal numeric assignments from Parsing.Assignments.Qn/QRn and routing them by id range — one reader for the single Q key shape, range routing inside (the Heidenhain analogue of the Fanuc range-routed reader trio): Q0-Q99 → HeidenhainQParameterTable free range (hincproj-persisted; the table is the single source of truth — no JSON mirror). QRn → the same table's permanent QR store. Q100-Q199 → controller-written system parameters: the write is consumed but not applied, with a HeidenhainQ--SystemReadOnly warning (no fabricated values). Q200+ → volatile range: dict-merged into Vars.Volatile with canonical Q+id keys, carried block-to-block like the Fanuc VolatileVariableReadingSyntax; cleared at program end by ProgramEndCleanSyntax. The carry of the previous block's Vars.Volatile happens on every block regardless of assignments, so the single-step traceback contract of HeidenhainVolatileQLookup holds. Only literal numeric RHS values are consumed (Q1 = 5000 ✓; Q1 = Q1*.75 ✗). Non-literal RHS entries are left untouched in Parsing.Assignments; VariableEvaluatorSyntax resolves them to literals earlier on the same block, so by the time this syntax runs, every evaluable RHS is literal. The two syntaxes are decoupled. public class HeidenhainQParameterReadingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainQParameterReadingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild: (with a HeidenhainQParameterTable on the dependency list; the literal moves into the table) { \"Parsing\": { \"Assignments\": { \"Q1\": \"300\" } } } #AfterBuild: {} Constructors HeidenhainQParameterReadingSyntax() Default constructor. public HeidenhainQParameterReadingSyntax() HeidenhainQParameterReadingSyntax(XElement) Loads from an XML element produced by MakeXmlSource(string, string, bool). No state to deserialise. public HeidenhainQParameterReadingSyntax(XElement src) Parameters src XElement Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Heidenhain.HeidenhainSubProgramCallSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Heidenhain.HeidenhainSubProgramCallSyntax.html",
    "title": "Class HeidenhainSubProgramCallSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainSubProgramCallSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Heidenhain Assembly HiMech.dll Consumes the Parsing.CALL record captured by HeidenhainCallSyntax and executes the three klartext call mechanisms over the shared M98 inline machinery: CALL LBL n / CALL LBL \"name\" (subprogram): the host file is re-segmented through the runner's own segmenter (SegmenterDependency), scanned for the matching LBL definition with LabelScanUtil and the LabelProbeSyntaxes, truncated at the first following LBL 0 (inclusive — its consumption pops the frame), and prepended into layers[0] with a pushed CallStack frame. A subprogram without LBL 0 is a structured safe-skip (inlining to EOF would double-execute the file tail). CALL LBL n REP m (program-section repeat — TNC semantics: the section from LBL n up to, not including, the call line runs m extra times): m fresh re-segmentation passes of that slice are prepended. A loop, not a call — no new CallStack frame is pushed, but the host block's stack propagates onto the repeated pieces so nested calls inside the section still accumulate depth against the rail; the repeat count itself is a literal bound. Any LBL 0 passed inside the section is a no-op for the return syntax (null-safe pop). CALL PGM name: resolved through InternalFolder with the FilePatterns chain ({0}.h → {0}.H → {0}) and inlined whole — the SiemensSubProgramCallSyntax mechanism verbatim, including resolve-miss safe-skip (HeidenhainCall--Skipped). The callee's END PGM pops the frame via HeidenhainSubProgramReturnSyntax; a unit switch inside the callee is not restored on return (recorded limitation). Recursion rail: like the Siemens call path, a self-recursive CALL LBL/CALL PGM would splice forever; a call whose host block already carries MaxCallDepth CallStack frames is consumed as a safe-skip with HeidenhainCall--DepthLimitExceeded. No MacroFrame is stamped — klartext subprograms share the caller's Q scope. Pipeline placement: head of the Heidenhain Evaluation bundle (the Fanuc discipline — call/inline ahead of all variable machinery). public class HeidenhainSubProgramCallSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainSubProgramCallSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainSubProgramCallSyntax() Parameterless instance with default settings. public HeidenhainSubProgramCallSyntax() HeidenhainSubProgramCallSyntax(XElement, string, IProgress<IMessage>) Loads FilePatterns, MaxCallDepth and LabelProbeSyntaxes from XML produced by MakeXmlSource(string, string, bool); absent elements fall back to defaults. public HeidenhainSubProgramCallSyntax(XElement src, string baseDirectory, IProgress<IMessage> progress) Parameters src XElement Root element named XName. baseDirectory string Project base directory propagated to child XFactory calls. progress IProgress<IMessage> Diagnostic sink propagated to child factories. Fields DefaultMaxCallDepth Default for MaxCallDepth — the Siemens call-path value; the TNC itself nests far lower (8 levels). public const int DefaultMaxCallDepth = 32 Field Value int FrameKindKey Key of the frame-kind marker on a CallFrame entry. public const string FrameKindKey = \"Kind\" Field Value string MaxRepetitions TNC's own repeat-count ceiling. A larger literal is a corrupt or hostile file; without the cap the O(rep × file size) re-scan loop is a single-input denial of service. public const int MaxRepetitions = 65534 Field Value int Properties FilePatterns Filename-resolution fallback chain for CALL PGM, formatted with the callee name as the only positional arg. Case-insensitive match is delegated to the host filesystem (the .h/.H pair matters on Linux). public List<string> FilePatterns { get; set; } Property Value List<string> LabelProbeSyntaxes Ordered probe syntaxes run on each candidate block during label scans, before the name predicate fires. Defaults match the Heidenhain Parsing bundle head (; tail comments, bare klartext block numbers, the LBL statement parser). Swappable via XML — the LabelProbeSyntaxes pattern. public List<ISituNcSyntax> LabelProbeSyntaxes { get; set; } Property Value List<ISituNcSyntax> MaxCallDepth Recursion rail for the call path (no iteration watchdog covers it); see the class remarks. public int MaxCallDepth { get; set; } Property Value int Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Heidenhain.HeidenhainSubProgramReturnSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Heidenhain.HeidenhainSubProgramReturnSyntax.html",
    "title": "Class HeidenhainSubProgramReturnSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainSubProgramReturnSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Heidenhain Assembly HiMech.dll Consumes the two klartext return spellings and the standalone label markers: LBL 0 — end-of-subprogram sentinel: stamps SubProgramReturn (Term: \"LBL 0\") and pops the CallStack frame (null-safe: an LBL 0 reached in the main flow — the 1.H head layout — is a no-op). Like the Fanuc M99, the \"return\" itself is structural: the call syntax truncated the inlined slice at this block, so the caller's tail follows naturally. LBL n / LBL \"name\" — definition markers: consumed into a block-root HeidenhainLbl record (no motion; keeps the label visible for dumps and the P5 jump family). END PGM with a non-empty CallStack — the return of a CALL PGM callee: consumes Parsing.PGM before the Logic program-header syntax can treat it as a real program end (which would clear the volatile Q store mid-stream), stamps SubProgramReturn (Term: \"END PGM\"), and pops the frame. The main file's END PGM (empty stack) is untouched. Pipeline placement: directly after HeidenhainSubProgramCallSyntax at the head of the Evaluation bundle. public class HeidenhainSubProgramReturnSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainSubProgramReturnSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainSubProgramReturnSyntax() Initializes a new instance with default settings. public HeidenhainSubProgramReturnSyntax() HeidenhainSubProgramReturnSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainSubProgramReturnSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Heidenhain.HeidenhainVolatileQLookup.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Heidenhain.HeidenhainVolatileQLookup.html",
    "title": "Class HeidenhainVolatileQLookup | HiAPI-C# 2025",
    "summary": "Class HeidenhainVolatileQLookup Namespace Hi.NcParsers.EvaluationSyntaxs.Heidenhain Assembly HiMech.dll Reads Heidenhain volatile Q parameters (Q200+, the cycle/user range that resets at program start) from Vars.Volatile. Self-gates the id range so the evaluator's RuntimeVariableLookups chain can fall through for other keys (Q0-Q99/QRn resolve on the HeidenhainQParameterTable further down the chain; Q100-Q199 stay vacant by design). Sibling of the Fanuc VolatileVariableLookup with the same single-step traceback contract: HeidenhainQParameterReadingSyntax dict-merges every block's Vars.Volatile into the next block, so the entry — if it exists — is on the current block or the immediately previous one. Keys are stored canonically as Q + id by the reader; this lookup re-canonicalises the incoming key the same way, so lowercase raw captures still resolve. Stateless and dependency-free. public class HeidenhainVolatileQLookup : IRuntimeVariableLookup, IMakeXmlSource Inheritance object HeidenhainVolatileQLookup Implements IRuntimeVariableLookup IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainVolatileQLookup() Default constructor. public HeidenhainVolatileQLookup() HeidenhainVolatileQLookup(XElement) Loads from an XML element produced by MakeXmlSource(string, string, bool). Stateless — no fields to deserialise. public HeidenhainVolatileQLookup(XElement src) Parameters src XElement Fields VolatileMax Inclusive upper bound of the volatile Q range (Q1999) — covers the TNC cycle-parameter and user ranges above the persistent/system segments. public const int VolatileMax = 1999 Field Value int VolatileMin Inclusive lower bound of the volatile Q range (Q200). public const int VolatileMin = 200 Field Value int Properties XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Get(string, LazyLinkedListNode<SyntaxPiece>, IReadOnlyList<INcDependency>) Returns the value of the variable identified by key in the context of node and dependencies, or null if the key is outside this lookup's range or the value is vacant. public double? Get(string key, LazyLinkedListNode<SyntaxPiece> node, IReadOnlyList<INcDependency> dependencies) Parameters key string node LazyLinkedListNode<SyntaxPiece> dependencies IReadOnlyList<INcDependency> Returns double? MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Heidenhain.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Heidenhain.html",
    "title": "Namespace Hi.NcParsers.EvaluationSyntaxs.Heidenhain | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.EvaluationSyntaxs.Heidenhain Classes HeidenhainExpressionParser Recursive-descent parser for Heidenhain klartext FN value expressions. Produces the same NcExpr AST as the Fanuc NcExpressionParser so NcExpressionEvaluator is reused unchanged. Pure: no variable lookup, no evaluation. Grammar (lowest precedence at top): expr := add-expr add-expr := term (('+' | '-') term)* term := factor (('*' | '/' | 'DIV') factor)* factor := ('+' | '-')? primary primary := number | '(' expr ')' | 'Q' digits | 'QR' digits | 'QL' digits | 'QS' digits | func primary → prefix form \"SQRT 4\" (FN 5) | func '(' arglist ')' → paren form \"SQRT(Q2)\" Dialect notes: Q-family tokens are canonicalised to uppercase (q1 → Q1) so Parsing.Assignments keys, table lookups and same-block references agree. (Caveat shared with the Siemens R canonicalisation: a lowercase-captured Assignments key keeps its raw spelling in the evaluator's same-block dictionary, so a later same-block reference resolves to the pre-block value instead — klartext posts emit uppercase, corpus-zero.) DIV is the FN 4 division spelling (FN 4: Q4 = +8 DIV +Q2) and maps onto the shared divide operator. Function names are limited to the klartext math vocabulary (SQRT SIN COS TAN ASIN ACOS ATAN ABS INT FRAC SGN NEG LN LOG EXP); INT normalises to the evaluator's FIX (truncate toward zero), names the shared evaluator lacks (FRAC/SGN/NEG/LOG) parse fine and fail soft at evaluation. Any other identifier is a parse error — klartext has no named variables, and rejecting bare words keeps the evaluator's Parsing-tree pass from touching non-expression strings (MM, MAX, tool-axis letters). Comparison/logical operators are deliberately absent: FN 9–12 jump conditions are pre-normalised by HeidenhainGotoParsingSyntax into separate value operands plus a shared comparison word — never parsed here. HeidenhainGotoSyntax Resolves Heidenhain FN 9–12 conditional jumps — the FanucGotoSyntax pattern with klartext LBL targets and a structural condition. Triggered by Parsing.HeidenhainGoto (written by HeidenhainGotoParsingSyntax); decides whether to fire, and on fire calls ReplaceSource(IEnumerable<T>) on layers[0] with the re-segmented file content starting at the target label line (inclusive — the definition marker is consumed by HeidenhainSubProgramReturnSyntax downstream). The condition is compared here, not by the expression grammar: the parsing owner pre-normalised the statement into two value operands plus a shared comparison word (the P2 decision that keeps the Heidenhain dialect free of comparison/logical layers). Each operand is read polymorphically — numeric (typed at capture for literals, or substituted in place by VariableEvaluatorSyntax for resolved Q references) fires the comparison; a still-string operand means unresolved (the FN 18 SYSREAD target staying vacant is the designed source) and the jump warns HeidenhainGoto--ConditionNotEvaluated and falls through — no fabricated values, both endings stay fail-soft. The label scan is whole-file first-match through the runner's own segmenter (SegmenterDependency) with the P4 call-path probe stack — klartext has no direction mnemonic and a TNC label is unique per program, so the anchored directional overloads would add a distinction the language does not have. Numeric labels canonicalize (\"01\" ≡ 1); GOTO LBL 0 targets the end-of-subprogram sentinel and is refused (HeidenhainGoto--Lbl0Target, the HeidenhainSubProgramCallSyntax precedent). Jumps hosted inside a P4 inlined body (CALL LBL/CALL PGM splice or a REP section pass) are recognized but not simulated — the redirect would discard the pending inline tail (HeidenhainGoto--InlinedContextUnsupported, the Siemens P5 guard). Pipeline placement: tail of the Heidenhain Evaluation bundle, after VariableEvaluatorSyntax (operand substitution) and the Q reader. The HeidenhainGotoIterationDependency watchdog caps fired jumps per (file, label); a missing watchdog disables the cap (Fanuc parity). HeidenhainQParameterReadingSyntax Obtains values for Heidenhain Q parameters by consuming literal numeric assignments from Parsing.Assignments.Qn/QRn and routing them by id range — one reader for the single Q key shape, range routing inside (the Heidenhain analogue of the Fanuc range-routed reader trio): Q0-Q99 → HeidenhainQParameterTable free range (hincproj-persisted; the table is the single source of truth — no JSON mirror). QRn → the same table's permanent QR store. Q100-Q199 → controller-written system parameters: the write is consumed but not applied, with a HeidenhainQ--SystemReadOnly warning (no fabricated values). Q200+ → volatile range: dict-merged into Vars.Volatile with canonical Q+id keys, carried block-to-block like the Fanuc VolatileVariableReadingSyntax; cleared at program end by ProgramEndCleanSyntax. The carry of the previous block's Vars.Volatile happens on every block regardless of assignments, so the single-step traceback contract of HeidenhainVolatileQLookup holds. Only literal numeric RHS values are consumed (Q1 = 5000 ✓; Q1 = Q1*.75 ✗). Non-literal RHS entries are left untouched in Parsing.Assignments; VariableEvaluatorSyntax resolves them to literals earlier on the same block, so by the time this syntax runs, every evaluable RHS is literal. The two syntaxes are decoupled. HeidenhainSubProgramCallSyntax Consumes the Parsing.CALL record captured by HeidenhainCallSyntax and executes the three klartext call mechanisms over the shared M98 inline machinery: CALL LBL n / CALL LBL \"name\" (subprogram): the host file is re-segmented through the runner's own segmenter (SegmenterDependency), scanned for the matching LBL definition with LabelScanUtil and the LabelProbeSyntaxes, truncated at the first following LBL 0 (inclusive — its consumption pops the frame), and prepended into layers[0] with a pushed CallStack frame. A subprogram without LBL 0 is a structured safe-skip (inlining to EOF would double-execute the file tail). CALL LBL n REP m (program-section repeat — TNC semantics: the section from LBL n up to, not including, the call line runs m extra times): m fresh re-segmentation passes of that slice are prepended. A loop, not a call — no new CallStack frame is pushed, but the host block's stack propagates onto the repeated pieces so nested calls inside the section still accumulate depth against the rail; the repeat count itself is a literal bound. Any LBL 0 passed inside the section is a no-op for the return syntax (null-safe pop). CALL PGM name: resolved through InternalFolder with the FilePatterns chain ({0}.h → {0}.H → {0}) and inlined whole — the SiemensSubProgramCallSyntax mechanism verbatim, including resolve-miss safe-skip (HeidenhainCall--Skipped). The callee's END PGM pops the frame via HeidenhainSubProgramReturnSyntax; a unit switch inside the callee is not restored on return (recorded limitation). Recursion rail: like the Siemens call path, a self-recursive CALL LBL/CALL PGM would splice forever; a call whose host block already carries MaxCallDepth CallStack frames is consumed as a safe-skip with HeidenhainCall--DepthLimitExceeded. No MacroFrame is stamped — klartext subprograms share the caller's Q scope. Pipeline placement: head of the Heidenhain Evaluation bundle (the Fanuc discipline — call/inline ahead of all variable machinery). HeidenhainSubProgramReturnSyntax Consumes the two klartext return spellings and the standalone label markers: LBL 0 — end-of-subprogram sentinel: stamps SubProgramReturn (Term: \"LBL 0\") and pops the CallStack frame (null-safe: an LBL 0 reached in the main flow — the 1.H head layout — is a no-op). Like the Fanuc M99, the \"return\" itself is structural: the call syntax truncated the inlined slice at this block, so the caller's tail follows naturally. LBL n / LBL \"name\" — definition markers: consumed into a block-root HeidenhainLbl record (no motion; keeps the label visible for dumps and the P5 jump family). END PGM with a non-empty CallStack — the return of a CALL PGM callee: consumes Parsing.PGM before the Logic program-header syntax can treat it as a real program end (which would clear the volatile Q store mid-stream), stamps SubProgramReturn (Term: \"END PGM\"), and pops the frame. The main file's END PGM (empty stack) is untouched. Pipeline placement: directly after HeidenhainSubProgramCallSyntax at the head of the Evaluation bundle. HeidenhainVolatileQLookup Reads Heidenhain volatile Q parameters (Q200+, the cycle/user range that resets at program start) from Vars.Volatile. Self-gates the id range so the evaluator's RuntimeVariableLookups chain can fall through for other keys (Q0-Q99/QRn resolve on the HeidenhainQParameterTable further down the chain; Q100-Q199 stay vacant by design). Sibling of the Fanuc VolatileVariableLookup with the same single-step traceback contract: HeidenhainQParameterReadingSyntax dict-merges every block's Vars.Volatile into the next block, so the entry — if it exists — is on the current block or the immediately previous one. Keys are stored canonically as Q + id by the reader; this lookup re-canonicalises the incoming key the same way, so lowercase raw captures still resolve. Stateless and dependency-free."
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.LabelScanDirection.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.LabelScanDirection.html",
    "title": "Enum LabelScanDirection | HiAPI-C# 2025",
    "summary": "Enum LabelScanDirection Namespace Hi.NcParsers.EvaluationSyntaxs Assembly HiMech.dll Scan region and match policy for the anchored LabelScanUtil overload. Forward scans take the first match below the anchor line; backward scans take the nearest match above it. public enum LabelScanDirection Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields BackwardNearestToAnchor = 1 Scan lines strictly above the anchor, nearest (last) match wins (GOTOB). ForwardFromAnchor = 0 Scan lines strictly below the anchor, first match wins (GOTOF)."
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.LabelScanUtil.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.LabelScanUtil.html",
    "title": "Class LabelScanUtil | HiAPI-C# 2025",
    "summary": "Class LabelScanUtil Namespace Hi.NcParsers.EvaluationSyntaxs Assembly HiMech.dll Shared “re-segment a file and skip pieces until a label matches” scan, used by both FanucGotoSyntax (unconditional GOTO redirect) and SubProgramReturnSyntax (M99 P{seq} jump into the caller file). Reads the file via ReadLines(int, string, string), segments through the provided ISegmenter, runs the caller-supplied probe syntaxes on each candidate block to extract IndexNote.Number, and returns the slice from the first matching block to EOF. Returns null when no block matches — the caller's responsibility to surface the appropriate diagnostic. The probes are idempotent because the downstream Parsing bundle re-runs the same syntaxes on the yielded pieces with no-op effect (the regex patterns no longer match once the N-prefix is consumed and the parenthesised comment stripped). public static class LabelScanUtil Inheritance object LabelScanUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods CanReadSource(List<INcDependency>, string, string) Whether a re-segmentation scan can obtain line content for labelPath — either an in-memory registration on the pipeline's NcLineSourceDependency (inline NC-code plays, whose pseudo-path never exists on disk) or an existing file at absPath. Jump syntaxes use this as the pre-scan guard in place of a bare File.Exists(absPath), so control flow inside inline plays is not misreported as a missing host file. public static bool CanReadSource(List<INcDependency> ncDependencyList, string labelPath, string absPath) Parameters ncDependencyList List<INcDependency> labelPath string absPath string Returns bool SegmentAndRewindToLine(ISegmenter, List<INcDependency>, string, string, int, int, int, NcDiagnosticProgress) Re-segments absPath and returns the slice starting at the first piece whose file line index equals beginLineIndex — the loop back-jump primitive (no label predicate, no probes). Extracted from the Fanuc WHILE/END reverse jump so the Siemens loop family shares the same engine; FanucWhileDoSyntax delegates here unchanged. Returns null when the line did not materialise as a segment start. public static List<SyntaxPiece> SegmentAndRewindToLine(ISegmenter segmenter, List<INcDependency> ncDependencyList, string absPath, string labelPath, int fileIndex, int sentenceIndexBegin, int beginLineIndex, NcDiagnosticProgress diag) Parameters segmenter ISegmenter Segmenter used to slice the file into Sentence blocks. ncDependencyList List<INcDependency> NC dependency list forwarded to GetSyntaxPieces(ISegmenter, List<INcDependency>, IEnumerable<IndexedFileLine>, int, NcDiagnosticProgress, CancellationToken) while re-segmenting the file. absPath string Absolute path to read line content from. labelPath string Project-relative path to stamp on each line's IndexedFileLine label. fileIndex int Fresh file index to stamp on each line, allocated by the caller from FileIndexCounterDependency. sentenceIndexBegin int Legacy fallback starting index — ignored when the pipeline carries a SentenceIndexCounterDependency. beginLineIndex int 0-based file line index of the block to rewind to (the loop-entry line). diag NcDiagnosticProgress Diagnostic sink for the re-segmentation. Returns List<SyntaxPiece> SegmentAndSkipUntilLabel(ISegmenter, List<INcDependency>, string, string, int, int, List<ISituNcSyntax>, Func<JsonObject, bool>, NcDiagnosticProgress) Predicate-driven overload. The caller supplies match as the per-candidate gate (run on the candidate block's JsonObject after the probe syntaxes have finished stamping). This unblocks scans whose label representation differs from IndexNote.Number — for example END m blocks identified by a custom probe-written section, where reusing IndexNote would collide with real N{m} head indices in the same file. The default targetN overload delegates here with the IndexNote.Number == targetN predicate baked in; existing callers (Fanuc unconditional GOTO, M99 P{seq} jump) are unchanged. public static List<SyntaxPiece> SegmentAndSkipUntilLabel(ISegmenter segmenter, List<INcDependency> ncDependencyList, string absPath, string labelPath, int fileIndex, int sentenceIndexBegin, List<ISituNcSyntax> probeSyntaxes, Func<JsonObject, bool> match, NcDiagnosticProgress diag) Parameters segmenter ISegmenter Segmenter used to slice the file into Sentence blocks. ncDependencyList List<INcDependency> NC dependency list forwarded to GetSyntaxPieces(ISegmenter, List<INcDependency>, IEnumerable<IndexedFileLine>, int, NcDiagnosticProgress, CancellationToken) while re-segmenting the scanned file. absPath string Absolute path to read line content from. labelPath string Project-relative path to stamp on each line's IndexedFileLine label. fileIndex int Fresh file index to stamp on each scanned line, allocated by the caller from FileIndexCounterDependency. sentenceIndexBegin int Legacy fallback starting index for the produced pieces — ignored when the pipeline carries a SentenceIndexCounterDependency. probeSyntaxes List<ISituNcSyntax> Ordered list of helper syntaxes to run on each candidate block before the predicate check. May be null. match Func<JsonObject, bool> Per-candidate predicate; true selects the first match. diag NcDiagnosticProgress Sink for any diagnostics produced by the probe syntaxes. Returns List<SyntaxPiece> SegmentAndSkipUntilLabel(ISegmenter, List<INcDependency>, string, string, int, int, List<ISituNcSyntax>, Func<JsonObject, bool>, int, LabelScanDirection, NcDiagnosticProgress) Anchored, direction-aware overload for the Siemens GOTOF/GOTOB family (and any other scan that must not see the whole file). The two legacy overloads above always scan the whole file top-down and take the first match — that cannot express “forward only, from the jump site” (GOTOF) or “nearest label above the jump site” (GOTOB), and it silently mis-targets when the same label text appears both before and after the host line. Semantics here: ForwardFromAnchor — only candidates whose file line index is strictly greater than anchorLineIndex are probed and matched; the first match wins. BackwardNearestToAnchor — only candidates strictly above anchorLineIndex are probed and matched; the last match (largest line index — nearest to the anchor) wins. Candidates without a resolvable line index are skipped. The returned slice runs from the matched block (inclusive — a label line may carry trailing code) to EOF, exactly like the legacy overloads; a backward jump is still \"replace the source with the slice from the target down\", the same shape the WHILE reverse jump uses. Returns null when no candidate matches. public static List<SyntaxPiece> SegmentAndSkipUntilLabel(ISegmenter segmenter, List<INcDependency> ncDependencyList, string absPath, string labelPath, int fileIndex, int sentenceIndexBegin, List<ISituNcSyntax> probeSyntaxes, Func<JsonObject, bool> match, int anchorLineIndex, LabelScanDirection direction, NcDiagnosticProgress diag) Parameters segmenter ISegmenter Segmenter used to slice the file into Sentence blocks. ncDependencyList List<INcDependency> NC dependency list forwarded to GetSyntaxPieces(ISegmenter, List<INcDependency>, IEnumerable<IndexedFileLine>, int, NcDiagnosticProgress, CancellationToken) while re-segmenting the scanned file. absPath string Absolute path to read line content from. labelPath string Project-relative path to stamp on each line's IndexedFileLine label. fileIndex int Fresh file index to stamp on each scanned line, allocated by the caller from FileIndexCounterDependency. sentenceIndexBegin int Legacy fallback starting index for the produced pieces — ignored when the pipeline carries a SentenceIndexCounterDependency. probeSyntaxes List<ISituNcSyntax> Ordered list of helper syntaxes to run on each in-region candidate before the predicate check. May be null. match Func<JsonObject, bool> Per-candidate predicate on the probed block's JSON. anchorLineIndex int 0-based file line index of the jump host block; the scan region excludes this line itself. direction LabelScanDirection Scan region and match policy relative to the anchor. diag NcDiagnosticProgress Sink for any diagnostics produced by the probe syntaxes. Returns List<SyntaxPiece> SegmentAndSkipUntilLabel(ISegmenter, List<INcDependency>, string, string, int, int, int, List<ISituNcSyntax>, NcDiagnosticProgress) Re-segments absPath from offset 0, scans for a block whose Number equals targetN (after the probeSyntaxes have stamped it in-place), and returns the sub-list of pieces from that block to EOF. Pieces are produced via GetSyntaxPieces(ISegmenter, List<INcDependency>, IEnumerable<IndexedFileLine>, int, NcDiagnosticProgress, CancellationToken), which stamps SentenceIndex from the session's SentenceIndexCounterDependency when present (the whole re-segmented file is numbered eagerly, so the discarded pre-label prefix leaves a gap in the sequence) and falls back to contiguous numbering from sentenceIndexBegin otherwise. Returns null when no match is found; the caller emits its own brand-specific “label not found” diagnostic. The predicate is fixed at the IndexNote.Number section — the section name comes from nameof() so a future rename propagates without re-edits. Reconfigurability for non-standard label-output sections is achieved by replacing the probe syntaxes (the natural extension point) rather than parameterising the predicate path here: a probe stack that doesn't end up writing IndexNote on candidates is by definition not participating in this scan. public static List<SyntaxPiece> SegmentAndSkipUntilLabel(ISegmenter segmenter, List<INcDependency> ncDependencyList, string absPath, string labelPath, int fileIndex, int sentenceIndexBegin, int targetN, List<ISituNcSyntax> probeSyntaxes, NcDiagnosticProgress diag) Parameters segmenter ISegmenter Segmenter used to slice the file into Sentence blocks. ncDependencyList List<INcDependency> NC dependency list forwarded to GetSyntaxPieces(ISegmenter, List<INcDependency>, IEnumerable<IndexedFileLine>, int, NcDiagnosticProgress, CancellationToken) while re-segmenting the scanned file. absPath string Absolute path to read line content from. labelPath string Project-relative path to stamp on each line's IndexedFileLine label (so diagnostics anchor to a relative form, not the resolver's transient absolute path). fileIndex int Fresh file index to stamp on each scanned line, allocated by the caller from FileIndexCounterDependency. sentenceIndexBegin int Legacy fallback starting index for the produced pieces — ignored when the pipeline carries a SentenceIndexCounterDependency. targetN int Integer label target to match against Number. probeSyntaxes List<ISituNcSyntax> Ordered list of helper syntaxes to run on each candidate block before the predicate check (typically comment-stripper(s) followed by a head-index parser). May be null. diag NcDiagnosticProgress Sink for any diagnostics produced by the probe syntaxes (e.g. comment-stripper malformed-comment warnings). Returns List<SyntaxPiece>"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.MacroFileResolver.ResolvedFile.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.MacroFileResolver.ResolvedFile.html",
    "title": "Struct MacroFileResolver.ResolvedFile | HiAPI-C# 2025",
    "summary": "Struct MacroFileResolver.ResolvedFile Namespace Hi.NcParsers.EvaluationSyntaxs Assembly HiMech.dll Tri-form resolution result. FileName is the bare matched name; RelPath is that name joined with the folder portion of the dependency (relative when the folder is configured relative, absolute fallback when it isn't); AbsPath is the fully-resolved I/O target. public readonly record struct MacroFileResolver.ResolvedFile : IEquatable<MacroFileResolver.ResolvedFile> Implements IEquatable<MacroFileResolver.ResolvedFile> Inherited Members ValueType.Equals(object) ValueType.GetHashCode() ValueType.ToString() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ResolvedFile(string, string, string) Tri-form resolution result. FileName is the bare matched name; RelPath is that name joined with the folder portion of the dependency (relative when the folder is configured relative, absolute fallback when it isn't); AbsPath is the fully-resolved I/O target. public ResolvedFile(string FileName, string RelPath, string AbsPath) Parameters FileName string RelPath string AbsPath string Properties AbsPath public string AbsPath { get; init; } Property Value string FileName public string FileName { get; init; } Property Value string RelPath public string RelPath { get; init; } Property Value string"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.MacroFileResolver.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.MacroFileResolver.html",
    "title": "Class MacroFileResolver | HiAPI-C# 2025",
    "summary": "Class MacroFileResolver Namespace Hi.NcParsers.EvaluationSyntaxs Assembly HiMech.dll Shared subprogram-/macro-file resolver for Fanuc-style O<n> lookups consumed by SubProgramCallSyntax (M98 / M198) and FanucMacroCallSyntax (G65). Single helper so the three path forms — file name, project-relative path, absolute path — are produced together at one site and each caller gets exactly the form it should consume: FileName — bare O####.NC form the resolver matched. Stored in JSON sections (FanucMacroCall, SubProgramCall) as the structural NC-language identifier; independent of which folder the dependency happened to be pointing at, so the JSON stays portable across environments. RelPath — relative path against the project base directory (e.g. \"NC/O1234.NC\"). Used as the IndexedFileLine label so diagnostics on inlined blocks align with the relative form already used for the main file label. AbsPath — absolute path. Used only at the ReadLines(int, string, string) call site for actual disk I/O; never persisted, never returned to JSON. Lives inside the resolver's stack frame and the segmenter's enumeration. Filename lookup order (first match wins) mirrors real Fanuc fallback: O{P:D4}.NC, O{P}.NC, O{P:D4}, O{P}, {P:D4}.NC, {P}.NC. Case-insensitive match is delegated to the host filesystem (Windows is, Linux is not). public static class MacroFileResolver Inheritance object MacroFileResolver Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields FilenamePatterns Filename-resolution fallback chain. Patterns are formatted with the P parameter as the only positional arg. public static readonly string[] FilenamePatterns Field Value string[] Methods ReadLines(int, string, string) Streams IndexedFileLine entries from absPath but stamps each entry's FilePath with the project-relative labelPath. Mirrors the manual loop in GetIndexedFileLines(string, IEnumerable<string>, int, NcDiagnosticProgress, CancellationToken) for the main file so inlined macros stay consistent with the rest of the pipeline (diagnostics anchored to a relative label, not the resolver's transient absolute path). public static IEnumerable<IndexedFileLine> ReadLines(int fileIndex, string absPath, string labelPath) Parameters fileIndex int absPath string labelPath string Returns IEnumerable<IndexedFileLine> Resolve(string, int, string) Resolves an O<p> file against the given folder, returning all three path forms. Returns null when the folder cannot be anchored (relative folder but no baseDirectory), the resolved folder does not exist, or no filename pattern matched. folder may be absolute (used as-is) or relative (combined with baseDirectory). Empty / null folder means \"look directly in baseDirectory\". When the folder is absolute, RelPath falls back to absolute too — there's no natural relative form when the user explicitly configured an out-of-project folder. public static MacroFileResolver.ResolvedFile? Resolve(string folder, int p, string baseDirectory) Parameters folder string p int baseDirectory string Returns MacroFileResolver.ResolvedFile? Resolve(string, string, string, IEnumerable<string>) Name-based sibling of Resolve(string, int, string) for dialects whose subprogram identifier is a word rather than an O-number (Siemens L9810 / HQ_FC by-name calls). patterns is formatted with the name as the only positional arg (e.g. \"{0}.SPF\") — supplied per call so brand pattern sets stay on their own syntaxes instead of leaking into the shared Fanuc FilenamePatterns chain. Folder anchoring and the tri-form result follow the int overload exactly. public static MacroFileResolver.ResolvedFile? Resolve(string folder, string name, string baseDirectory, IEnumerable<string> patterns) Parameters folder string name string baseDirectory string patterns IEnumerable<string> Returns MacroFileResolver.ResolvedFile?"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.MacroInlineUtil.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.MacroInlineUtil.html",
    "title": "Class MacroInlineUtil | HiAPI-C# 2025",
    "summary": "Class MacroInlineUtil Namespace Hi.NcParsers.EvaluationSyntaxs Assembly HiMech.dll Shared inline mechanism for Fanuc Custom Macro B body expansion — used by both FanucMacroCallSyntax (one-shot) and FanucModalMacroSyntax's expansion phase (modal trigger). Both callers do the same three things on every produced SyntaxPiece: stamp a FanucMacroCall clone, stamp a fresh MacroFrame id, and stamp argument bindings into Vars.Local. Centralising lets the two call sites stay in lock-step — frame allocation, file-index allocation, and the inline-piece JSON shape are guaranteed identical. Frame ids share the same FileIndexCounterDependency counter as file indices — both just need within-session uniqueness and the counter is rewound on session start in lock-step with the pipeline. The main NC file is allocated index 0 first, so all inline frame ids land at > 0 and never collide with main. public static class MacroInlineUtil Inheritance object MacroInlineUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods ApplyLocalBindings(JsonObject, IReadOnlyDictionary<string, double>) Writes the resolved #N → value bindings into Vars.Local on the given block. No-op when bindings is empty. Always overwrites any pre-existing Vars.Local on the block — for inlined macro bodies this is a fresh stamp. public static void ApplyLocalBindings(JsonObject json, IReadOnlyDictionary<string, double> bindings) Parameters json JsonObject bindings IReadOnlyDictionary<string, double> BuildInlinedPieces(ResolvedFile, int, IReadOnlyDictionary<string, double>, JsonObject, JsonObject, FileIndexCounterDependency, ISegmenter, List<INcDependency>, int, NcDiagnosticProgress) Yields L repetitions of the macro body as inline-ready SyntaxPiece entries. Each repetition gets its own freshly-allocated FileIndex and MacroFrame id; every yielded piece is stamped with a deep clone of callRecord, the frame id, and the resolved #N → value bindings. The caller passes the result to PrependSource(IEnumerable<T>) on the source layer. SentenceIndex allocation happens inside GetSyntaxPieces(ISegmenter, List<INcDependency>, IEnumerable<IndexedFileLine>, int, NcDiagnosticProgress, CancellationToken) via the session's FileIndexCounterDependency sibling SentenceIndexCounterDependency; sentenceIndexBegin is only the legacy fallback numbering for counter-less presets. public static IEnumerable<SyntaxPiece> BuildInlinedPieces(MacroFileResolver.ResolvedFile resolvedFile, int l, IReadOnlyDictionary<string, double> bindings, JsonObject callRecord, JsonObject pushedCallStack, FileIndexCounterDependency counterDep, ISegmenter segmenter, List<INcDependency> ncDependencyList, int sentenceIndexBegin, NcDiagnosticProgress ncDiagnosticProgress) Parameters resolvedFile MacroFileResolver.ResolvedFile l int bindings IReadOnlyDictionary<string, double> callRecord JsonObject pushedCallStack JsonObject counterDep FileIndexCounterDependency segmenter ISegmenter ncDependencyList List<INcDependency> sentenceIndexBegin int ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<SyntaxPiece> BuildLocalBindings(JsonObject) Translates the argument-letter map captured by the host call ({ “A”: 1.5, “B”: 2.0, ... }) into the #N → value bindings the macro body's expression evaluator will read off Vars.Local. Skips non-numeric (string) args silently — those are unresolved variable references that the evaluator's own VariableExpression–Unevaluated diagnostic will surface; writing a string into Vars.Local would just propagate the residue. public static Dictionary<string, double> BuildLocalBindings(JsonObject args) Parameters args JsonObject Returns Dictionary<string, double>"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.RetainedCommonVariableReadingSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.RetainedCommonVariableReadingSyntax.html",
    "title": "Class RetainedCommonVariableReadingSyntax | HiAPI-C# 2025",
    "summary": "Class RetainedCommonVariableReadingSyntax Namespace Hi.NcParsers.EvaluationSyntaxs Assembly HiMech.dll Obtains values for Fanuc-style retained common variables (#500-#999) by consuming literal numeric assignments from Parsing.Assignments.#nnn and writing them straight to a registered RetainedCommonVariableTable. No SyntaxPiece JSON mirror is created — the table is the single source of truth for retained values, and VariableEvaluatorSyntax reads from the table directly. The hincproj round-trip preserves writes across project sessions. Only literal numeric RHS values are consumed by this syntax (#500 = 1.234 ✓; #600 = #500 + 1 ✗). Non-literal RHS entries are left untouched in Parsing.Assignments; VariableEvaluatorSyntax resolves them and writes the result through the same table. The two syntaxes are decoupled. If no RetainedCommonVariableTable is registered on the runner's NcDependencyList, this syntax is a no-op. public class RetainedCommonVariableReadingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object RetainedCommonVariableReadingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors RetainedCommonVariableReadingSyntax() Default constructor. public RetainedCommonVariableReadingSyntax() RetainedCommonVariableReadingSyntax(XElement) Loads from an XML element produced by MakeXmlSource(string, string, bool). No state to deserialise. public RetainedCommonVariableReadingSyntax(XElement src) Parameters src XElement Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensAcIcSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensAcIcSyntax.html",
    "title": "Class SiemensAcIcSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensAcIcSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Siemens Assembly HiMech.dll Recognizes the Siemens per-word coordinate function family on axis words — AC(...) (absolute), IC(...) (incremental), DC(...) (rotary shortest-path), ACP(...) / ACN(...) (rotary directional approach), and the coded-position (indexing axis) counterparts CAC(...) / CIC(...) / CDC(...) / CACP(...) / CACN(...) — e.g. X=AC(400), C=IC(360/17), C=DC(47.296), B=CAC(2) — unwraps the inner expression so the downstream VariableEvaluatorSyntax resolves it through the normal Siemens expression machinery, and records the per-word positioning override in a block-root PositioningOverride section keyed by word name (Absolute / Incremental / Shortest / PositiveOnly / NegativeOnly, and the Coded* values for the coded-position verbs). Siemens semantics: the wrapper forces the interpretation of that one coordinate word for that one block, regardless of the modal G90/G91 state. The positional conversion itself stays with the same consumers that honor the modal state — IncrementalResolveSyntax for linear axes and McAbcSyntax for rotary axes (both treat every non-Incremental override as an absolute write), while the rotary shortest/directional resolution stays with the McAbcCyclicPathSyntax tail-pass — this syntax only normalizes the text and stamps the override; it never reads machine position (the Evaluation stage is not the place for position-state reads). Scope: axis words (per AxisNames, falling back to X/Y/Z/A/B/C) accept the full family, except that the rotary-only verbs DC/ACP/ACN are unwrapped only on rotary axes (per IsRotaryAxis(string), falling back to A/B/C) — on a linear axis they are invalid Siemens and are left untouched so they surface as unevaluated residue instead of being silently mis-read. The interpolation parameters I/J/K accept AC/IC only (Siemens circle centers are incremental by default; I=AC(...) switches that one component to an absolute center coordinate, consumed by SiemensCircularMotionSyntax) — the rotary verbs are meaningless there and are left untouched. The coded-position verbs (their argument is a 1-based indexing position number, not a coordinate) are unwrapped only on axes that IsIndexingAxis(string) reports as usable indexing axes — CDC/CACP/CACN additionally require the axis to be rotary. Everywhere else (a non-indexing axis, no indexing config on the list, I/J/K) they stay untouched, mirroring the Siemens alarm 17500 (\"axis is not an indexing axis\") with loud unevaluated residue. The number→coordinate lookup happens at the write stage (McAbcSyntax / IncrementalResolveSyntax via CodedPositionUtil), not here — the Evaluation stage neither reads machine position nor resolves tables. Positioning-axis forms (POS[C]=DC(...) / SPOS=) never reach the word path and are out of scope. Values whose parentheses do not balance around the wrapper (e.g. IC(1)+AC(2)) are also left untouched. Must be placed in the Evaluation bundle before VariableEvaluatorSyntax (the unwrapped inner text is a plain Siemens expression the evaluator numeric-ifies on the same block). Inside REPEAT / subprogram splices each re-fed piece runs the full bundle again, so the unwrap happens on every iteration. public class SiemensAcIcSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensAcIcSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples C=IC(360/17) (the HUA08126 REPEAT shape) — the wrapper is unwrapped to the inner expression (still a string; the evaluator numeric-ifies it later on the same block) and the override section records the per-word incremental interpretation: #BeforeBuild: { \"Parsing\": { \"C\": \"IC(360/17)\" } } #AfterBuild: { \"Parsing\": { \"C\": \"360/17\" }, \"PositioningOverride\": { \"C\": \"Incremental\" } } X=AC(25) — absolute override; the inner literal stays a string here (pass-2 of the evaluator turns it numeric): #BeforeBuild: { \"Parsing\": { \"X\": \"AC(25)\" } } #AfterBuild: { \"Parsing\": { \"X\": \"25\" }, \"PositioningOverride\": { \"X\": \"Absolute\" } } A plain expression without the wrapper is not touched and no override section appears: #BeforeBuild: { \"Parsing\": { \"X\": \"R5+2\" } } #AfterBuild: { \"Parsing\": { \"X\": \"R5+2\" } } Unbalanced wrapper parentheses (IC(1)+AC(2) — the outer regex shape matches but the inner text closes the wrapper early) — left untouched so it surfaces as unevaluated residue instead of a silent mis-read: #BeforeBuild: { \"Parsing\": { \"X\": \"IC(1)+AC(2)\" } } #AfterBuild: { \"Parsing\": { \"X\": \"IC(1)+AC(2)\" } } C=DC(47.296) (the A055548 corpus shape, 6632 lines in one program) — rotary shortest-path: unwrapped like AC and stamped Shortest; the write stays absolute and the shortest swing is the unconditional McAbcCyclicPathSyntax tail-pass for modular rotary axes (an exactly-180° target resolves deterministically to the negative swing — the tail-pass window is half-open [anchor-180°, anchor+180°); real controls make that measure-zero tie machine-data-dependent): #BeforeBuild: { \"Parsing\": { \"C\": \"DC(47.296)\" } } #AfterBuild: { \"Parsing\": { \"C\": \"47.296\" }, \"PositioningOverride\": { \"C\": \"Shortest\" } } X=DC(90) — the rotary-only verb on a linear axis is invalid Siemens (real controls alarm): left untouched, loud residue instead of a silent absolute conversion: #BeforeBuild: { \"Parsing\": { \"X\": \"DC(90)\" } } #AfterBuild: { \"Parsing\": { \"X\": \"DC(90)\" } } C=ACP(270) — absolute target, positive-direction-only approach (may deliberately take the long way around): #BeforeBuild: { \"Parsing\": { \"C\": \"ACP(270)\" } } #AfterBuild: { \"Parsing\": { \"C\": \"270\" }, \"PositioningOverride\": { \"C\": \"PositiveOnly\" } } C=ACN(90) — the negative-direction mirror: #BeforeBuild: { \"Parsing\": { \"C\": \"ACN(90)\" } } #AfterBuild: { \"Parsing\": { \"C\": \"90\" }, \"PositioningOverride\": { \"C\": \"NegativeOnly\" } } I=AC(400) — interpolation parameter switched to an absolute center coordinate (Siemens I/J/K default incremental); consumed by SiemensCircularMotionSyntax: #BeforeBuild: { \"Parsing\": { \"I\": \"AC(400)\" } } #AfterBuild: { \"Parsing\": { \"I\": \"400\" }, \"PositioningOverride\": { \"I\": \"Absolute\" } } I=DC(10) — rotary verbs are meaningless on interpolation parameters: left untouched, loud residue: #BeforeBuild: { \"Parsing\": { \"I\": \"DC(10)\" } } #AfterBuild: { \"Parsing\": { \"I\": \"DC(10)\" } } The coded-position cases below inject a SiemensMachineDataTable declaring C rotary and X linear, both assigned to indexing table 1 = [0, 90, 180, 270] (the values double as mm for X). C=CAC(3) — coded absolute: the inner text (a position number expression, numeric-ified later by the evaluator like every other case) is unwrapped and the coded override is stamped; the number→angle lookup stays with the write-stage consumers: #BeforeBuild: { \"Parsing\": { \"C\": \"CAC(3)\" } } #AfterBuild: { \"Parsing\": { \"C\": \"3\" }, \"PositioningOverride\": { \"C\": \"CodedAbsolute\" } } C=CIC(2) — coded incremental (advance two indexing positions): #BeforeBuild: { \"Parsing\": { \"C\": \"CIC(2)\" } } #AfterBuild: { \"Parsing\": { \"C\": \"2\" }, \"PositioningOverride\": { \"C\": \"CodedIncremental\" } } C=CDC(4) — coded shortest-path: #BeforeBuild: { \"Parsing\": { \"C\": \"CDC(4)\" } } #AfterBuild: { \"Parsing\": { \"C\": \"4\" }, \"PositioningOverride\": { \"C\": \"CodedShortest\" } } C=CACP(2) — coded positive-direction-only: #BeforeBuild: { \"Parsing\": { \"C\": \"CACP(2)\" } } #AfterBuild: { \"Parsing\": { \"C\": \"2\" }, \"PositioningOverride\": { \"C\": \"CodedPositiveOnly\" } } C=CACN(2) — coded negative-direction-only: #BeforeBuild: { \"Parsing\": { \"C\": \"CACN(2)\" } } #AfterBuild: { \"Parsing\": { \"C\": \"2\" }, \"PositioningOverride\": { \"C\": \"CodedNegativeOnly\" } } C=CAC(3) with no indexing config on the dependency list (this case injects none) — the axis is not an indexing axis, so the word stays untouched and surfaces as loud unevaluated residue (the Siemens control raises alarm 17500 here): #BeforeBuild: { \"Parsing\": { \"C\": \"CAC(3)\" } } #AfterBuild: { \"Parsing\": { \"C\": \"CAC(3)\" } } X=CDC(2) — the rotary coded verbs are invalid on a linear indexing axis: left untouched, loud residue (X=CAC(2) / X=CIC(2) would unwrap): #BeforeBuild: { \"Parsing\": { \"X\": \"CDC(2)\" } } #AfterBuild: { \"Parsing\": { \"X\": \"CDC(2)\" } } I=CAC(3) — interpolation parameters take no coded verbs: #BeforeBuild: { \"Parsing\": { \"I\": \"CAC(3)\" } } #AfterBuild: { \"Parsing\": { \"I\": \"CAC(3)\" } } Constructors SiemensAcIcSyntax() Initializes a new instance with default settings. public SiemensAcIcSyntax() SiemensAcIcSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public SiemensAcIcSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensExpressionParser.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensExpressionParser.html",
    "title": "Class SiemensExpressionParser | HiAPI-C# 2025",
    "summary": "Class SiemensExpressionParser Namespace Hi.NcParsers.EvaluationSyntaxs.Siemens Assembly HiMech.dll Recursive-descent parser for Sinumerik value expressions. Produces the same NcExpr AST as the Fanuc NcExpressionParser so NcExpressionEvaluator is reused unchanged. Pure: no variable lookup, no evaluation. Grammar (lowest precedence at top): expr := or-expr or-expr := and-expr (('OR' | 'XOR') and-expr)* and-expr := cmp-expr ('AND' cmp-expr)* cmp-expr := add-expr (('==' | '<>' | '>=' | '<=' | '>' | '<') add-expr)* add-expr := term (('+' | '-') term)* term := factor (('*' | '/' | 'MOD') factor)* factor := ('+' | '-')? primary primary := number | '(' expr ')' | 'R' digits → variable \"R63\" (canonical uppercase) | '$' name ('[' indexlist ']')? → variable \"$P_UIFR[1,X,TR]\" (canonical) | name '(' arglist ')' → function call | name '[' indexlist ']' → variable \"_RENC[35]\" (canonical) | name → variable \"_X_HOME\" (case preserved) indexlist := (integer | name) (',' (integer | name))* arglist := expr (',' expr)* Dialect differences from the Fanuc parser: parentheses group and call (Fanuc uses brackets); comparisons are spelled == <> >= <= > < (Fanuc uses EQ NE .. words); bare identifiers are named-variable references (Fanuc rejects an identifier without [); R63 is canonicalised to uppercase so table lookups and Parsing.Assignments keys agree. Indexed accesses ($P_UIFR[1,X,TR], _RENC[35]) require literal index elements (integers, bare letters, or keywords like TR) and are emitted as a single NcVariableExpr whose key is the canonical uppercase-indexed token — the whole token routes through Get(string), keeping the AST brand-agnostic. Function-name aliases are normalised where Sinumerik and the shared evaluator spell the same math differently: ATAN2 → ATAN (both are two-arg atan2 in degrees), TRUNC → FIX (truncate toward zero). Unknown functions (e.g. the rotary positioning form DC(...)) parse fine and fail later in the evaluator, which callers treat as fail-soft. public sealed class SiemensExpressionParser Inheritance object SiemensExpressionParser Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods TryParse(string, out NcExpr, out string) Parses source requiring the whole string to be consumed. On success, expr is the AST and error is null. On failure, expr is null and error describes the syntax problem. public static bool TryParse(string source, out NcExpr expr, out string error) Parameters source string expr NcExpr error string Returns bool TryParsePrefix(string, out NcExpr, out int, out string) Parses the longest valid expression prefix of source. On success, consumedLength is the number of leading characters that form the expression (trailing text from that offset on is the caller's to keep, e.g. as remaining UnparsedText). Fails only when not even a prefix parses (e.g. the text starts with a quote or an operator dangles at end-of-input) — callers fall back to their legacy lexical capture in that case. This is the parser-delimited RHS boundary: the expression grammar itself decides where the right-hand side ends, so whitespace inside expressions (R64 - 14/2), balanced call parentheses (DC(47.296)) and a following non-expression word (R24=14 R26=... / F=R103 X-204.) all resolve without lexical boundary regexes or TerminateWords. public static bool TryParsePrefix(string source, out NcExpr expr, out int consumedLength, out string error) Parameters source string expr NcExpr consumedLength int error string Returns bool"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensGotoSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensGotoSyntax.html",
    "title": "Class SiemensGotoSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensGotoSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Siemens Assembly HiMech.dll Resolves Siemens GOTOF/GOTOB control flow — the FanucGotoSyntax pattern with named-label targets and explicit direction. Triggered by Parsing.SiemensGoto (written by SiemensGotoParsingSyntax); decides whether to fire, and on fire calls ReplaceSource(IEnumerable<T>) on layers[0] with the re-segmented file content starting at the target label line (inclusive — a Siemens label may prefix code). Direction comes from the mnemonic and drives the anchored LabelScanUtil overload: GOTOF takes the first match strictly below the host line, GOTOB the nearest match strictly above it — never the whole-file first match, which would silently mis-target duplicate label texts. Targets may be a named label (LBL1: line, matched Ordinal-exact on the block-root SiemensLabel record) or an N<num> block number (matched on Number). The conditional forms (IF <cond> GOTOF <label>) lean on VariableEvaluatorSyntax's pass-2 tree walk; ReadCondition(JsonNode) (a dialect-neutral numeric-JSON reader despite its home) reads the resolved node. Truthy fires; zero falls through silently; unresolved warns SiemensGoto--ConditionNotEvaluated and falls through. Because the label field is an ordinary Parsing string, a label name that collides with a set named variable may have been substituted to a numeric by the evaluator — the original text is then recovered from the Formula.SiemensGoto.Label mirror. Pipeline placement: Evaluation bundle, in the control-flow group after VariableEvaluatorSyntax. The SiemensGotoIterationDependency watchdog caps fired jumps per (file, label); a missing watchdog disables the cap (Fanuc parity). public class SiemensGotoSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensGotoSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SiemensGotoSyntax() Parameterless instance with default probe syntaxes. public SiemensGotoSyntax() SiemensGotoSyntax(XElement, string, IProgress<IMessage>) Loads hosted probe syntaxes from XML produced by MakeXmlSource(string, string, bool). The <LabelProbeSyntaxes> wrapper contains one child element per probe syntax in source order; an absent wrapper falls back to the default list. public SiemensGotoSyntax(XElement src, string baseDirectory, IProgress<IMessage> progress) Parameters src XElement Root element named XName. baseDirectory string Project base directory propagated to child XFactory calls. progress IProgress<IMessage> Diagnostic sink propagated to child factories. Properties LabelProbeSyntaxes Ordered list of helper syntaxes run on each candidate block during the label scan before the predicate is checked. Defaults match the Siemens probe stack established by the P4 REPEAT scan: TailCommentSyntax (strip ; comments so a commented-out label never matches), HeadIndexSyntax with symbol “N” (so N100 block-number targets resolve and a numbered label line still exposes its label), then SiemensLabelSyntax (block-root SiemensLabel record). Order matters: comment stripper first, label parser last. public List<ISituNcSyntax> LabelProbeSyntaxes { get; set; } Property Value List<ISituNcSyntax> Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensIfSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensIfSyntax.html",
    "title": "Class SiemensIfSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensIfSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Siemens Assembly HiMech.dll Resolves the Siemens IF ... [ELSE ...] ENDIF block conditional. Three phrases dispatched by Term, none of which needs a frame stack: IF — reads the resolved condition via FanucConditionReader (dialect-neutral numeric-JSON reader). True falls through into the then-branch; false forward-jumps to just after the matching ELSE (else-branch executes) or after the matching ENDIF when no else exists; unresolved warns SiemensIf--ConditionNotEvaluated and falls through (no redirect on unresolved input — the then-branch executes, and the ELSE rule below then skips the else-branch, which keeps the two branches mutually exclusive even on the fail-soft path). ELSE — reached in the normal stream only when the then-branch just executed (a false IF jumps past the ELSE line directly), so it unconditionally forward-jumps past the matching ENDIF. ENDIF — consumed no-op (stamped for cache dumps). Both forward scans run on the anchored LabelScanUtil overload from the host line, with a nesting-depth predicate: each nested block-IF increments the depth, each ENDIF at depth > 0 decrements it, and the match fires only at depth 0. The probe stack replays the Parsing statement owners the depth counter depends on — including SiemensGotoParsingSyntax ahead of SiemensIfParsingSyntax, so a nested single-line IF cond GOTOF lbl is claimed by the GOTO owner and never miscounted as a block-IF. Pipeline placement: Evaluation bundle control-flow group, after VariableEvaluatorSyntax (condition substituted) and before the variable readers. public class SiemensIfSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensIfSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SiemensIfSyntax() Parameterless instance (no XML state). public SiemensIfSyntax() SiemensIfSyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public SiemensIfSyntax(XElement src) Parameters src XElement Root element named XName. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensInlineContextUtil.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensInlineContextUtil.html",
    "title": "Class SiemensInlineContextUtil | HiAPI-C# 2025",
    "summary": "Class SiemensInlineContextUtil Namespace Hi.NcParsers.EvaluationSyntaxs.Siemens Assembly HiMech.dll Detects whether a block executes inside a P4 inlined body — an L/name-call subprogram splice or a REPEAT label section repetition. Both are PrependSource inlines whose “return to the caller / to the line after REPEAT” is the natural pipeline tail; the P5 control-flow redirects (ReplaceSource with a re-segmented host-file slice) would silently discard that pending tail — and, for a section repeat, re-execute the REPEAT statement itself, which has no watchdog (its count is eagerly known) and therefore no bound. The P5 jump syntaxes consult this guard and degrade to a structured warning + fall-through instead: control flow inside an inlined body is recognized but not simulated (corpus count zero; true support needs return-frame machinery, a future work item). Subprogram context: the call syntax stamps a pushed CallStack on every inlined piece — any frame on the stack marks callee context. Section-repeat context: SiemensRepeatSyntax stamps every inlined piece with a SiemensRepeat clone carrying a 1-based Iteration; the REPEAT host block itself never carries that field. public static class SiemensInlineContextUtil Inheritance object SiemensInlineContextUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods IsInlinedContext(JsonObject) True when hostJson belongs to an inlined subprogram or section-repeat body (see class remarks). public static bool IsInlinedContext(JsonObject hostJson) Parameters hostJson JsonObject Returns bool"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensLoopSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensLoopSyntax.html",
    "title": "Class SiemensLoopSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensLoopSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Siemens Assembly HiMech.dll Resolves the four Siemens loop constructs against one shared frame stack — WHILE ... ENDWHILE, FOR ... ENDFOR, REPEAT ... UNTIL (the label-less post-test loop) and LOOP ... ENDLOOP — the FanucWhileDoSyntax template (frames-in-JSON + ModalCarry tracked key + forward scan to the terminator + back-jump to the recorded entry line), adapted to constructs that carry no LoopId: frames stack in nesting order on the block-root SiemensLoopFrames section, and every terminator validates that the innermost frame carries its own construct Kind and file. A single shared stack is what makes mixed-construct nesting (a FOR inside a WHILE inside a LOOP) pair correctly. WHILE — pre-test: truthy pushes a frame (first arrival) and falls through; falsy/unresolved pops its own frame and forward-jumps past the matching ENDWHILE (depth-counted). ENDWHILE back-jumps unconditionally; the WHILE line re-evaluates. FOR — counting: first arrival resolves the bounds once (Sinumerik semantics), assigns the loop variable by lifting into Parsing.Assignments (the reader syntaxes downstream persist it exactly as a written assignment), and pushes a frame carrying Var/End/Value; each re-arrival increments Value until it exceeds End, then pops and jumps past ENDFOR. REPEAT/UNTIL — post-test: REPEAT pushes and always falls through; UNTIL exits on truthy (pop), warns and exits on unresolved, back-jumps to the REPEAT line on falsy. LOOP/ENDLOOP — endless: ENDLOOP back-jumps while the SiemensLoopIterationDependency watchdog allows; the watchdog is a hard requirement here (no exit condition exists), so a missing dependency suppresses the jump with a configuration error instead of hanging the pipeline. Back-jump counting happens at the back-jump step only (a loop whose condition is false from the outset consumes zero iterations), keyed (FileName, BeginLineNo) on the watchdog. All scans use the anchored LabelScanUtil overload from the host line — never the whole-file first match, which would pair a terminator with an earlier sibling construct of the same kind. Pipeline placement: Evaluation bundle control-flow group, after VariableEvaluatorSyntax (conditions and bounds substituted) and before the variable readers (the FOR lift must reach them on the same block). Known limitation — stack pairing vs lexical pairing. Real Sinumerik pairs loop constructs lexically at block preparation; this syntax pairs them dynamically on the carried frame stack. A GOTOF/GOTOB that leaves a loop body strands that loop's frame (only the FOR head detects and drops a stale frame, via AdvancePending), so a jump from an inner loop into an enclosing loop's body can mispair the enclosing terminator with the stale inner frame. Sinumerik itself forbids jumping into control structures; all such shapes stay bounded here by the watchdog and surface loud diagnostics. Scan probes also mirror the Fanuc convention of not replaying BlockSkipSyntax — a /-prefixed terminator is invisible to the exit scans. public class SiemensLoopSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensLoopSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SiemensLoopSyntax() Parameterless instance (no XML state). public SiemensLoopSyntax() SiemensLoopSyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public SiemensLoopSyntax(XElement src) Parameters src XElement Root element named XName. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensNamedVariableLookup.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensNamedVariableLookup.html",
    "title": "Class SiemensNamedVariableLookup | HiAPI-C# 2025",
    "summary": "Class SiemensNamedVariableLookup Namespace Hi.NcParsers.EvaluationSyntaxs.Siemens Assembly HiMech.dll Reads Sinumerik named program variables (_X_HOME) from Vars.Named. Self-gates on the named-identifier key shape so the evaluator's RuntimeVariableLookups chain can fall through for other keys. Sibling of the Fanuc VolatileVariableLookup with the same single-step traceback: SiemensNamedVariableReadingSyntax dict-merges every block's Vars.Named into the next block, so the entry — if it exists — is on the current block or the immediately previous one. Stateless and dependency-free — instances are interchangeable. public class SiemensNamedVariableLookup : IRuntimeVariableLookup, IMakeXmlSource Inheritance object SiemensNamedVariableLookup Implements IRuntimeVariableLookup IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SiemensNamedVariableLookup() Default constructor. public SiemensNamedVariableLookup() SiemensNamedVariableLookup(XElement) Loads from an XML element produced by MakeXmlSource(string, string, bool). Stateless — no fields to deserialise. public SiemensNamedVariableLookup(XElement src) Parameters src XElement Properties XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Get(string, LazyLinkedListNode<SyntaxPiece>, IReadOnlyList<INcDependency>) Returns the value of the variable identified by key in the context of node and dependencies, or null if the key is outside this lookup's range or the value is vacant. public double? Get(string key, LazyLinkedListNode<SyntaxPiece> node, IReadOnlyList<INcDependency> dependencies) Parameters key string node LazyLinkedListNode<SyntaxPiece> dependencies IReadOnlyList<INcDependency> Returns double? MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensNamedVariableReadingSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensNamedVariableReadingSyntax.html",
    "title": "Class SiemensNamedVariableReadingSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensNamedVariableReadingSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Siemens Assembly HiMech.dll Obtains values for Sinumerik named program variables (GUD/LUD identifiers such as _X_HOME, declared via DEF REAL or assigned directly). Reads literal numeric assignments from Parsing.Assignments.<ident>, dict-merges them with the previous block's state, and writes the resulting per-block dictionary into Vars.Named — the same carry-forward pattern as the Fanuc VolatileVariableReadingSyntax. Lifetime is bounded by MachiningSession: within one session the dictionary carries forward block-by-block; session restart abandons the SyntaxPiece JSON dataflow and starts fresh. This matches LUD scoping well (program-local) and under-persists real GUD (globally retentive) — acceptable until a GUD definition-file feature exists. Only literal numeric RHS values are consumed (_X_HOME = 155.5 ✓; _A = R1+5 ✗ — the evaluator resolves those to literals earlier on the same block). String-valued RHS (quoted) never reaches Assignments — the quote-guard syntaxes quarantine it in the Parsing bundle. public class SiemensNamedVariableReadingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensNamedVariableReadingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild: { \"Parsing\": { \"Assignments\": { \"_X_HOME\": \"155.5\" } } } #AfterBuild: { \"Vars\": { \"Named\": { \"_X_HOME\": 155.5 } } } Constructors SiemensNamedVariableReadingSyntax() Default constructor. public SiemensNamedVariableReadingSyntax() SiemensNamedVariableReadingSyntax(XElement) Loads from an XML element produced by MakeXmlSource(string, string, bool). No state to deserialise. public SiemensNamedVariableReadingSyntax(XElement src) Parameters src XElement Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensRParameterReadingSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensRParameterReadingSyntax.html",
    "title": "Class SiemensRParameterReadingSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensRParameterReadingSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Siemens Assembly HiMech.dll Obtains values for Sinumerik R parameters (R0-R999) by consuming literal numeric assignments from Parsing.Assignments.Rn and writing them straight to a registered SiemensRParameterTable. Sibling of the Fanuc RetainedCommonVariableReadingSyntax. No SyntaxPiece JSON mirror is created — the table is the single source of truth for R values, and VariableEvaluatorSyntax reads from the table directly (the table implements IVariableLookup). The hincproj round-trip preserves writes across project sessions. Only literal numeric RHS values are consumed by this syntax (R63 = 100.5 ✓; R26 = R64-14/2 ✗). Non-literal RHS entries are left untouched in Parsing.Assignments; VariableEvaluatorSyntax resolves them to literals earlier on the same block, so by the time this syntax runs, every evaluable RHS is literal. The two syntaxes are decoupled. If no SiemensRParameterTable is registered on the runner's effective NcDependencyList, this syntax is a no-op. public class SiemensRParameterReadingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensRParameterReadingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild: (with a SiemensRParameterTable on the dependency list; the literal moves into the table) { \"Parsing\": { \"Assignments\": { \"R63\": \"100.5\" } } } #AfterBuild: {} Constructors SiemensRParameterReadingSyntax() Default constructor. public SiemensRParameterReadingSyntax() SiemensRParameterReadingSyntax(XElement) Loads from an XML element produced by MakeXmlSource(string, string, bool). No state to deserialise. public SiemensRParameterReadingSyntax(XElement src) Parameters src XElement Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensRepeatSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensRepeatSyntax.html",
    "title": "Class SiemensRepeatSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensRepeatSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Siemens Assembly HiMech.dll Executes the Siemens REPEAT StartLabel EndLabel [P=n] section repeat: the host file is re-segmented from the top, the [StartLabel: … EndLabel:) slice is cut out (start-label line included — it may carry trailing code; end-label line excluded), and the slice is prepended into layers[0] once per repetition via PrependSource(IEnumerable<T>). “Return to the line after REPEAT” is the natural pipeline tail — the M98-inline pattern — so no return frame or rewind is needed (Siemens end labels are passive, unlike Fanuc's END m which actively fires a syntax). Label scanning reuses LabelScanUtil's predicate overload with a Siemens probe stack (TailCommentSyntax + HeadIndexSyntax + SiemensLabelSyntax) and matches on the block-root SiemensLabel record. Each repetition is its own segmentation pass with a fresh fileIndex — downstream syntaxes mutate block JSON in place, so repetitions must not share piece instances. Every inlined block is stamped with a SiemensRepeat clone carrying its 1-based Iteration. Fail-soft paths (consume + structured warning + no motion): missing end label in the statement (single-label form — corpus count zero, not simulated), start/end label not found in the file, a slice that contains the REPEAT line itself (would re-fire forever — real Sinumerik programs place REPEAT after the end label), and missing runtime dependencies. The repetition count is known eagerly, so no iteration watchdog is needed. public class SiemensRepeatSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensRepeatSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SiemensRepeatSyntax() Parameterless instance (no XML state). public SiemensRepeatSyntax() SiemensRepeatSyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public SiemensRepeatSyntax(XElement src) Parameters src XElement Root element named XName. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensSubProgramCallSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensSubProgramCallSyntax.html",
    "title": "Class SiemensSubProgramCallSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensSubProgramCallSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Siemens Assembly HiMech.dll Consumes the Parsing.SiemensCall sub-object captured by SiemensCallStatementSyntax and either inlines the called subprogram or safe-skips the call: Resolved — the callee file (looked up through InternalFolder with the FilePatterns chain, default {name}.SPF → {name}.MPF → {name}) is segmented and prepended into layers[0] — the SubProgramCallSyntax (M98) mechanism verbatim, including the P-times repetition loop, per-repetition file indices, and a pushed CallStack frame that SiemensSubProgramReturnSyntax pops on M17/RET. Like M98 (and unlike G65), no MacroFrame is stamped — callee blocks share the caller's variable scope; DEF-local isolation is a later work item. Unresolved — the corpus norm: OEM / measuring cycles (HQ_FC, Renishaw L9810, L_ZYM91) whose definition files ship with the machine, not the NC program. The call is consumed whole with a block-root SiemensCall record (Skipped: true) and a single structured SiemensCall--Skipped warning — motion state untouched, replacing the raw UnparsedText--Remaining noise. Pipeline placement: head of the Siemens Evaluation bundle (the Fanuc discipline — call/inline ahead of all variable and motion machinery). Argument binding to PROC parameters is not implemented: a resolved call carrying arguments emits SiemensCall--ArgsNotBound and inlines without bindings. public class SiemensSubProgramCallSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensSubProgramCallSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SiemensSubProgramCallSyntax() Parameterless instance with default settings. public SiemensSubProgramCallSyntax() SiemensSubProgramCallSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public SiemensSubProgramCallSyntax(XElement src) Parameters src XElement Source XML element. Fields DefaultMaxCallDepth Default for MaxCallDepth. Sinumerik itself caps program levels far lower (16 on 840D); 32 leaves headroom for exotic post output while still catching recursion promptly. public const int DefaultMaxCallDepth = 32 Field Value int Properties FilePatterns Filename-resolution fallback chain, formatted with the callee name as the only positional arg. Default mirrors Sinumerik conventions: .SPF subprogram, .MPF main-program-as-subprogram, bare name. Case-insensitive match is delegated to the host filesystem (Windows is, Linux is not). public List<string> FilePatterns { get; set; } Property Value List<string> MaxCallDepth Recursion rail: a self- or mutually-recursive callee re-captures its own call statement inside every inlined body and would splice forever (no iteration watchdog covers the call path). A call whose host block already carries this many CallStack frames is consumed as a structured safe-skip with SiemensCall–DepthLimitExceeded instead of inlining. public int MaxCallDepth { get; set; } Property Value int Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensSubProgramReturnSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensSubProgramReturnSyntax.html",
    "title": "Class SiemensSubProgramReturnSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensSubProgramReturnSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Siemens Assembly HiMech.dll Consumes Siemens subprogram-end words — M17 (subprogram end) and RET (return without function output) — and pops one CallStack frame. Like the plain-M99 half of SubProgramReturnSyntax, the actual “return” is the natural pipeline tail: the inlined body's last block is followed in layers[0] by the caller's next block, so this syntax only consumes the trigger (keeping UnconsumedCheckSyntax quiet), stamps a SubProgramReturn section, and writes the popped stack. M17 in the main frame (no caller) is the norm in practice — post-processors commonly end a main .MPF with M17 — and is consumed silently with no pop and no warning, mirroring how a plain M99 tolerates the main frame. Sinumerik's M17 has no P-jump form, so there is no redirect path here. Triggers: M17 arrives in Parsing.Flags via NumberedFlagSyntax; RET via the FlagSyntax word table. Known limitation — early return. Because the return is the natural pipeline tail, an M17/RET in the middle of a body (e.g. inside an IF branch) pops the frame but does not truncate the remaining inlined blocks — they still execute. Honoring a mid-body return needs body-boundary bookkeeping (a future work item alongside PROC parameter binding); the corpus places every return at the body end. public class SiemensSubProgramReturnSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensSubProgramReturnSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SiemensSubProgramReturnSyntax() Parameterless instance (no XML state). public SiemensSubProgramReturnSyntax() SiemensSubProgramReturnSyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public SiemensSubProgramReturnSyntax(XElement src) Parameters src XElement Root element named XName. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensSystemVariableSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensSystemVariableSyntax.html",
    "title": "Class SiemensSystemVariableSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensSystemVariableSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Siemens Assembly HiMech.dll Consumes writes to Sinumerik $ system variables the pipeline does not simulate ($TC_DP… handled elsewhere aside, e.g. $AC_TIME, $SC_…, non-TR $P_UIFR components). Siemens counterpart of the Fanuc record-only FanucSystemControlVariableSyntax pattern: public class SiemensSystemVariableSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensSystemVariableSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild: { \"Parsing\": { \"Assignments\": { \"$SC_PA_ACTIV_IMMED\": \"1\" } } } #AfterBuild: { \"Vars\": { \"SystemNamed\": { \"$SC_PA_ACTIV_IMMED\": 1 } } } Remarks records the literal write on the block JSON under Vars.SystemNamed (round-trip and cache-dump visibility), carried forward block-by-block; emits a SiemensSystemVariable--Unsupported UnsupportedMessage(ISentenceCarrier, string, string, object) so the user knows the assignment was recognised but its controller-side effect is not simulated (Message severity — safe no-op offline); removes the entry from Parsing.Assignments so it does not re-surface as a generic Parsing--Unconsumed diagnostic. MUST run after SiemensUifrWritingSyntax — this syntax is the $-catchall; the UIFR bridge owns the simulated subset. Only literal numeric RHS values are consumed; non-literal RHS is left for VariableEvaluatorSyntax. Constructors SiemensSystemVariableSyntax() Default constructor. public SiemensSystemVariableSyntax() SiemensSystemVariableSyntax(XElement) Loads from an XML element produced by MakeXmlSource(string, string, bool). No state to deserialise. public SiemensSystemVariableSyntax(XElement src) Parameters src XElement Fields UnsupportedDiagId Diagnostic id emitted for every consumed unsimulated $ assignment — recognised by the parser, ignored by simulation. public const string UnsupportedDiagId = \"SiemensSystemVariable--Unsupported\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensUifrVariableLookup.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensUifrVariableLookup.html",
    "title": "Class SiemensUifrVariableLookup | HiAPI-C# 2025",
    "summary": "Class SiemensUifrVariableLookup Namespace Hi.NcParsers.EvaluationSyntaxs.Siemens Assembly HiMech.dll Reads Sinumerik settable-frame translations (R100=$P_UIFR[1,X,TR]) from the SiemensFrameTable on the runner's effective dependency list. Self-gates on the $P_UIFR[n,axis,TR] key shape so the evaluator's RuntimeVariableLookups chain can fall through for other keys (non-TR components fall to the record-only SiemensSystemVariableSyntax path as unevaluable reads). State-from-deps flavour: the table is resolved from the call's dependencies list on every call — never held as a field — so the lookup survives XML round-trip without a rebind path (the wrapper anti-pattern ban on IRuntimeVariableLookup). public class SiemensUifrVariableLookup : IRuntimeVariableLookup, IMakeXmlSource Inheritance object SiemensUifrVariableLookup Implements IRuntimeVariableLookup IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SiemensUifrVariableLookup() Default constructor. public SiemensUifrVariableLookup() SiemensUifrVariableLookup(XElement) Loads from an XML element produced by MakeXmlSource(string, string, bool). Stateless — no fields to deserialise. public SiemensUifrVariableLookup(XElement src) Parameters src XElement Properties XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Get(string, LazyLinkedListNode<SyntaxPiece>, IReadOnlyList<INcDependency>) Returns the value of the variable identified by key in the context of node and dependencies, or null if the key is outside this lookup's range or the value is vacant. public double? Get(string key, LazyLinkedListNode<SyntaxPiece> node, IReadOnlyList<INcDependency> dependencies) Parameters key string node LazyLinkedListNode<SyntaxPiece> dependencies IReadOnlyList<INcDependency> Returns double? MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensUifrWritingSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.SiemensUifrWritingSyntax.html",
    "title": "Class SiemensUifrWritingSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensUifrWritingSyntax Namespace Hi.NcParsers.EvaluationSyntaxs.Siemens Assembly HiMech.dll Consumes Sinumerik settable-frame translation writes ($P_UIFR[5,Z,TR]=R102-281.48, probing programs' workpiece re-referencing idiom) by routing literal numeric assignments from Parsing.Assignments into the SiemensFrameTable on the runner's effective dependency list — the write is thereby fully simulated: a subsequent G54/G505+ selection reads the updated offset through the existing CoordinateOffset path (X/Y/Z), and $P_UIFR reads see it via SiemensUifrVariableLookup. Only literal numeric RHS values are consumed; VariableEvaluatorSyntax normalizes expression RHS to literals earlier on the same block. Only the TR component is bridged — other components (RT, FI) stay in Assignments and fall to the record-only SiemensSystemVariableSyntax, which must run after this syntax. Writes to $P_UIFR[0,..] (G500) are consumed but ignored, matching SetAxisOffset(string, string, double). If no SiemensFrameTable is registered, this syntax is a no-op (entries stay visible as unconsumed residue). public class SiemensUifrWritingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensUifrWritingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild: { \"Parsing\": { \"Assignments\": { \"$P_UIFR[5,Z,TR]\": \"-281.48\" } } } #AfterBuild: { } Constructors SiemensUifrWritingSyntax() Default constructor. public SiemensUifrWritingSyntax() SiemensUifrWritingSyntax(XElement) Loads from an XML element produced by MakeXmlSource(string, string, bool). No state to deserialise. public SiemensUifrWritingSyntax(XElement src) Parameters src XElement Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.Siemens.html",
    "title": "Namespace Hi.NcParsers.EvaluationSyntaxs.Siemens | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.EvaluationSyntaxs.Siemens Classes SiemensAcIcSyntax Recognizes the Siemens per-word coordinate function family on axis words — AC(...) (absolute), IC(...) (incremental), DC(...) (rotary shortest-path), ACP(...) / ACN(...) (rotary directional approach), and the coded-position (indexing axis) counterparts CAC(...) / CIC(...) / CDC(...) / CACP(...) / CACN(...) — e.g. X=AC(400), C=IC(360/17), C=DC(47.296), B=CAC(2) — unwraps the inner expression so the downstream VariableEvaluatorSyntax resolves it through the normal Siemens expression machinery, and records the per-word positioning override in a block-root PositioningOverride section keyed by word name (Absolute / Incremental / Shortest / PositiveOnly / NegativeOnly, and the Coded* values for the coded-position verbs). Siemens semantics: the wrapper forces the interpretation of that one coordinate word for that one block, regardless of the modal G90/G91 state. The positional conversion itself stays with the same consumers that honor the modal state — IncrementalResolveSyntax for linear axes and McAbcSyntax for rotary axes (both treat every non-Incremental override as an absolute write), while the rotary shortest/directional resolution stays with the McAbcCyclicPathSyntax tail-pass — this syntax only normalizes the text and stamps the override; it never reads machine position (the Evaluation stage is not the place for position-state reads). Scope: axis words (per AxisNames, falling back to X/Y/Z/A/B/C) accept the full family, except that the rotary-only verbs DC/ACP/ACN are unwrapped only on rotary axes (per IsRotaryAxis(string), falling back to A/B/C) — on a linear axis they are invalid Siemens and are left untouched so they surface as unevaluated residue instead of being silently mis-read. The interpolation parameters I/J/K accept AC/IC only (Siemens circle centers are incremental by default; I=AC(...) switches that one component to an absolute center coordinate, consumed by SiemensCircularMotionSyntax) — the rotary verbs are meaningless there and are left untouched. The coded-position verbs (their argument is a 1-based indexing position number, not a coordinate) are unwrapped only on axes that IsIndexingAxis(string) reports as usable indexing axes — CDC/CACP/CACN additionally require the axis to be rotary. Everywhere else (a non-indexing axis, no indexing config on the list, I/J/K) they stay untouched, mirroring the Siemens alarm 17500 (\"axis is not an indexing axis\") with loud unevaluated residue. The number→coordinate lookup happens at the write stage (McAbcSyntax / IncrementalResolveSyntax via CodedPositionUtil), not here — the Evaluation stage neither reads machine position nor resolves tables. Positioning-axis forms (POS[C]=DC(...) / SPOS=) never reach the word path and are out of scope. Values whose parentheses do not balance around the wrapper (e.g. IC(1)+AC(2)) are also left untouched. Must be placed in the Evaluation bundle before VariableEvaluatorSyntax (the unwrapped inner text is a plain Siemens expression the evaluator numeric-ifies on the same block). Inside REPEAT / subprogram splices each re-fed piece runs the full bundle again, so the unwrap happens on every iteration. SiemensExpressionParser Recursive-descent parser for Sinumerik value expressions. Produces the same NcExpr AST as the Fanuc NcExpressionParser so NcExpressionEvaluator is reused unchanged. Pure: no variable lookup, no evaluation. Grammar (lowest precedence at top): expr := or-expr or-expr := and-expr (('OR' | 'XOR') and-expr)* and-expr := cmp-expr ('AND' cmp-expr)* cmp-expr := add-expr (('==' | '<>' | '>=' | '<=' | '>' | '<') add-expr)* add-expr := term (('+' | '-') term)* term := factor (('*' | '/' | 'MOD') factor)* factor := ('+' | '-')? primary primary := number | '(' expr ')' | 'R' digits → variable \"R63\" (canonical uppercase) | '$' name ('[' indexlist ']')? → variable \"$P_UIFR[1,X,TR]\" (canonical) | name '(' arglist ')' → function call | name '[' indexlist ']' → variable \"_RENC[35]\" (canonical) | name → variable \"_X_HOME\" (case preserved) indexlist := (integer | name) (',' (integer | name))* arglist := expr (',' expr)* Dialect differences from the Fanuc parser: parentheses group and call (Fanuc uses brackets); comparisons are spelled == <> >= <= > < (Fanuc uses EQ NE .. words); bare identifiers are named-variable references (Fanuc rejects an identifier without [); R63 is canonicalised to uppercase so table lookups and Parsing.Assignments keys agree. Indexed accesses ($P_UIFR[1,X,TR], _RENC[35]) require literal index elements (integers, bare letters, or keywords like TR) and are emitted as a single NcVariableExpr whose key is the canonical uppercase-indexed token — the whole token routes through Get(string), keeping the AST brand-agnostic. Function-name aliases are normalised where Sinumerik and the shared evaluator spell the same math differently: ATAN2 → ATAN (both are two-arg atan2 in degrees), TRUNC → FIX (truncate toward zero). Unknown functions (e.g. the rotary positioning form DC(...)) parse fine and fail later in the evaluator, which callers treat as fail-soft. SiemensGotoSyntax Resolves Siemens GOTOF/GOTOB control flow — the FanucGotoSyntax pattern with named-label targets and explicit direction. Triggered by Parsing.SiemensGoto (written by SiemensGotoParsingSyntax); decides whether to fire, and on fire calls ReplaceSource(IEnumerable<T>) on layers[0] with the re-segmented file content starting at the target label line (inclusive — a Siemens label may prefix code). Direction comes from the mnemonic and drives the anchored LabelScanUtil overload: GOTOF takes the first match strictly below the host line, GOTOB the nearest match strictly above it — never the whole-file first match, which would silently mis-target duplicate label texts. Targets may be a named label (LBL1: line, matched Ordinal-exact on the block-root SiemensLabel record) or an N<num> block number (matched on Number). The conditional forms (IF <cond> GOTOF <label>) lean on VariableEvaluatorSyntax's pass-2 tree walk; ReadCondition(JsonNode) (a dialect-neutral numeric-JSON reader despite its home) reads the resolved node. Truthy fires; zero falls through silently; unresolved warns SiemensGoto--ConditionNotEvaluated and falls through. Because the label field is an ordinary Parsing string, a label name that collides with a set named variable may have been substituted to a numeric by the evaluator — the original text is then recovered from the Formula.SiemensGoto.Label mirror. Pipeline placement: Evaluation bundle, in the control-flow group after VariableEvaluatorSyntax. The SiemensGotoIterationDependency watchdog caps fired jumps per (file, label); a missing watchdog disables the cap (Fanuc parity). SiemensIfSyntax Resolves the Siemens IF ... [ELSE ...] ENDIF block conditional. Three phrases dispatched by Term, none of which needs a frame stack: IF — reads the resolved condition via FanucConditionReader (dialect-neutral numeric-JSON reader). True falls through into the then-branch; false forward-jumps to just after the matching ELSE (else-branch executes) or after the matching ENDIF when no else exists; unresolved warns SiemensIf--ConditionNotEvaluated and falls through (no redirect on unresolved input — the then-branch executes, and the ELSE rule below then skips the else-branch, which keeps the two branches mutually exclusive even on the fail-soft path). ELSE — reached in the normal stream only when the then-branch just executed (a false IF jumps past the ELSE line directly), so it unconditionally forward-jumps past the matching ENDIF. ENDIF — consumed no-op (stamped for cache dumps). Both forward scans run on the anchored LabelScanUtil overload from the host line, with a nesting-depth predicate: each nested block-IF increments the depth, each ENDIF at depth > 0 decrements it, and the match fires only at depth 0. The probe stack replays the Parsing statement owners the depth counter depends on — including SiemensGotoParsingSyntax ahead of SiemensIfParsingSyntax, so a nested single-line IF cond GOTOF lbl is claimed by the GOTO owner and never miscounted as a block-IF. Pipeline placement: Evaluation bundle control-flow group, after VariableEvaluatorSyntax (condition substituted) and before the variable readers. SiemensInlineContextUtil Detects whether a block executes inside a P4 inlined body — an L/name-call subprogram splice or a REPEAT label section repetition. Both are PrependSource inlines whose “return to the caller / to the line after REPEAT” is the natural pipeline tail; the P5 control-flow redirects (ReplaceSource with a re-segmented host-file slice) would silently discard that pending tail — and, for a section repeat, re-execute the REPEAT statement itself, which has no watchdog (its count is eagerly known) and therefore no bound. The P5 jump syntaxes consult this guard and degrade to a structured warning + fall-through instead: control flow inside an inlined body is recognized but not simulated (corpus count zero; true support needs return-frame machinery, a future work item). Subprogram context: the call syntax stamps a pushed CallStack on every inlined piece — any frame on the stack marks callee context. Section-repeat context: SiemensRepeatSyntax stamps every inlined piece with a SiemensRepeat clone carrying a 1-based Iteration; the REPEAT host block itself never carries that field. SiemensLoopSyntax Resolves the four Siemens loop constructs against one shared frame stack — WHILE ... ENDWHILE, FOR ... ENDFOR, REPEAT ... UNTIL (the label-less post-test loop) and LOOP ... ENDLOOP — the FanucWhileDoSyntax template (frames-in-JSON + ModalCarry tracked key + forward scan to the terminator + back-jump to the recorded entry line), adapted to constructs that carry no LoopId: frames stack in nesting order on the block-root SiemensLoopFrames section, and every terminator validates that the innermost frame carries its own construct Kind and file. A single shared stack is what makes mixed-construct nesting (a FOR inside a WHILE inside a LOOP) pair correctly. WHILE — pre-test: truthy pushes a frame (first arrival) and falls through; falsy/unresolved pops its own frame and forward-jumps past the matching ENDWHILE (depth-counted). ENDWHILE back-jumps unconditionally; the WHILE line re-evaluates. FOR — counting: first arrival resolves the bounds once (Sinumerik semantics), assigns the loop variable by lifting into Parsing.Assignments (the reader syntaxes downstream persist it exactly as a written assignment), and pushes a frame carrying Var/End/Value; each re-arrival increments Value until it exceeds End, then pops and jumps past ENDFOR. REPEAT/UNTIL — post-test: REPEAT pushes and always falls through; UNTIL exits on truthy (pop), warns and exits on unresolved, back-jumps to the REPEAT line on falsy. LOOP/ENDLOOP — endless: ENDLOOP back-jumps while the SiemensLoopIterationDependency watchdog allows; the watchdog is a hard requirement here (no exit condition exists), so a missing dependency suppresses the jump with a configuration error instead of hanging the pipeline. Back-jump counting happens at the back-jump step only (a loop whose condition is false from the outset consumes zero iterations), keyed (FileName, BeginLineNo) on the watchdog. All scans use the anchored LabelScanUtil overload from the host line — never the whole-file first match, which would pair a terminator with an earlier sibling construct of the same kind. Pipeline placement: Evaluation bundle control-flow group, after VariableEvaluatorSyntax (conditions and bounds substituted) and before the variable readers (the FOR lift must reach them on the same block). Known limitation — stack pairing vs lexical pairing. Real Sinumerik pairs loop constructs lexically at block preparation; this syntax pairs them dynamically on the carried frame stack. A GOTOF/GOTOB that leaves a loop body strands that loop's frame (only the FOR head detects and drops a stale frame, via AdvancePending), so a jump from an inner loop into an enclosing loop's body can mispair the enclosing terminator with the stale inner frame. Sinumerik itself forbids jumping into control structures; all such shapes stay bounded here by the watchdog and surface loud diagnostics. Scan probes also mirror the Fanuc convention of not replaying BlockSkipSyntax — a /-prefixed terminator is invisible to the exit scans. SiemensNamedVariableLookup Reads Sinumerik named program variables (_X_HOME) from Vars.Named. Self-gates on the named-identifier key shape so the evaluator's RuntimeVariableLookups chain can fall through for other keys. Sibling of the Fanuc VolatileVariableLookup with the same single-step traceback: SiemensNamedVariableReadingSyntax dict-merges every block's Vars.Named into the next block, so the entry — if it exists — is on the current block or the immediately previous one. Stateless and dependency-free — instances are interchangeable. SiemensNamedVariableReadingSyntax Obtains values for Sinumerik named program variables (GUD/LUD identifiers such as _X_HOME, declared via DEF REAL or assigned directly). Reads literal numeric assignments from Parsing.Assignments.<ident>, dict-merges them with the previous block's state, and writes the resulting per-block dictionary into Vars.Named — the same carry-forward pattern as the Fanuc VolatileVariableReadingSyntax. Lifetime is bounded by MachiningSession: within one session the dictionary carries forward block-by-block; session restart abandons the SyntaxPiece JSON dataflow and starts fresh. This matches LUD scoping well (program-local) and under-persists real GUD (globally retentive) — acceptable until a GUD definition-file feature exists. Only literal numeric RHS values are consumed (_X_HOME = 155.5 ✓; _A = R1+5 ✗ — the evaluator resolves those to literals earlier on the same block). String-valued RHS (quoted) never reaches Assignments — the quote-guard syntaxes quarantine it in the Parsing bundle. SiemensRParameterReadingSyntax Obtains values for Sinumerik R parameters (R0-R999) by consuming literal numeric assignments from Parsing.Assignments.Rn and writing them straight to a registered SiemensRParameterTable. Sibling of the Fanuc RetainedCommonVariableReadingSyntax. No SyntaxPiece JSON mirror is created — the table is the single source of truth for R values, and VariableEvaluatorSyntax reads from the table directly (the table implements IVariableLookup). The hincproj round-trip preserves writes across project sessions. Only literal numeric RHS values are consumed by this syntax (R63 = 100.5 ✓; R26 = R64-14/2 ✗). Non-literal RHS entries are left untouched in Parsing.Assignments; VariableEvaluatorSyntax resolves them to literals earlier on the same block, so by the time this syntax runs, every evaluable RHS is literal. The two syntaxes are decoupled. If no SiemensRParameterTable is registered on the runner's effective NcDependencyList, this syntax is a no-op. SiemensRepeatSyntax Executes the Siemens REPEAT StartLabel EndLabel [P=n] section repeat: the host file is re-segmented from the top, the [StartLabel: … EndLabel:) slice is cut out (start-label line included — it may carry trailing code; end-label line excluded), and the slice is prepended into layers[0] once per repetition via PrependSource(IEnumerable<T>). “Return to the line after REPEAT” is the natural pipeline tail — the M98-inline pattern — so no return frame or rewind is needed (Siemens end labels are passive, unlike Fanuc's END m which actively fires a syntax). Label scanning reuses LabelScanUtil's predicate overload with a Siemens probe stack (TailCommentSyntax + HeadIndexSyntax + SiemensLabelSyntax) and matches on the block-root SiemensLabel record. Each repetition is its own segmentation pass with a fresh fileIndex — downstream syntaxes mutate block JSON in place, so repetitions must not share piece instances. Every inlined block is stamped with a SiemensRepeat clone carrying its 1-based Iteration. Fail-soft paths (consume + structured warning + no motion): missing end label in the statement (single-label form — corpus count zero, not simulated), start/end label not found in the file, a slice that contains the REPEAT line itself (would re-fire forever — real Sinumerik programs place REPEAT after the end label), and missing runtime dependencies. The repetition count is known eagerly, so no iteration watchdog is needed. SiemensSubProgramCallSyntax Consumes the Parsing.SiemensCall sub-object captured by SiemensCallStatementSyntax and either inlines the called subprogram or safe-skips the call: Resolved — the callee file (looked up through InternalFolder with the FilePatterns chain, default {name}.SPF → {name}.MPF → {name}) is segmented and prepended into layers[0] — the SubProgramCallSyntax (M98) mechanism verbatim, including the P-times repetition loop, per-repetition file indices, and a pushed CallStack frame that SiemensSubProgramReturnSyntax pops on M17/RET. Like M98 (and unlike G65), no MacroFrame is stamped — callee blocks share the caller's variable scope; DEF-local isolation is a later work item. Unresolved — the corpus norm: OEM / measuring cycles (HQ_FC, Renishaw L9810, L_ZYM91) whose definition files ship with the machine, not the NC program. The call is consumed whole with a block-root SiemensCall record (Skipped: true) and a single structured SiemensCall--Skipped warning — motion state untouched, replacing the raw UnparsedText--Remaining noise. Pipeline placement: head of the Siemens Evaluation bundle (the Fanuc discipline — call/inline ahead of all variable and motion machinery). Argument binding to PROC parameters is not implemented: a resolved call carrying arguments emits SiemensCall--ArgsNotBound and inlines without bindings. SiemensSubProgramReturnSyntax Consumes Siemens subprogram-end words — M17 (subprogram end) and RET (return without function output) — and pops one CallStack frame. Like the plain-M99 half of SubProgramReturnSyntax, the actual “return” is the natural pipeline tail: the inlined body's last block is followed in layers[0] by the caller's next block, so this syntax only consumes the trigger (keeping UnconsumedCheckSyntax quiet), stamps a SubProgramReturn section, and writes the popped stack. M17 in the main frame (no caller) is the norm in practice — post-processors commonly end a main .MPF with M17 — and is consumed silently with no pop and no warning, mirroring how a plain M99 tolerates the main frame. Sinumerik's M17 has no P-jump form, so there is no redirect path here. Triggers: M17 arrives in Parsing.Flags via NumberedFlagSyntax; RET via the FlagSyntax word table. Known limitation — early return. Because the return is the natural pipeline tail, an M17/RET in the middle of a body (e.g. inside an IF branch) pops the frame but does not truncate the remaining inlined blocks — they still execute. Honoring a mid-body return needs body-boundary bookkeeping (a future work item alongside PROC parameter binding); the corpus places every return at the body end. SiemensSystemVariableSyntax Consumes writes to Sinumerik $ system variables the pipeline does not simulate ($TC_DP… handled elsewhere aside, e.g. $AC_TIME, $SC_…, non-TR $P_UIFR components). Siemens counterpart of the Fanuc record-only FanucSystemControlVariableSyntax pattern: SiemensUifrVariableLookup Reads Sinumerik settable-frame translations (R100=$P_UIFR[1,X,TR]) from the SiemensFrameTable on the runner's effective dependency list. Self-gates on the $P_UIFR[n,axis,TR] key shape so the evaluator's RuntimeVariableLookups chain can fall through for other keys (non-TR components fall to the record-only SiemensSystemVariableSyntax path as unevaluable reads). State-from-deps flavour: the table is resolved from the call's dependencies list on every call — never held as a field — so the lookup survives XML round-trip without a rebind path (the wrapper anti-pattern ban on IRuntimeVariableLookup). SiemensUifrWritingSyntax Consumes Sinumerik settable-frame translation writes ($P_UIFR[5,Z,TR]=R102-281.48, probing programs' workpiece re-referencing idiom) by routing literal numeric assignments from Parsing.Assignments into the SiemensFrameTable on the runner's effective dependency list — the write is thereby fully simulated: a subsequent G54/G505+ selection reads the updated offset through the existing CoordinateOffset path (X/Y/Z), and $P_UIFR reads see it via SiemensUifrVariableLookup. Only literal numeric RHS values are consumed; VariableEvaluatorSyntax normalizes expression RHS to literals earlier on the same block. Only the TR component is bridged — other components (RT, FI) stay in Assignments and fall to the record-only SiemensSystemVariableSyntax, which must run after this syntax. Writes to $P_UIFR[0,..] (G500) are consumed but ignored, matching SetAxisOffset(string, string, double). If no SiemensFrameTable is registered, this syntax is a no-op (entries stay visible as unconsumed residue)."
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.SubProgramCallSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.SubProgramCallSyntax.html",
    "title": "Class SubProgramCallSyntax | HiAPI-C# 2025",
    "summary": "Class SubProgramCallSyntax Namespace Hi.NcParsers.EvaluationSyntaxs Assembly HiMech.dll Inlines a Fanuc-style subprogram into the source layer when an M98 or M198 host block is reached. M98 P_ L_ reads the matching O<P> file from InternalFolder; M198 P_ reads from ExternalFolder (Fanuc external-storage call — same mechanism as M98, different lookup root). The file is segmented through the host runner's segmenter (SegmenterDependency) and the resulting SyntaxPieces are prepended into layers[0] via PrependSource(IEnumerable<T>); the rest of the pipeline picks them up through ordinary walkNode.Next traversal as if they had always been part of the host file. Pipeline placement: first child of the Fanuc Evaluation BundleSyntax. By the time this runs, M98Syntax / M198Syntax (each a ParameterizedFlagSyntax) have written a Parsing.M98 / Parsing.M198 sub-object carrying the captured P / L parameters. Note: those sub-objects are this syntax's only trigger — \"M98\" / \"M198\" never reach Parsing.Flags, because the parameterized match has already consumed the text by the time NumberedFlagSyntax runs. Filename lookup uses a fallback chain: O{P:D4}.NC, O{P}.NC, O{P:D4}, O{P}, {P:D4}.NC, {P}.NC — first match wins. Case-insensitive match is delegated to the host filesystem (Windows is, Linux is not). L > 1 inlines the same subprogram L times in series. Each repetition is a fresh segmentation pass so each block gets its own SyntaxPiece with an independent JSON object — the downstream pipeline mutates JSON in place and would clobber sibling repetitions if instances were shared. Not yet supported: M99 P{seq} early return inside a subprogram and partial-program calls (M98 P{seq}{prog} split encoding). Custom Macro B argument-binding calls (G65 / G66 / G67) live in FanucMacroCallSyntax and FanucModalMacroSyntax — those handle the argument-letter-to-#1..#26 binding and the macro-call frame isolation that M98 deliberately does not provide. public class SubProgramCallSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SubProgramCallSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SubProgramCallSyntax() Parameterless instance for bundle composition (no XML state). public SubProgramCallSyntax() SubProgramCallSyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public SubProgramCallSyntax(XElement src) Parameters src XElement Root element named XName. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.SubProgramReturnSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.SubProgramReturnSyntax.html",
    "title": "Class SubProgramReturnSyntax | HiAPI-C# 2025",
    "summary": "Class SubProgramReturnSyntax Namespace Hi.NcParsers.EvaluationSyntaxs Assembly HiMech.dll Consumes Fanuc-style M99 subprogram-return blocks and pops one CallStack frame. Plain M99 relies on the natural pipeline tail — the inlined body's last block is followed in layers[0] by the caller's next block, so the “return” happens implicitly; this syntax only consumes the M99 trigger (so UnconsumedCheckSyntax doesn't warn), stamps a SubProgramReturn diagnostic section, and writes the popped CallStack for downstream blocks to carry. M99 P{seq} additionally redirects control flow to the caller's N{seq} block via ReplaceSource(IEnumerable<T>). The caller's file is resolved from the popped frame's CallerFilePath; the scan uses the same LabelScanUtil.SegmentAndSkipUntilLabel helper as FanucGotoSyntax, with hardcoded Fanuc-default probes (QuoteCommentSyntax + HeadIndexSyntax with symbol \"N\") because the M99 P semantic itself is Fanuc-family-only and Mazak / Syntec follow the same conventions. The iteration is counted against FanucGotoIterationDependency, sharing the same runaway-loop guard as GOTO — keyed on the same (FileName, TargetN) bucket so a tight M98 → M99 P → M98 … loop trips the same threshold. Pipeline placement: same Evaluation bundle slot it always occupied, right after SubProgramCallSyntax at the head. Needs FanucGotoIterationDependency, ProjectFolderDependency, SegmenterDependency, SyntaxPieceLayerDependency, FileIndexCounterDependency on the dep list when M99 P{seq} is to fire; without them the plain-M99 path still works and the P-jump emits a configuration warning. Detection is on the Parsing.M99 sub-object written by M99Syntax (a ParameterizedFlagSyntax) — the keyword \"M99\" never reaches Parsing.Flags because the parameterized match has already consumed the text by the time NumberedFlagSyntax runs. public class SubProgramReturnSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SubProgramReturnSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SubProgramReturnSyntax() Parameterless instance with default probe list. public SubProgramReturnSyntax() SubProgramReturnSyntax(XElement, string, IProgress<IMessage>) Loads LabelProbeSyntaxes from XML produced by MakeXmlSource(string, string, bool). An absent wrapper falls back to the default probe list. public SubProgramReturnSyntax(XElement src, string baseDirectory, IProgress<IMessage> progress) Parameters src XElement Root element named XName. baseDirectory string Project base directory propagated to child XFactory calls. progress IProgress<IMessage> Diagnostic sink propagated to child factories. Properties LabelProbeSyntaxes Ordered list of probe syntaxes run on each candidate block during the M99 P{seq} caller-side scan, before the integer label predicate fires. Defaults match Fanuc / Mazak / Syntec (parenthesised comment stripper + N head-index parser); API customers can swap or extend (e.g. add a TailCommentSyntax for ; end-of-block comments, or insert a BlockSkipSyntax to exclude /-prefixed candidates) without subclassing. Mirrors the same hosted-list pattern as LabelProbeSyntaxes. public List<ISituNcSyntax> LabelProbeSyntaxes { get; set; } Property Value List<ISituNcSyntax> Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.VariableEvaluatorSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.VariableEvaluatorSyntax.html",
    "title": "Class VariableEvaluatorSyntax | HiAPI-C# 2025",
    "summary": "Class VariableEvaluatorSyntax Namespace Hi.NcParsers.EvaluationSyntaxs Assembly HiMech.dll Pure expression normalizer for Custom Macro B syntax. Walks the parser-stage residue on a single block and inlines numeric values wherever a Fanuc-style variable reference or bracket expression appears — but does not write to any specific store. Routing “where the resolved literal lands” stays in the brand-specific reader syntaxes (VolatileVariableReadingSyntax, RetainedCommonVariableTable's reader, FanucSystemControlVariableSyntax, …) which run after this syntax on the same block. Two passes per block: Assignments normalize — Parsing.Assignments.#nnn entries whose RHS is non-literal (e.g. \"#500+1\", \"SQRT[#100]\") are evaluated via the VariableEvaluatorSyntax.ChainLookup and the RHS string is replaced with the resolved literal (round-trip-safe \"R\"-format). The entry stays in Parsing.Assignments so downstream reader syntaxes consume it as a pure-literal assignment. Iteration follows source order (Parsing.Assignments insertion order). Parsing tree substitution — every string-typed value reachable from Parsing.<tag> (axis tags, canned-cycle sub-objects) is parsed; on a successful evaluation the string is replaced with a numeric JsonValue. Failures silently leave the original string and rely on downstream GetParsedDouble(JsonObject, string, ISentenceCarrier, NcDiagnosticProgress) at consumer sites to surface VariableExpression--Unevaluated only if the tag is actually read. Lookup chain (first non-null wins, configured per brand preset via RuntimeVariableLookups + IVariableLookup instances on NcDependencyList): Current block's own resolved assignments — built-in to VariableEvaluatorSyntax.ChainLookup; covers same-block forward references in source order (an earlier #nnn=literal is visible to a later RHS that mentions #nnn). Each IRuntimeVariableLookup in RuntimeVariableLookups, in list order. Typical contents for a Fanuc-family preset: LocalVariableLookup (#1-#33), VolatileVariableLookup (#100-#499), FanucPositionVariableLookup (#5001-#5043). Each IVariableLookup on the runner's NcDependencyList, in registration order (RetainedCommonVariableTable, FanucParameterTable, FanucToolOffsetVariableLookup). Each lookup self-gates its id range; the evaluator stays brand- and range-agnostic. Adding a new variable surface is additive: register an IVariableLookup on a dependency or push an IRuntimeVariableLookup onto the per-preset list. Same-block forward reference — when an Assignment RHS references a #nnn that is also being assigned later in the same block (i.e. listed in Parsing.Assignments after the RHS being evaluated), the VariableEvaluatorSyntax.ChainLookup cannot pick up the not-yet-resolved value and falls back to traceback / dependency-table reads — effectively the pre-block value. A VariableEvaluator--SameBlockForwardReference warning is emitted per such RHS so the user is told the source-order semantics were not honoured. Practical impact is near-zero for typical CAM-emitted NC (one assignment per line). Formula mirror tree — when either pass actually performs a non-trivial expression evaluation (i.e. the RHS / tag value was not already a pure literal and the evaluator returned a finite value), the original expression string is mirrored to a parallel Formula.<same path> entry at the root of the block JSON. The Parsing.* subtree carries the resolved value (R-format string for Assignments; numeric JsonValue for tags); the Formula.* subtree preserves the source-text expression for diagnostics, round-trip reconstruction, and downstream inspection. Pure-literal RHS values produce no Formula entry — the Parsing value is already the original text. In the tag pass the same holds for the Heidenhain dialect only (literal strings short-circuit there because klartext readers consume them as strings); Fanuc / Siemens literal-string tags are numeric-ified as they always were (int-typed capture fallbacks and constant conditions depend on it) and thus carry a Formula entry. Evaluation failures (parse error, vacant variable, non-finite result) produce no Formula entry — the original string is still in Parsing.* untouched, no preservation needed. public class VariableEvaluatorSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object VariableEvaluatorSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors VariableEvaluatorSyntax() Default constructor. public VariableEvaluatorSyntax() VariableEvaluatorSyntax(XElement) Loads from an XML element produced by MakeXmlSource(string, string, bool); restores RuntimeVariableLookups via XFactory dispatch. A missing <Dialect> element falls back to Fanuc (legacy files). public VariableEvaluatorSyntax(XElement src) Parameters src XElement Fields FormulaKey Top-level key under which the Formula mirror tree is written. public const string FormulaKey = \"Formula\" Field Value string Properties Dialect Expression grammar this evaluator parses with. Default Fanuc keeps the legacy behavior byte-identical (Custom Macro B #nnn + brackets); the Siemens preset sets Siemens for Rn/named/$ keys and parenthesised grammar. The evaluation machinery (lookup chain, Formula mirror, diagnostics) is dialect-independent — only tokenization routes through NcExpressionDialectUtil. public NcExpressionDialect Dialect { get; set; } Property Value NcExpressionDialect Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string RuntimeVariableLookups Per-preset list of context-sensitive lookups (block-local Vars.Local / Vars.Volatile, position reads, runtime-state reads). Walked in list order, before the dependency-bound IVariableLookups. Brand presets configure this; the list is XML-serialised so a runner rebuilt from XML keeps its brand-specific lookups (each impl is stateless and dispatches by its XName via XFactory). public List<IRuntimeVariableLookup> RuntimeVariableLookups { get; set; } Property Value List<IRuntimeVariableLookup> XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.VolatileVariableReadingSyntax.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.VolatileVariableReadingSyntax.html",
    "title": "Class VolatileVariableReadingSyntax | HiAPI-C# 2025",
    "summary": "Class VolatileVariableReadingSyntax Namespace Hi.NcParsers.EvaluationSyntaxs Assembly HiMech.dll Obtains values for Fanuc-style non-retained common variables (#100-#499). Reads literal numeric assignments from Parsing.Assignments.#nnn, dict-merges them with the previous block's volatile state, and writes the resulting per-block dictionary into Vars.Volatile. Lifetime is bounded by MachiningSession: within one session the dictionary carries forward block-by-block via this syntax; session restart abandons the SyntaxPiece JSON dataflow and starts fresh. Program-end (M02/M30) clearing is handled by ProgramEndCleanSyntax. Only literal numeric RHS values are consumed by this syntax (#124 = 15. ✓; #100 = #1 + 5 ✗). Non-literal RHS entries are left untouched in Parsing.Assignments; VariableEvaluatorSyntax resolves them and writes the result into the same per-block dictionary. The two syntaxes are decoupled — the evaluator's lookup tracebacks via SyntaxPiece linkage so it does not depend on having run before or after this syntax. public class VolatileVariableReadingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object VolatileVariableReadingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors VolatileVariableReadingSyntax() Default constructor. public VolatileVariableReadingSyntax() VolatileVariableReadingSyntax(XElement) Loads from an XML element produced by MakeXmlSource(string, string, bool). No state to deserialise. public VolatileVariableReadingSyntax(XElement src) Parameters src XElement Fields VolatileMax Inclusive upper bound of the non-retained common range (#499). public const int VolatileMax = 499 Field Value int VolatileMin Inclusive lower bound of the non-retained common range (#100). public const int VolatileMin = 100 Field Value int Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.EvaluationSyntaxs.html": {
    "href": "api/Hi.NcParsers.EvaluationSyntaxs.html",
    "title": "Namespace Hi.NcParsers.EvaluationSyntaxs | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.EvaluationSyntaxs Classes CallStackUtil Push / pop helpers for the per-block CallStack section. Both produce a fresh deep-cloned JsonObject ready to stamp onto an inlined piece (push site) or onto an M99 return block (pop site); the caller is responsible for deep-cloning again if it distributes the same stamp across multiple pieces of an L-repetition. Pairs with ModalCarrySyntax at the Logic stage: explicit push / pop writes seed the section at frame boundaries, ModalCarry copies it forward to every block in between so each block is self-contained for cache-dump readers and downstream consumers (notably M99 P{seq} reading the top frame's CallerFilePath). LabelScanUtil Shared “re-segment a file and skip pieces until a label matches” scan, used by both FanucGotoSyntax (unconditional GOTO redirect) and SubProgramReturnSyntax (M99 P{seq} jump into the caller file). Reads the file via ReadLines(int, string, string), segments through the provided ISegmenter, runs the caller-supplied probe syntaxes on each candidate block to extract IndexNote.Number, and returns the slice from the first matching block to EOF. Returns null when no block matches — the caller's responsibility to surface the appropriate diagnostic. The probes are idempotent because the downstream Parsing bundle re-runs the same syntaxes on the yielded pieces with no-op effect (the regex patterns no longer match once the N-prefix is consumed and the parenthesised comment stripped). MacroFileResolver Shared subprogram-/macro-file resolver for Fanuc-style O<n> lookups consumed by SubProgramCallSyntax (M98 / M198) and FanucMacroCallSyntax (G65). Single helper so the three path forms — file name, project-relative path, absolute path — are produced together at one site and each caller gets exactly the form it should consume: FileName — bare O####.NC form the resolver matched. Stored in JSON sections (FanucMacroCall, SubProgramCall) as the structural NC-language identifier; independent of which folder the dependency happened to be pointing at, so the JSON stays portable across environments. RelPath — relative path against the project base directory (e.g. \"NC/O1234.NC\"). Used as the IndexedFileLine label so diagnostics on inlined blocks align with the relative form already used for the main file label. AbsPath — absolute path. Used only at the ReadLines(int, string, string) call site for actual disk I/O; never persisted, never returned to JSON. Lives inside the resolver's stack frame and the segmenter's enumeration. Filename lookup order (first match wins) mirrors real Fanuc fallback: O{P:D4}.NC, O{P}.NC, O{P:D4}, O{P}, {P:D4}.NC, {P}.NC. Case-insensitive match is delegated to the host filesystem (Windows is, Linux is not). MacroInlineUtil Shared inline mechanism for Fanuc Custom Macro B body expansion — used by both FanucMacroCallSyntax (one-shot) and FanucModalMacroSyntax's expansion phase (modal trigger). Both callers do the same three things on every produced SyntaxPiece: stamp a FanucMacroCall clone, stamp a fresh MacroFrame id, and stamp argument bindings into Vars.Local. Centralising lets the two call sites stay in lock-step — frame allocation, file-index allocation, and the inline-piece JSON shape are guaranteed identical. Frame ids share the same FileIndexCounterDependency counter as file indices — both just need within-session uniqueness and the counter is rewound on session start in lock-step with the pipeline. The main NC file is allocated index 0 first, so all inline frame ids land at > 0 and never collide with main. RetainedCommonVariableReadingSyntax Obtains values for Fanuc-style retained common variables (#500-#999) by consuming literal numeric assignments from Parsing.Assignments.#nnn and writing them straight to a registered RetainedCommonVariableTable. No SyntaxPiece JSON mirror is created — the table is the single source of truth for retained values, and VariableEvaluatorSyntax reads from the table directly. The hincproj round-trip preserves writes across project sessions. Only literal numeric RHS values are consumed by this syntax (#500 = 1.234 ✓; #600 = #500 + 1 ✗). Non-literal RHS entries are left untouched in Parsing.Assignments; VariableEvaluatorSyntax resolves them and writes the result through the same table. The two syntaxes are decoupled. If no RetainedCommonVariableTable is registered on the runner's NcDependencyList, this syntax is a no-op. SubProgramCallSyntax Inlines a Fanuc-style subprogram into the source layer when an M98 or M198 host block is reached. M98 P_ L_ reads the matching O<P> file from InternalFolder; M198 P_ reads from ExternalFolder (Fanuc external-storage call — same mechanism as M98, different lookup root). The file is segmented through the host runner's segmenter (SegmenterDependency) and the resulting SyntaxPieces are prepended into layers[0] via PrependSource(IEnumerable<T>); the rest of the pipeline picks them up through ordinary walkNode.Next traversal as if they had always been part of the host file. Pipeline placement: first child of the Fanuc Evaluation BundleSyntax. By the time this runs, M98Syntax / M198Syntax (each a ParameterizedFlagSyntax) have written a Parsing.M98 / Parsing.M198 sub-object carrying the captured P / L parameters. Note: those sub-objects are this syntax's only trigger — \"M98\" / \"M198\" never reach Parsing.Flags, because the parameterized match has already consumed the text by the time NumberedFlagSyntax runs. Filename lookup uses a fallback chain: O{P:D4}.NC, O{P}.NC, O{P:D4}, O{P}, {P:D4}.NC, {P}.NC — first match wins. Case-insensitive match is delegated to the host filesystem (Windows is, Linux is not). L > 1 inlines the same subprogram L times in series. Each repetition is a fresh segmentation pass so each block gets its own SyntaxPiece with an independent JSON object — the downstream pipeline mutates JSON in place and would clobber sibling repetitions if instances were shared. Not yet supported: M99 P{seq} early return inside a subprogram and partial-program calls (M98 P{seq}{prog} split encoding). Custom Macro B argument-binding calls (G65 / G66 / G67) live in FanucMacroCallSyntax and FanucModalMacroSyntax — those handle the argument-letter-to-#1..#26 binding and the macro-call frame isolation that M98 deliberately does not provide. SubProgramReturnSyntax Consumes Fanuc-style M99 subprogram-return blocks and pops one CallStack frame. Plain M99 relies on the natural pipeline tail — the inlined body's last block is followed in layers[0] by the caller's next block, so the “return” happens implicitly; this syntax only consumes the M99 trigger (so UnconsumedCheckSyntax doesn't warn), stamps a SubProgramReturn diagnostic section, and writes the popped CallStack for downstream blocks to carry. M99 P{seq} additionally redirects control flow to the caller's N{seq} block via ReplaceSource(IEnumerable<T>). The caller's file is resolved from the popped frame's CallerFilePath; the scan uses the same LabelScanUtil.SegmentAndSkipUntilLabel helper as FanucGotoSyntax, with hardcoded Fanuc-default probes (QuoteCommentSyntax + HeadIndexSyntax with symbol \"N\") because the M99 P semantic itself is Fanuc-family-only and Mazak / Syntec follow the same conventions. The iteration is counted against FanucGotoIterationDependency, sharing the same runaway-loop guard as GOTO — keyed on the same (FileName, TargetN) bucket so a tight M98 → M99 P → M98 … loop trips the same threshold. Pipeline placement: same Evaluation bundle slot it always occupied, right after SubProgramCallSyntax at the head. Needs FanucGotoIterationDependency, ProjectFolderDependency, SegmenterDependency, SyntaxPieceLayerDependency, FileIndexCounterDependency on the dep list when M99 P{seq} is to fire; without them the plain-M99 path still works and the P-jump emits a configuration warning. Detection is on the Parsing.M99 sub-object written by M99Syntax (a ParameterizedFlagSyntax) — the keyword \"M99\" never reaches Parsing.Flags because the parameterized match has already consumed the text by the time NumberedFlagSyntax runs. VariableEvaluatorSyntax Pure expression normalizer for Custom Macro B syntax. Walks the parser-stage residue on a single block and inlines numeric values wherever a Fanuc-style variable reference or bracket expression appears — but does not write to any specific store. Routing “where the resolved literal lands” stays in the brand-specific reader syntaxes (VolatileVariableReadingSyntax, RetainedCommonVariableTable's reader, FanucSystemControlVariableSyntax, …) which run after this syntax on the same block. Two passes per block: Assignments normalize — Parsing.Assignments.#nnn entries whose RHS is non-literal (e.g. \"#500+1\", \"SQRT[#100]\") are evaluated via the VariableEvaluatorSyntax.ChainLookup and the RHS string is replaced with the resolved literal (round-trip-safe \"R\"-format). The entry stays in Parsing.Assignments so downstream reader syntaxes consume it as a pure-literal assignment. Iteration follows source order (Parsing.Assignments insertion order). Parsing tree substitution — every string-typed value reachable from Parsing.<tag> (axis tags, canned-cycle sub-objects) is parsed; on a successful evaluation the string is replaced with a numeric JsonValue. Failures silently leave the original string and rely on downstream GetParsedDouble(JsonObject, string, ISentenceCarrier, NcDiagnosticProgress) at consumer sites to surface VariableExpression--Unevaluated only if the tag is actually read. Lookup chain (first non-null wins, configured per brand preset via RuntimeVariableLookups + IVariableLookup instances on NcDependencyList): Current block's own resolved assignments — built-in to VariableEvaluatorSyntax.ChainLookup; covers same-block forward references in source order (an earlier #nnn=literal is visible to a later RHS that mentions #nnn). Each IRuntimeVariableLookup in RuntimeVariableLookups, in list order. Typical contents for a Fanuc-family preset: LocalVariableLookup (#1-#33), VolatileVariableLookup (#100-#499), FanucPositionVariableLookup (#5001-#5043). Each IVariableLookup on the runner's NcDependencyList, in registration order (RetainedCommonVariableTable, FanucParameterTable, FanucToolOffsetVariableLookup). Each lookup self-gates its id range; the evaluator stays brand- and range-agnostic. Adding a new variable surface is additive: register an IVariableLookup on a dependency or push an IRuntimeVariableLookup onto the per-preset list. Same-block forward reference — when an Assignment RHS references a #nnn that is also being assigned later in the same block (i.e. listed in Parsing.Assignments after the RHS being evaluated), the VariableEvaluatorSyntax.ChainLookup cannot pick up the not-yet-resolved value and falls back to traceback / dependency-table reads — effectively the pre-block value. A VariableEvaluator--SameBlockForwardReference warning is emitted per such RHS so the user is told the source-order semantics were not honoured. Practical impact is near-zero for typical CAM-emitted NC (one assignment per line). Formula mirror tree — when either pass actually performs a non-trivial expression evaluation (i.e. the RHS / tag value was not already a pure literal and the evaluator returned a finite value), the original expression string is mirrored to a parallel Formula.<same path> entry at the root of the block JSON. The Parsing.* subtree carries the resolved value (R-format string for Assignments; numeric JsonValue for tags); the Formula.* subtree preserves the source-text expression for diagnostics, round-trip reconstruction, and downstream inspection. Pure-literal RHS values produce no Formula entry — the Parsing value is already the original text. In the tag pass the same holds for the Heidenhain dialect only (literal strings short-circuit there because klartext readers consume them as strings); Fanuc / Siemens literal-string tags are numeric-ified as they always were (int-typed capture fallbacks and constant conditions depend on it) and thus carry a Formula entry. Evaluation failures (parse error, vacant variable, non-finite result) produce no Formula entry — the original string is still in Parsing.* untouched, no preservation needed. VolatileVariableReadingSyntax Obtains values for Fanuc-style non-retained common variables (#100-#499). Reads literal numeric assignments from Parsing.Assignments.#nnn, dict-merges them with the previous block's volatile state, and writes the resulting per-block dictionary into Vars.Volatile. Lifetime is bounded by MachiningSession: within one session the dictionary carries forward block-by-block via this syntax; session restart abandons the SyntaxPiece JSON dataflow and starts fresh. Program-end (M02/M30) clearing is handled by ProgramEndCleanSyntax. Only literal numeric RHS values are consumed by this syntax (#124 = 15. ✓; #100 = #1 + 5 ✗). Non-literal RHS entries are left untouched in Parsing.Assignments; VariableEvaluatorSyntax resolves them and writes the result into the same per-block dictionary. The two syntaxes are decoupled — the evaluator's lookup tracebacks via SyntaxPiece linkage so it does not depend on having run before or after this syntax. Structs MacroFileResolver.ResolvedFile Tri-form resolution result. FileName is the bare matched name; RelPath is that name joined with the folder portion of the dependency (relative when the folder is configured relative, absolute fallback when it isn't); AbsPath is the fully-resolved I/O target. Enums LabelScanDirection Scan region and match policy for the anchored LabelScanUtil overload. Forward scans take the first match below the anchor line; backward scans take the nearest match above it."
  },
  "api/Hi.NcParsers.IGetSentence.html": {
    "href": "api/Hi.NcParsers.IGetSentence.html",
    "title": "Interface IGetSentence | HiAPI-C# 2025",
    "summary": "Interface IGetSentence Namespace Hi.NcParsers Assembly HiMech.dll Abstraction for a source that carries a Sentence. public interface IGetSentence Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetSentence() Returns the source Sentence carried by this object. Sentence GetSentence() Returns Sentence"
  },
  "api/Hi.NcParsers.ISentenceCarrier.html": {
    "href": "api/Hi.NcParsers.ISentenceCarrier.html",
    "title": "Interface ISentenceCarrier | HiAPI-C# 2025",
    "summary": "Interface ISentenceCarrier Namespace Hi.NcParsers Assembly HiMech.dll Carries a reference to a source Sentence together with its execution-order SentenceIndex. Used as the cross-process alignment carrier for diagnostics, messages, ClStripPos, MachiningStep, etc. — both the source content (via GetSentence()) and the execution-order position (via SentenceIndex) are available without needing two separate references. public interface ISentenceCarrier : IGetSentence, ISentenceIndexed Inherited Members IGetSentence.GetSentence() ISentenceIndexed.SentenceIndex Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.NcParsers.ISentenceIndexed.html": {
    "href": "api/Hi.NcParsers.ISentenceIndexed.html",
    "title": "Interface ISentenceIndexed | HiAPI-C# 2025",
    "summary": "Interface ISentenceIndexed Namespace Hi.NcParsers Assembly HiMech.dll Abstraction for an object that carries a SentenceIndex — a 0-based ordinal of its source Sentence in NC execution order. Use as a cross-process alignment key (messages, ClStripPos, MachiningStep, etc.) when the (FileIndex, LineIndex) source order is not enough because SubProgram inline reorders blocks relative to source order. public interface ISentenceIndexed Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties SentenceIndex 0-based ordinal in pipeline execution order. int SentenceIndex { get; } Property Value int"
  },
  "api/Hi.NcParsers.ISessionResettable.html": {
    "href": "api/Hi.NcParsers.ISessionResettable.html",
    "title": "Interface ISessionResettable | HiAPI-C# 2025",
    "summary": "Interface ISessionResettable Namespace Hi.NcParsers Assembly HiMech.dll Marker for objects that hold session-scoped runtime state which must be cleared when RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) initializes a new session pipeline (the state.IsInitialized == false edge). Implementers may live on either chain: INcDependency or INcSyntax. SoftNcRunner scans PipelineNcDependencyList and NcSyntaxList on the session-init edge and calls OnSessionReset() on every match. Distinct from IPowerResettable: power-reset clears retained-but-volatile state on a controller power cycle (e.g., Fanuc #100-#499), an edge that survives ordinary session boundaries. Session-reset clears state whose lifetime is one pipeline pass (iteration counters, file-index allocators, etc.). public interface ISessionResettable Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods OnSessionReset() Clears the session-scoped subset owned by this object. Called by RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) on the same edge that rebuilds the syntax-piece pipeline so a runner reused across sessions does not leak counters / allocators / accumulators from the previous session. void OnSessionReset()"
  },
  "api/Hi.NcParsers.Initializers.HomeMcInitializer.html": {
    "href": "api/Hi.NcParsers.Initializers.HomeMcInitializer.html",
    "title": "Class HomeMcInitializer | HiAPI-C# 2025",
    "summary": "Class HomeMcInitializer Namespace Hi.NcParsers.Initializers Assembly HiMech.dll Sets the initial MachineCoordinateState on the first SyntaxPiece from IHomeMcConfig and IMachineAxisConfig. Every declared axis is written — rotary axes without a configured home seed at 0 deg, the same value the runtime's begin/reset teleport re-homes the machining chain to — so the first motion contour interpolates from the pose the machine actually holds at t=0 instead of a per-axis “never set” hole. public class HomeMcInitializer : INcInitializer, IMakeXmlSource Inheritance object HomeMcInitializer Implements INcInitializer IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HomeMcInitializer() Creates a new HomeMcInitializer. public HomeMcInitializer() HomeMcInitializer(XElement) Creates a HomeMcInitializer from an XML source element. public HomeMcInitializer(XElement src) Parameters src XElement Properties Name Display/registration name of the initializer. public string Name { get; } Property Value string XName XML element name used to register and serialize this initializer. public static string XName { get; } Property Value string Methods Initialize(JsonObject, List<INcDependency>) Writes initial sections into jsonObject, optionally using values resolved from ncDependencyList. public void Initialize(JsonObject jsonObject, List<INcDependency> ncDependencyList) Parameters jsonObject JsonObject ncDependencyList List<INcDependency> MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Initializers.INcInitializer.html": {
    "href": "api/Hi.NcParsers.Initializers.INcInitializer.html",
    "title": "Interface INcInitializer | HiAPI-C# 2025",
    "summary": "Interface INcInitializer Namespace Hi.NcParsers.Initializers Assembly HiMech.dll Populates the init-block JSON sections (e.g. home position, static defaults) before the soft-NC runtime processes any source NC syntax. Implementations such as HomeMcInitializer and StaticInitializer write into the supplied JsonObject. public interface INcInitializer : IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Name Display/registration name of the initializer. string Name { get; } Property Value string Methods Initialize(JsonObject, List<INcDependency>) Writes initial sections into jsonObject, optionally using values resolved from ncDependencyList. void Initialize(JsonObject jsonObject, List<INcDependency> ncDependencyList) Parameters jsonObject JsonObject ncDependencyList List<INcDependency>"
  },
  "api/Hi.NcParsers.Initializers.StaticInitializer.html": {
    "href": "api/Hi.NcParsers.Initializers.StaticInitializer.html",
    "title": "Class StaticInitializer | HiAPI-C# 2025",
    "summary": "Class StaticInitializer Namespace Hi.NcParsers.Initializers Assembly HiMech.dll Merges a fixed Initialization JSON snippet into the init-block JSON. Used to seed brand-default sections (e.g. G54, G80) before any source NC syntax is processed. public class StaticInitializer : INcInitializer, IMakeXmlSource Inheritance object StaticInitializer Implements INcInitializer IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors StaticInitializer() Creates an empty StaticInitializer. public StaticInitializer() StaticInitializer(XElement) Creates a StaticInitializer from an XML source element, reading the embedded JSON from the Initialization child element. public StaticInitializer(XElement src) Parameters src XElement Properties Default An empty StaticInitializer with no preset sections. public static StaticInitializer Default { get; } Property Value StaticInitializer HeidenhainDefault Heidenhain default: no coordinate offset active (datum tables used on demand). public static StaticInitializer HeidenhainDefault { get; } Property Value StaticInitializer Initialization JSON sections to merge into the init-block JSON during Initialize(JsonObject, List<INcDependency>). public JsonObject Initialization { get; set; } Property Value JsonObject IsoDefault ISO/Fanuc default: G54 active, canned-cycle cancelled (G80). public static StaticInitializer IsoDefault { get; } Property Value StaticInitializer Name Display/registration name of the initializer. public string Name { get; } Property Value string SiemensDefault Siemens default: no settable work offset active (G500) and canned-cycle cancelled (the shared G80 inactive sentinel — Sinumerik has no G80 vocabulary, the marker is internal). G500 is the Siemens factory default of G group 8 (Programming Manual Fundamentals 03/2010 §16.3, SAG column): unlike Fanuc's implicit G54, a Sinumerik activates no settable frame until the program commands one — a program that never writes G54-G599 machines in the machine frame. Group 1's factory default (G1, not G0) is deliberately NOT seeded: no brand initializer seeds a motion term — first-block motion semantics are owned uniformly by the motion syntaxes' absent-state rules. public static StaticInitializer SiemensDefault { get; } Property Value StaticInitializer XName XML element name used to register and serialize this initializer. public static string XName { get; } Property Value string Methods Initialize(JsonObject, List<INcDependency>) Writes initial sections into jsonObject, optionally using values resolved from ncDependencyList. public void Initialize(JsonObject jsonObject, List<INcDependency> ncDependencyList) Parameters jsonObject JsonObject ncDependencyList List<INcDependency> MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Initializers.html": {
    "href": "api/Hi.NcParsers.Initializers.html",
    "title": "Namespace Hi.NcParsers.Initializers | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.Initializers Classes HomeMcInitializer Sets the initial MachineCoordinateState on the first SyntaxPiece from IHomeMcConfig and IMachineAxisConfig. Every declared axis is written — rotary axes without a configured home seed at 0 deg, the same value the runtime's begin/reset teleport re-homes the machining chain to — so the first motion contour interpolates from the pose the machine actually holds at t=0 instead of a per-axis “never set” hole. StaticInitializer Merges a fixed Initialization JSON snippet into the init-block JSON. Used to seed brand-default sections (e.g. G54, G80) before any source NC syntax is processed. Interfaces INcInitializer Populates the init-block JSON sections (e.g. home position, static defaults) before the soft-NC runtime processes any source NC syntax. Implementations such as HomeMcInitializer and StaticInitializer write into the supplied JsonObject."
  },
  "api/Hi.NcParsers.InspectionSyntaxs.CleanupSyntax.html": {
    "href": "api/Hi.NcParsers.InspectionSyntaxs.CleanupSyntax.html",
    "title": "Class CleanupSyntax | HiAPI-C# 2025",
    "summary": "Class CleanupSyntax Namespace Hi.NcParsers.InspectionSyntaxs Assembly HiMech.dll Removes indicated JSON keys from JsonObject after upstream syntaxes have consumed them. Useful for cleaning up runtime-derived intermediate data (e.g., ProgramToMcTransform) that should not persist in the final output. Place at the end of the syntax list, after all consumers have read the keys. public class CleanupSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object CleanupSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples new CleanupSyntax(\"ProgramToMcTransform\", \"ToolOrientation\") Constructors CleanupSyntax(params string[]) Creates a CleanupSyntax seeded with the given keys. public CleanupSyntax(params string[] keys) Parameters keys string[] JSON keys to remove on each block; copied into Keys. CleanupSyntax(XElement) Reconstructs a CleanupSyntax from a project XML element previously produced by MakeXmlSource(string, string, bool). public CleanupSyntax(XElement src) Parameters src XElement XML element with one Key child per entry in Keys. Properties Keys JSON keys to remove from JsonObject each block. public List<string> Keys { get; set; } Property Value List<string> Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.InspectionSyntaxs.ProgramXyzBackfillSyntax.html": {
    "href": "api/Hi.NcParsers.InspectionSyntaxs.ProgramXyzBackfillSyntax.html",
    "title": "Class ProgramXyzBackfillSyntax | HiAPI-C# 2025",
    "summary": "Class ProgramXyzBackfillSyntax Namespace Hi.NcParsers.InspectionSyntaxs Assembly HiMech.dll Debug / observability back-fill: writes ProgramXyz onto blocks that did not have it written by upstream logic syntaxes (e.g. HomeMcInitializer block, chain-change blocks that only updated MC via a rotary-only path), only when the effective program position has changed from the previous block's effective value (which, blocks being skipped only on equality, is also the last stored ProgramXyz). Skips the block entirely when either of these holds: The block already has ProgramXyz written — e.g. by ProgramXyzSyntax, G53p1RotaryPositionSyntax, MachineCoordSelectSyntax, ReferenceReturnSyntax, McAbcXyzFallbackSyntax, or RadiusCompensationSyntax. The effective value equals the predecessor's effective value (modal-only block such as pure F / S / M / plane-select — no program motion). Only back-fills the root block; ItemsKey items are intentionally skipped (they are managed by Hi.NcParsers.LogicSyntaxs.CompoundMotionSyntaxUtil and per-cycle syntaxes that already write the right per-item ProgramXyz). Placement: end of NcSyntaxList, after UnconsumedCheckSyntax. Runs purely as a bookkeeping pass — no other syntax / semantic in the default pipeline reads the additional back-fill values it emits, so the runtime output (IAct stream) is unchanged whether this syntax is present or not. The only observable effect is additional ProgramXyz entries in the cached syntax-pieces dump, which makes block-to-block debugging and diffing easier. public class ProgramXyzBackfillSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object ProgramXyzBackfillSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ProgramXyzBackfillSyntax() Creates a default ProgramXyzBackfillSyntax. public ProgramXyzBackfillSyntax() Fields AddedByValue Value written under AddedByKey on the ProgramXyz JSON object when this syntax synthesized the value. Absent on sub-objects authored by LogicSyntaxs-stage writers (e.g. ProgramXyzSyntax, G53p1RotaryPositionSyntax, MachineCoordSelectSyntax) — the AddedByKey is only present when a post-Logic / Inspection stage writer (this syntax, or ModalCarrySyntax) injected the sub-object. Purely informational — no downstream syntax / semantic reads this marker. Intended for cache-file diffing: its presence means \"this block did not originally command program motion; the value is a modal back-fill to make debug dumps more complete\". public const string AddedByValue = \"Backfill\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.InspectionSyntaxs.SnapshotSyntax.html": {
    "href": "api/Hi.NcParsers.InspectionSyntaxs.SnapshotSyntax.html",
    "title": "Class SnapshotSyntax | HiAPI-C# 2025",
    "summary": "Class SnapshotSyntax Namespace Hi.NcParsers.InspectionSyntaxs Assembly HiMech.dll Debug-time JsonObject capture: deep-clones every key on the current JsonObject (except the SnapshotKey envelope itself) into json[SnapshotKey][SectionName], leaving the rest of the block untouched. Insertable at any position in NcSyntaxList — placement determines what stage the dump captures (e.g. drop after the Parsing bundle for \"after-parsing\", drop after the Logic bundle for \"after-logic\"). Two instances with different SectionName values can coexist on the same pipeline and their dumps end up under sibling keys of the same SnapshotKey envelope, so a single cache file shows the data at every captured stage in one place. Excluding the SnapshotKey envelope from the clone keeps each captured section flat: it reflects \"everything else on the block at that stage\", and re-running through additional SnapshotSyntax instances never nests past one level. Set IsEnabled = false to keep the configuration in place but skip the capture (no JSON mutation, no allocation) — convenient for toggling a debug pipeline without removing the entries. public class SnapshotSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SnapshotSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SnapshotSyntax() Creates a SnapshotSyntax with no SectionName set yet. public SnapshotSyntax() SnapshotSyntax(string) Creates a SnapshotSyntax with the given SectionName. public SnapshotSyntax(string sectionName) Parameters sectionName string Sub-key under SnapshotKey for this instance's capture. SnapshotSyntax(XElement) Reconstructs a SnapshotSyntax from a project XML element previously produced by MakeXmlSource(string, string, bool). public SnapshotSyntax(XElement src) Parameters src XElement XML element carrying SectionName and IsEnabled; null is treated as defaults. Fields SnapshotKey Top-level JSON envelope key under which captured sections are stored. Each SnapshotSyntax instance writes a sibling key (named by SectionName) inside this envelope. public const string SnapshotKey = \"Snapshot\" Field Value string Properties IsEnabled When false, Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) is a no-op — keeps the entry in the syntax list for easy toggling without re-editing the project. public bool IsEnabled { get; set; } Property Value bool Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string SectionName Sub-key inside the SnapshotKey envelope under which this instance writes its capture. Two instances configured with the same SectionName are last-writer-wins on a given block. Required: Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) throws InvalidOperationException when this is null or empty (a misconfiguration the user should see, not a silent skip). public string SectionName { get; set; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.InspectionSyntaxs.UnconsumedCheckSyntax.html": {
    "href": "api/Hi.NcParsers.InspectionSyntaxs.UnconsumedCheckSyntax.html",
    "title": "Class UnconsumedCheckSyntax | HiAPI-C# 2025",
    "summary": "Class UnconsumedCheckSyntax Namespace Hi.NcParsers.InspectionSyntaxs Assembly HiMech.dll Emits diagnostic warnings for content remaining after all upstream syntaxes have run: unconsumed Parsing entries and non-empty UnparsedText. Flags listed in ExcludedFlags are silently ignored. Must be placed at the end of NcSyntaxList. public class UnconsumedCheckSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object UnconsumedCheckSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors UnconsumedCheckSyntax() Creates a checker with an empty ExcludedFlags set. public UnconsumedCheckSyntax() UnconsumedCheckSyntax(XElement) Loads excluded flag names from <Exclude> child elements. public UnconsumedCheckSyntax(XElement src) Parameters src XElement Root element named XName. Properties ExcludedFlags Parsing flags/keys that are known but intentionally unhandled — listed entries are silently skipped by this check. This is the per-project escape hatch for non-M-code residue (sections, dotted keys, vendor G/word codes) a project has decided is irrelevant, configured via <Exclude> elements in the project XML. For machine M-codes prefer IMCodeDeclarationConfig declarations instead: an empty declaration silences by explicit intent, and a note-only declaration keeps the code visible as known-but-unmodeled. Brand presets deliberately ship this set empty — a silent default would erode the very signal this check exists for. public HashSet<string> ExcludedFlags { get; set; } Property Value HashSet<string> Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.InspectionSyntaxs.html": {
    "href": "api/Hi.NcParsers.InspectionSyntaxs.html",
    "title": "Namespace Hi.NcParsers.InspectionSyntaxs | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.InspectionSyntaxs Classes CleanupSyntax Removes indicated JSON keys from JsonObject after upstream syntaxes have consumed them. Useful for cleaning up runtime-derived intermediate data (e.g., ProgramToMcTransform) that should not persist in the final output. Place at the end of the syntax list, after all consumers have read the keys. ProgramXyzBackfillSyntax Debug / observability back-fill: writes ProgramXyz onto blocks that did not have it written by upstream logic syntaxes (e.g. HomeMcInitializer block, chain-change blocks that only updated MC via a rotary-only path), only when the effective program position has changed from the previous block's effective value (which, blocks being skipped only on equality, is also the last stored ProgramXyz). Skips the block entirely when either of these holds: The block already has ProgramXyz written — e.g. by ProgramXyzSyntax, G53p1RotaryPositionSyntax, MachineCoordSelectSyntax, ReferenceReturnSyntax, McAbcXyzFallbackSyntax, or RadiusCompensationSyntax. The effective value equals the predecessor's effective value (modal-only block such as pure F / S / M / plane-select — no program motion). Only back-fills the root block; ItemsKey items are intentionally skipped (they are managed by Hi.NcParsers.LogicSyntaxs.CompoundMotionSyntaxUtil and per-cycle syntaxes that already write the right per-item ProgramXyz). Placement: end of NcSyntaxList, after UnconsumedCheckSyntax. Runs purely as a bookkeeping pass — no other syntax / semantic in the default pipeline reads the additional back-fill values it emits, so the runtime output (IAct stream) is unchanged whether this syntax is present or not. The only observable effect is additional ProgramXyz entries in the cached syntax-pieces dump, which makes block-to-block debugging and diffing easier. SnapshotSyntax Debug-time JsonObject capture: deep-clones every key on the current JsonObject (except the SnapshotKey envelope itself) into json[SnapshotKey][SectionName], leaving the rest of the block untouched. Insertable at any position in NcSyntaxList — placement determines what stage the dump captures (e.g. drop after the Parsing bundle for \"after-parsing\", drop after the Logic bundle for \"after-logic\"). Two instances with different SectionName values can coexist on the same pipeline and their dumps end up under sibling keys of the same SnapshotKey envelope, so a single cache file shows the data at every captured stage in one place. Excluding the SnapshotKey envelope from the clone keeps each captured section flat: it reflects \"everything else on the block at that stage\", and re-running through additional SnapshotSyntax instances never nests past one level. Set IsEnabled = false to keep the configuration in place but skip the capture (no JSON mutation, no allocation) — convenient for toggling a debug pipeline without removing the entries. UnconsumedCheckSyntax Emits diagnostic warnings for content remaining after all upstream syntaxes have run: unconsumed Parsing entries and non-empty UnparsedText. Flags listed in ExcludedFlags are silently ignored. Must be placed at the end of NcSyntaxList."
  },
  "api/Hi.NcParsers.Keywords.BlockSkip.html": {
    "href": "api/Hi.NcParsers.Keywords.BlockSkip.html",
    "title": "Class BlockSkip | HiAPI-C# 2025",
    "summary": "Class BlockSkip Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Optional block skip marker extracted from the head of an NC block. ISO 6983 / Fanuc calls this feature Block Delete (BDT switch); Siemens / Syntec / Mazak use the same / prefix with matching behaviour. The section is only present on blocks that carry a / prefix. Whether the block's NC commands are actually skipped at runtime depends on IBlockSkipConfig: Config absent or the Layer bit OFF → the / prefix is consumed, Body is left null, and the rest of the line parses as a regular NC block (comments still take effect). Config present and the Layer bit ON → the rest of the line is moved into Body and cleared from UnparsedText, so downstream parsing syntaxes see nothing and no NC action is emitted. Comment syntaxes run before this one so comments (and any embedded CsScript) still take effect. Not a comment: a comment is static metadata, block skip is a runtime toggle that can change per machine/operator setting. public class BlockSkip Inheritance object BlockSkip Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Body NC commands from the block that were moved out of UnparsedText because the skip took effect (after comment and CsScript extraction, with surrounding whitespace trimmed). Represents the semantic payload of the skipped block — not a verbatim snapshot; recover human-readable NC text with a dedicated formatter if needed. null when the skip did not take effect (no IBlockSkipConfig or its layer bit was OFF); in that case the block's commands are still in UnparsedText and parse normally. public string Body { get; set; } Property Value string Layer Skip layer (1..9). A bare / without a digit is layer 1 (most controllers treat / and /1 as the same switch). /2../9 map to layers 2..9. public int Layer { get; set; } Property Value int Symbol Delimiter symbol as it appeared in the NC block (always \"/\"). public string Symbol { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.CallFrame.html": {
    "href": "api/Hi.NcParsers.Keywords.CallFrame.html",
    "title": "Class CallFrame | HiAPI-C# 2025",
    "summary": "Class CallFrame Namespace Hi.NcParsers.Keywords Assembly HiMech.dll One entry in Frames. Holds the caller-side information consumers need to “unwind” or “look back” — currently only the relative file path of the caller, used by SubProgramReturnSyntax on M99 P{seq} to locate the caller's N{seq} block. public class CallFrame Inheritance object CallFrame Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties CallerFilePath Project-relative file path of the calling block — same form as FilePath on the caller side. Used by M99 P{seq} to re-segment the caller file and skip ahead to N{seq}. public string CallerFilePath { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.CallStack.html": {
    "href": "api/Hi.NcParsers.Keywords.CallStack.html",
    "title": "Class CallStack | HiAPI-C# 2025",
    "summary": "Class CallStack Namespace Hi.NcParsers.Keywords Assembly HiMech.dll JSON-section data shape representing the active call-frame stack on a block — pushed by call-and-inline syntaxes (SubProgramCallSyntax for M98/M198, FanucMacroCallSyntax for G65, and FanucModalMacroSyntax's expansion phase for G66 implicit triggers) and popped by SubProgramReturnSyntax on M99. Every block between push and pop carries the section forward via ModalCarrySyntax; the caller's blocks before push and after pop carry the surrounding stack state (typically empty when running from the main file). The section is wrapped in a JsonObject rather than exposed as a bare JsonArray so it fits ModalCarry's \"deep-clone JsonObject\" carry pattern — the array of frames lives inside Frames. public class CallStack Inheritance object CallStack Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Frames Ordered list of active call frames, bottom-of-stack first. Each entry is a CallFrame-shaped JSON object. Length 0 means the block is in the main (top-level) frame. public JsonArray Frames { get; set; } Property Value JsonArray"
  },
  "api/Hi.NcParsers.Keywords.CannedCycle.html": {
    "href": "api/Hi.NcParsers.Keywords.CannedCycle.html",
    "title": "Class CannedCycle | HiAPI-C# 2025",
    "summary": "Class CannedCycle Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section key holder + concrete implementation for ICannedCycleDef. public class CannedCycle : ICannedCycleDef Inheritance object CannedCycle Implements ICannedCycleDef Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Params Resolved absolute cycle parameters: X, Y, Z, R, Q, F, P, K. Used for modal lookback so the next repeat block can merge its own overrides with the previously-resolved values. Absent on G80 blocks. public JsonObject Params { get; set; } Property Value JsonObject ReturnMode Return level mode: “G98” (initial Z) or “G99” (R-point). Only meaningful when Term is an active cycle code; absent on G80 blocks. public string ReturnMode { get; set; } Property Value string Term NC term of the canned-cycle-group code on this block (“G81”, “G82”, ..., “G89”, or “G80” for explicit cancel). Modal-repeat blocks carry the same term as the most recent active cycle. public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Comment.html": {
    "href": "api/Hi.NcParsers.Keywords.Comment.html",
    "title": "Class Comment | HiAPI-C# 2025",
    "summary": "Class Comment Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Comment extracted from an NC block. Symbol identifies the comment style; Text holds the content without the symbol. Downstream syntaxes (e.g., CsScript) may further trim Text after extracting embedded markers. public class Comment Inheritance object Comment Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Symbol Comment delimiter used in the NC block (e.g., \"%\", \"()\", \";\", \"//\"). public string Symbol { get; set; } Property Value string Text Comment body without the delimiter symbol. Initially set by the comment syntax; may be trimmed by CsScriptSyntax after script extraction. public string Text { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.CompoundMotion.html": {
    "href": "api/Hi.NcParsers.Keywords.CompoundMotion.html",
    "title": "Class CompoundMotion | HiAPI-C# 2025",
    "summary": "Class CompoundMotion Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section key holder + concrete implementation for ICompoundMotionDef. public class CompoundMotion : ICompoundMotionDef Inheritance object CompoundMotion Implements ICompoundMotionDef Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields FeedrateKey JSON key for feedrate (mm/s) inside the Hi.Motion section of non-rapid items. Absent on rapid items whose speed is determined by machine config. public const string FeedrateKey = \"Feedrate_mmds\" Field Value string ItemsKey JSON array key for the sub-operation items within the section. Items are discriminated by Hi.Motion or Dwell key presence. public const string ItemsKey = \"Items\" Field Value string Properties Term CNC term that triggered this compound motion (e.g., “G28”, “G81”). public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Coolant.html": {
    "href": "api/Hi.NcParsers.Keywords.Coolant.html",
    "title": "Class Coolant | HiAPI-C# 2025",
    "summary": "Class Coolant Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section key holder + concrete implementation for ICoolantDef. public class Coolant : ICoolantDef Inheritance object Coolant Implements ICoolantDef Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Flood Flood coolant (corresponds to M08). public const string Flood = \"Flood\" Field Value string Mist Mist coolant (corresponds to M07). public const string Mist = \"Mist\" Field Value string Off Coolant off (corresponds to M09). public const string Off = \"Off\" Field Value string Properties IsOn Whether any coolant is currently active. public bool IsOn { get; set; } Property Value bool Mode Abstract coolant mode (Flood / Mist / Off). public string Mode { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.CoordinateOffset.html": {
    "href": "api/Hi.NcParsers.Keywords.CoordinateOffset.html",
    "title": "Class CoordinateOffset | HiAPI-C# 2025",
    "summary": "Class CoordinateOffset Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Work coordinate offset state written by IsoCoordinateOffsetSyntax. Property names are used as JSON keys via nameof. Managed commands (ISO): G54, G55, G56, G57, G58, G59, G59.1–G59.9. Siemens: G54–G57 + G505–G599 (extended), G500 to cancel. Heidenhain: CYCL DEF 247 (Datum Preset) / CYCL DEF 7 (Datum Shift). public class CoordinateOffset Inheritance object CoordinateOffset Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples \"CoordinateOffset\": { \"CoordinateId\": \"G54\", \"Offset_X\": 0.0, \"Offset_Y\": 0.0, \"Offset_Z\": -100.0 } Properties CoordinateId Active coordinate system ID: “G54”, “G55”, ..., “G59.9”. public string CoordinateId { get; set; } Property Value string Offset_X X component of the coordinate offset (mm). public double Offset_X { get; set; } Property Value double Offset_Y Y component of the coordinate offset (mm). public double Offset_Y { get; set; } Property Value double Offset_Z Z component of the coordinate offset (mm). public double Offset_Z { get; set; } Property Value double"
  },
  "api/Hi.NcParsers.Keywords.CsScript.html": {
    "href": "api/Hi.NcParsers.Keywords.CsScript.html",
    "title": "Class CsScript | HiAPI-C# 2025",
    "summary": "Class CsScript Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section-key holder for inline C# scripts attached to an NC block. Carries BeginScript (run before the block's acts) and EndScript (run after). Resolved by CsScriptBeginSemantic and CsScriptEndSemantic. public class CsScript Inheritance object CsScript Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties BeginScript The script effect before the NC block excuting. public string BeginScript { get; set; } Property Value string EndScript The script effect after the NC block excuted. public string EndScript { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Dwell.html": {
    "href": "api/Hi.NcParsers.Keywords.Dwell.html",
    "title": "Class Dwell | HiAPI-C# 2025",
    "summary": "Class Dwell Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section key holder + concrete implementation for IDwellDef. public class Dwell : IDwellDef Inheritance object Dwell Implements IDwellDef Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Time Dwell time in seconds. public double Time { get; set; } Property Value double"
  },
  "api/Hi.NcParsers.Keywords.Fanuc.FanucKeywords.html": {
    "href": "api/Hi.NcParsers.Keywords.Fanuc.FanucKeywords.html",
    "title": "Class FanucKeywords | HiAPI-C# 2025",
    "summary": "Class FanucKeywords Namespace Hi.NcParsers.Keywords.Fanuc Assembly HiMech.dll Fanuc-specific G-code and M-code constants. For ISO standard codes shared across brands, see IsoKeywords. public static class FanucKeywords Inheritance object FanucKeywords Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields G12p1 G12.1: start Polar Coordinate Interpolation (turn-mill face milling). The linear axis word (X) commands a diameter value; the rotary axis word (C) commands a hypothetical Cartesian coordinate in linear units. See PolarInterpolationSyntax. public const string G12p1 = \"G12.1\" Field Value string G13p1 G13.1: end Polar Coordinate Interpolation. Modal counterpart of G12p1. public const string G13p1 = \"G13.1\" Field Value string G43p4 G43.4: TCPM (Tool Center Point Management / RTCP). Fanuc-specific. Siemens equivalent: TRAORI. Heidenhain equivalent: M128. public const string G43p4 = \"G43.4\" Field Value string G54p1 G54.1: additional workpiece coordinate system selection, always with a P index (G54.1 P1–P48, P300 with the option). Fanuc's manual titles the chapter “G54.1 or G54”: the G54 Pn spelling is the same command, and the parsing capture (G54p1Syntax) stores both spellings under this key. Also read by the Syntec and Mazak presets. Consumed by IsoCoordinateOffsetSyntax. public const string G54p1 = \"G54.1\" Field Value string"
  },
  "api/Hi.NcParsers.Keywords.Fanuc.html": {
    "href": "api/Hi.NcParsers.Keywords.Fanuc.html",
    "title": "Namespace Hi.NcParsers.Keywords.Fanuc | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.Keywords.Fanuc Classes FanucKeywords Fanuc-specific G-code and M-code constants. For ISO standard codes shared across brands, see IsoKeywords."
  },
  "api/Hi.NcParsers.Keywords.FanucGoto.html": {
    "href": "api/Hi.NcParsers.Keywords.FanucGoto.html",
    "title": "Class FanucGoto | HiAPI-C# 2025",
    "summary": "Class FanucGoto Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Fanuc Custom Macro B GOTO record. Stamped on the host block by FanucGotoSyntax after the control-flow decision has been made; produced earlier by FanucGotoParsingSyntax as a parsing-stage sub-section (Parsing.FanucGoto) carrying the raw captured fields. Two source forms map to the same shape: GOTO <n> — unconditional jump. Condition is null. IF [<bool-expr>] GOTO <n> — conditional jump. Condition holds the expression text from inside the brackets. At parsing time N is a raw token from the source — it may be a literal (\"100\"), a variable reference (\"#1\"), or a bracketed expression (\"#[#2+5]\"). VariableEvaluatorSyntax substitutes a resolved literal back into the same field in the Evaluation bundle; FanucGotoSyntax then int.TryParses the final string to produce an int target. Lifecycle of the condition fields. Condition is written at Parsing time as the raw expression text and substituted in place by VariableEvaluatorSyntax pass-2 — the original text is preserved at Formula.FanucGoto.Condition when substitution succeeds. ConditionEvaluated is the host-level stamp written by FanucGotoSyntax carrying the tri-state truthy outcome. public class FanucGoto Inheritance object FanucGoto Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Condition Raw boolean expression text from inside the IF [...] brackets at Parsing time; substituted to a numeric JsonValue in place by VariableEvaluatorSyntax when the expression evaluates successfully. The original text survives at Formula.FanucGoto.Condition. Null for the unconditional form. Note: not written on the host-level stamp; the gate outcome lives at ConditionEvaluated. public string Condition { get; set; } Property Value string ConditionEvaluated Tri-state outcome of evaluating the IF-form's boolean condition, stamped on the host block by FanucGotoSyntax: true — condition met (gate fires). false — condition not met (gate falls through silently). null — evaluator could not produce a finite truth value (vacant variable, parse error, NaN / ±∞), or the host block is the unconditional GOTO form. The original expression text is preserved at Formula.FanucGoto.Condition by VariableEvaluatorSyntax. public bool? ConditionEvaluated { get; set; } Property Value bool? Fired Whether the GOTO actually redirected control flow on this block. False on conditional GOTOs whose condition evaluated to false, on conditional GOTOs whose condition was not evaluable, and on iteration-limit-exceeded blocks. The host block is preserved in either case so diagnostic readers can still see the call. public bool Fired { get; set; } Property Value bool N Target sequence-number expression — kept as a string so the in-place evaluator can substitute \"#1\" → “3” before the Evaluation stage parses it as an int. public string N { get; set; } Property Value string Term Triggering phrase: “GOTO” for the unconditional form, “IF...GOTO” for the conditional form. public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.FanucHpcc.html": {
    "href": "api/Hi.NcParsers.Keywords.FanucHpcc.html",
    "title": "Class FanucHpcc | HiAPI-C# 2025",
    "summary": "Class FanucHpcc Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section data holder for IFanucHpccDef. public class FanucHpcc : IFanucHpccDef Inheritance object FanucHpcc Implements IFanucHpccDef Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties FunctionCode Raw P function-selection value, preserved for NC-text write-back; null when the source block carried no P word or the P value was an unevaluated variable/expression. public int? FunctionCode { get; set; } Property Value int? IsEnabled True only for P10000 (HPCC entered); false for the cancel (P0) and the non-HPCC functions. public bool IsEnabled { get; set; } Property Value bool Term Source spelling that carried the selection (G05 or G5). public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.FanucIfThen.html": {
    "href": "api/Hi.NcParsers.Keywords.FanucIfThen.html",
    "title": "Class FanucIfThen | HiAPI-C# 2025",
    "summary": "Class FanucIfThen Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Fanuc Custom Macro B IF [<cond>] THEN <body> single-block conditional record. Stamped on the host block by FanucIfThenSyntax after the gate decision; produced earlier by FanucIfThenParsingSyntax as a parsing-stage sub-section (Parsing.FanucIfThen) carrying the raw captured fields plus an internal PendingAssignments sub-object harvested from the body text. Spec: IF [bool-expr] THEN <stmt> executes <stmt> only when the condition is truthy. Unlike FanucGoto's conditional form there is no jump — the body affects the current block only, no source splice, no label scan, no iteration watchdog. The most common body shape is a single Custom Macro B assignment (#nnn = <expr>); multiple assignments in one body are also accepted and lifted together. Condition is held as a string at parsing time so VariableEvaluatorSyntax's pass-2 tree walk can substitute it to a numeric JsonValue in place; the FanucIfThenSyntax tail then reads the resolved node polymorphically via the same ReadCondition shape used by FanucGotoSyntax. public class FanucIfThen Inheritance object FanucIfThen Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Applied Whether the body actually fired on this block. False on conditions that evaluated to zero, on conditions the evaluator could not resolve, and on bodies that did not parse as one or more assignments (a G-code-only body for example, currently unsupported and warned). The host block is preserved in either case so diagnostic readers can still see the IF-THEN call site. public bool Applied { get; set; } Property Value bool BodyText Raw body text after the THEN keyword, retained verbatim for diagnostics and round-trip visibility. The structured sub-section actually lifted on a truthy condition lives at Parsing.FanucIfThen.PendingAssignments, populated by the parsing syntax via NcSyntaxUtil's GrabTagAssignment. public string BodyText { get; set; } Property Value string Condition Raw boolean expression text from inside the IF [...] brackets at Parsing time; substituted to a numeric JsonValue in place by VariableEvaluatorSyntax's pass-2 tree walk when the expression evaluates successfully. The original text survives at Formula.FanucIfThen.Condition. Note: not written on the host-level stamp; the gate outcome lives at ConditionEvaluated. public string Condition { get; set; } Property Value string ConditionEvaluated Tri-state outcome of evaluating the IF-form's boolean condition, stamped on the host block by FanucIfThenSyntax: true — condition met (body fires). false — condition not met (body skipped silently). null — evaluator could not produce a finite truth value (vacant variable, parse error, NaN / ±∞). The original expression text is preserved at Formula.FanucIfThen.Condition by VariableEvaluatorSyntax. public bool? ConditionEvaluated { get; set; } Property Value bool?"
  },
  "api/Hi.NcParsers.Keywords.FanucMacroCall.html": {
    "href": "api/Hi.NcParsers.Keywords.FanucMacroCall.html",
    "title": "Class FanucMacroCall | HiAPI-C# 2025",
    "summary": "Class FanucMacroCall Namespace Hi.NcParsers.Keywords Assembly HiMech.dll One-shot custom-macro-call record written by FanucMacroCallSyntax. Lives on both the G65 host block (the caller) and every inlined block of the macro body — so a cache-dump reader can land on any block inside the macro and immediately see “this block belongs to a G65 call of FileName with these argument bindings” without back-walking to find the host. Each inlined block additionally carries the resolved Vars.Local #1-#26 bindings derived from Args (see FanucMacroArgumentMap), so LocalVariableLookup resolves macro args in a single-block lookup. Frame isolation is structural: caller blocks never have Vars.Local written, so after the macro body ends, the next caller block reads null for any #1-#26 without any explicit frame marker. public class FanucMacroCall Inheritance object FanucMacroCall Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Args Argument-letter → numeric-value map captured from the call line (e.g., G65 P9100 A1.5 B2. ⇒ { “A”: 1.5, “B”: 2.0 }). The matching Vars.Local bindings on each inlined block are derived from this via the Type-I argument-letter map (FanucMacroArgumentMap). public JsonObject Args { get; set; } Property Value JsonObject FileName Bare matched file name (e.g. “O9100.NC”). The resolver tries several fallback patterns (FilenamePatterns); this records which one hit. JSON-portable across environments — the folder context lives on the host's SubProgramFolderConfig dependency, not encoded here. public string FileName { get; set; } Property Value string L Repeat count from the L parameter; defaults to 1 when absent. public int L { get; set; } Property Value int P Macro program number from the P parameter (e.g., 9100 for O9100). public int P { get; set; } Property Value int Term Triggering keyword (always “G65”). public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.FanucModalMacro.html": {
    "href": "api/Hi.NcParsers.Keywords.FanucModalMacro.html",
    "title": "Class FanucModalMacro | HiAPI-C# 2025",
    "summary": "Class FanucModalMacro Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Modal-macro-call record left by FanucModalMacroSyntax. Carries Fanuc G66 setup state forward block-to-block until cancelled by G67. The section is also written on the G67 block itself (with Term = “G67”) so cache dumps show the cancel edge; subsequent blocks then carry no section at all. Per-block expansion of the modal call into an actual macro inline at every positioning move is not yet implemented — a FanucModalMacro--NotExpanded warning is emitted on the setup block to flag the simulation gap. The setup state itself is captured faithfully so external tooling can detect \"this block sits inside a G66 modal\" via the carried section. public class FanucModalMacro Inheritance object FanucModalMacro Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Args Argument-letter → numeric-value map captured from the G66 setup line. Null on a G67 cancel block. public JsonObject Args { get; set; } Property Value JsonObject FileName Bare matched file name (e.g. “O9000.NC”) that would supply the modal-call macro body. Null on a G67 cancel block or when the file could not be resolved at the setup site. Same JSON-portable form as FileName — the folder context lives on the host's SubProgramFolderConfig dependency, not encoded here. public string FileName { get; set; } Property Value string L Repeat count from the L parameter; defaults to 1 when absent. Null on a G67 cancel block. public int? L { get; set; } Property Value int? P Macro program number from the P parameter on the G66 setup. Null on a G67 cancel block. public int? P { get; set; } Property Value int? Term Triggering keyword: “G66” for setup / modal-active blocks, “G67” for the cancel block. Carried blocks downstream of a G66 setup mirror the setup section verbatim. public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.FanucPathSmoothing.html": {
    "href": "api/Hi.NcParsers.Keywords.FanucPathSmoothing.html",
    "title": "Class FanucPathSmoothing | HiAPI-C# 2025",
    "summary": "Class FanucPathSmoothing Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section data holder for IFanucPathSmoothingDef. public class FanucPathSmoothing : PathSmoothing, IFanucPathSmoothingDef, IPathSmoothingDef Inheritance object PathSmoothing FanucPathSmoothing Implements IFanucPathSmoothingDef IPathSmoothingDef Inherited Members PathSmoothing.IsEnabled PathSmoothing.Term object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Level Fanuc G05.1 R precision / smoothness level number (typically 1..10). null when the source NC line did not specify R. Ignored when IsEnabled is false. public int? Level { get; set; } Property Value int?"
  },
  "api/Hi.NcParsers.Keywords.FanucProgramNumber.html": {
    "href": "api/Hi.NcParsers.Keywords.FanucProgramNumber.html",
    "title": "Class FanucProgramNumber | HiAPI-C# 2025",
    "summary": "Class FanucProgramNumber Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Fanuc-family program identifier header that follows a TapeBoundary line — e.g. O1234 or <O1234>. Wrapper records the surface form so a parsed block can be emitted back to the original notation. public class FanucProgramNumber Inheritance object FanucProgramNumber Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields WrapperAngle Wrapper value for the angle-bracketed form: <O1234>. public const string WrapperAngle = \"Angle\" Field Value string Remarks Fanuc 30i / 31i / 32i extended program-name notation. Some CAM post-processors emit this at the head of subprogram files. WrapperNone Wrapper value for the bare form: O1234. public const string WrapperNone = \"None\" Field Value string Properties Number The numeric portion of the program identifier, as written (no leading zero normalization). public string Number { get; set; } Property Value string Wrapper Surface form of the wrapping symbols around the O token — one of WrapperNone or WrapperAngle. New values may be added as additional notations are observed; consumers should treat unknown values as round-trip-only. public string Wrapper { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.FanucWhileDo.html": {
    "href": "api/Hi.NcParsers.Keywords.FanucWhileDo.html",
    "title": "Class FanucWhileDo | HiAPI-C# 2025",
    "summary": "Class FanucWhileDo Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Fanuc Custom Macro B WHILE/END bounded-loop record. Stamped on the host block by FanucWhileDoSyntax after the control-flow decision has been made; produced earlier by FanucWhileDoParsingSyntax as a parsing-stage sub-section (Parsing.FanucWhileDo) carrying the raw captured fields. Two phrases map to the same shape, distinguished by Term: WHILE [<bool-expr>] DO <m> — loop entry. Condition holds the expression text from inside the brackets at parsing time; substituted to a numeric JsonValue by VariableEvaluatorSyntax in place. ConditionEvaluated carries the host-level truthy outcome at stamp time. END <m> — loop terminator. Carries no condition; unconditionally reverse-jumps to the matching WHILE block on every execution (re-evaluation of the entry condition is the WHILE block's responsibility). LoopId is the spec-named \"identification number for nesting\" (the m in DO m / END m). Nested loops must use distinct LoopIds; matching is by exact value. Same-LoopId nesting is spec-undefined and not given special handling here. Active loop frames are carried block-to-block via the top-level WhileFrames JSON section (a JsonObject keyed by LoopId-as-string, each entry recording the BeginLineNo of the WHILE block that opened that frame). Carried by ModalCarrySyntax as part of its Logic tracked keys (mutated in Evaluation, must reach Logic-stage consumers and downstream blocks unchanged). public class FanucWhileDo Inheritance object FanucWhileDo Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Condition Raw boolean expression text from inside the WHILE's [...] brackets at Parsing time; substituted to a numeric JsonValue in place by VariableEvaluatorSyntax when the expression evaluates successfully. The original text survives at Formula.FanucWhileDo.Condition. Null on the END phrase. Note: not written on the host-level stamp; the gate outcome lives at ConditionEvaluated. public string Condition { get; set; } Property Value string ConditionEvaluated Tri-state outcome of evaluating the WHILE's boolean condition, stamped on the host block by FanucWhileDoSyntax: true — condition met (body executes; loop continues). false — condition not met (loop exits; forward-jump past matching END). null — evaluator could not produce a finite truth value (vacant variable, parse error, NaN / ±∞); loop exits defensively and emits FanucWhileDo--ConditionNotEvaluated. Null also on the END phrase (no condition to evaluate). The original expression text is preserved at Formula.FanucWhileDo.Condition by VariableEvaluatorSyntax. public bool? ConditionEvaluated { get; set; } Property Value bool? LoopId The m identifier from DO m / END m — the spec-named “identification number for nesting”. Nested loops use distinct LoopIds (1–3 typical); WHILE and END pair by exact match. public int LoopId { get; set; } Property Value int Term Triggering phrase: “WHILE...DO” for the loop entry form, “END” for the loop terminator. public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Feedrate.html": {
    "href": "api/Hi.NcParsers.Keywords.Feedrate.html",
    "title": "Class Feedrate | HiAPI-C# 2025",
    "summary": "Class Feedrate Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section key holder + concrete implementation for IFeedrateDef. public class Feedrate : IFeedrateDef Inheritance object Feedrate Implements IFeedrateDef Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties FeedrateValue Feedrate value (mm/min for G94, mm/rev for G95). public double FeedrateValue { get; set; } Property Value double Term “G94” (per minute) or “G95” (per revolution). See IsoKeywords. public string Term { get; set; } Property Value string Unit Display unit derived from Term: “mm/min” for G94, “mm/rev” for G95. public string Unit { get; set; } Property Value string Methods GetUnit(string) Returns the display unit for a given feedrate term. public static string GetUnit(string term) Parameters term string Returns string"
  },
  "api/Hi.NcParsers.Keywords.Generic.ArcCenterSource.html": {
    "href": "api/Hi.NcParsers.Keywords.Generic.ArcCenterSource.html",
    "title": "Class ArcCenterSource | HiAPI-C# 2025",
    "summary": "Class ArcCenterSource Namespace Hi.NcParsers.Keywords.Generic Assembly HiMech.dll Where an arc's center came from when it was NOT read off the arc block's own words — the values of CenterSource. An arc whose block states its center (I/J/K offsets, absolute I/J/K, R) carries no stamp at all. Written by HeidenhainCircularMotionSyntax (the klartext C … DR± block never carries center words); read by the NcOpt splition write-back, which must know whether the block's text has center words to rebuild per fragment and whether the center even survives a split. public static class ArcCenterSource Inheritance object ArcCenterSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields ModalCircleCenter The modal circle-center section a preceding klartext CC block set (HeidenhainCircleCenterSyntax, absolute program coordinates). The center lives on the CC line, not on the arc block, so the fragments of a split arc share it unchanged and only their endpoint words move. public const string ModalCircleCenter = \"ModalCircleCenter\" Field Value string StartPoint The arc's own start point supplied at least one in-plane center component — the parser's degrade for a klartext arc with no CC ever given, or with a CC that left an in-plane axis unstated. A split cannot share such a center: on a re-parse every fragment would fill the missing component from its own start point. public const string StartPoint = \"StartPoint\" Field Value string"
  },
  "api/Hi.NcParsers.Keywords.Generic.IsoKeywords.html": {
    "href": "api/Hi.NcParsers.Keywords.Generic.IsoKeywords.html",
    "title": "Class IsoKeywords | HiAPI-C# 2025",
    "summary": "Class IsoKeywords Namespace Hi.NcParsers.Keywords.Generic Assembly HiMech.dll ISO/RS274 standard G-code and M-code constants. Shared across Fanuc, Mazak, Okuma, and other ISO-compatible controllers. Brand-specific codes belong in their own keyword classes (e.g., FanucKeywords, Siemens, Heidenhain). public static class IsoKeywords Inheritance object IsoKeywords Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields CannedCycleCodes All canned cycle codes. public static readonly string[] CannedCycleCodes Field Value string[] CoolantCodes All coolant control codes (M07 mist, M08 flood, M09 off). public static readonly string[] CoolantCodes Field Value string[] G00 Rapid positioning — moves all axes at maximum traverse rate to the target. public const string G00 = \"G00\" Field Value string G01 Linear interpolation — moves in a straight line at the programmed feedrate. public const string G01 = \"G01\" Field Value string G02 Circular interpolation clockwise — arc motion in the active plane at the programmed feedrate. Center defined by I/J/K offsets or R radius. public const string G02 = \"G02\" Field Value string G03 Circular interpolation counter-clockwise — arc motion in the active plane at the programmed feedrate. Center defined by I/J/K offsets or R radius. public const string G03 = \"G03\" Field Value string G17 XY plane selection — arcs and canned cycles operate in the XY plane. Default on most controllers. public const string G17 = \"G17\" Field Value string G18 ZX plane selection — arcs and canned cycles operate in the ZX plane. public const string G18 = \"G18\" Field Value string G19 YZ plane selection — arcs and canned cycles operate in the YZ plane. public const string G19 = \"G19\" Field Value string G20 Inch unit mode — axis values and feedrates are interpreted in inches (inch/inch-per-min). Not supported by the HiNC pipeline; emits an Unsupported Error. public const string G20 = \"G20\" Field Value string G21 Metric unit mode — axis values and feedrates are interpreted in millimetres (mm/mm-per-min). HiNC default. public const string G21 = \"G21\" Field Value string G28 Reference point return — moves through an intermediate point, then to the machine reference (home) position. public const string G28 = \"G28\" Field Value string G40 Cutter radius compensation cancel — deactivates G41/G42 tool radius offset. public const string G40 = \"G40\" Field Value string G41 Cutter radius compensation left — offsets tool path to the left of the programmed path by the tool radius. public const string G41 = \"G41\" Field Value string G42 Cutter radius compensation right — offsets tool path to the right of the programmed path by the tool radius. public const string G42 = \"G42\" Field Value string G43 Tool length compensation (+) — applies positive-direction tool height offset from the offset table. public const string G43 = \"G43\" Field Value string G44 Tool length compensation (−) — applies negative-direction tool height offset from the offset table. public const string G44 = \"G44\" Field Value string G49 Tool length compensation cancel — deactivates G43/G44 tool height offset. public const string G49 = \"G49\" Field Value string G52 Local coordinate system — sets a temporary coordinate offset relative to the active work coordinate system. public const string G52 = \"G52\" Field Value string G53 Machine coordinate selection — non-modal, one-shot. Axis values specify machine coordinates directly, bypassing all work offsets. public const string G53 = \"G53\" Field Value string G53p1 Tool axis direction control — non-modal, one-shot. Positions rotary axes to align with the active tilted work plane (G68.2). Requires G68.2 active. public const string G53p1 = \"G53.1\" Field Value string G54 Work coordinate system 1 — first standard work offset (most commonly used). public const string G54 = \"G54\" Field Value string G54Series All standard work coordinate offsets: G54–G59 plus the extended G59xSeries. public static readonly string[] G54Series Field Value string[] G55 Work coordinate system 2. public const string G55 = \"G55\" Field Value string G56 Work coordinate system 3. public const string G56 = \"G56\" Field Value string G57 Work coordinate system 4. public const string G57 = \"G57\" Field Value string G58 Work coordinate system 5. public const string G58 = \"G58\" Field Value string G59 Work coordinate system 6. public const string G59 = \"G59\" Field Value string G59xSeries The extended work coordinate offsets G59.1–G59.9 — an extension no brand parameter table maps (Fanuc holds G54–G59 at #5221+ and G54.1 P1–P48 at #7001+, nothing for these), carried by a brand-neutral IsoCoordinateTable. public static readonly string[] G59xSeries Field Value string[] G68 Coordinate rotation — rotates the XY program coordinate system around a center point by an angle R. public const string G68 = \"G68\" Field Value string G68p2 Tilted work plane (5-axis) — defines an inclined coordinate system via Euler angles (I/J/K) and an origin (X/Y/Z). public const string G68p2 = \"G68.2\" Field Value string G69 Coordinate rotation / tilted work plane cancel — deactivates G68 or G68.2. public const string G69 = \"G69\" Field Value string G70 Inch unit mode — the RS-274-D / Fanuc G-code system C / Syntec spelling of G20. Same Group 06 modal slot and behaviour (not supported; emits an Unsupported Error). Fanuc lathe systems A/B use this code as a finishing cycle instead. public const string G70 = \"G70\" Field Value string G71 Metric unit mode — the RS-274-D / Fanuc G-code system C / Syntec spelling of G21. Same Group 06 modal slot. Fanuc lathe systems A/B use this code as a roughing cycle instead. public const string G71 = \"G71\" Field Value string G73 High-speed peck drilling cycle — drills in increments of Q with partial retract (chip breaking). public const string G73 = \"G73\" Field Value string G74 Left-hand tapping cycle — feed to Z with CCW spindle, reverse to CW, feed retract. public const string G74 = \"G74\" Field Value string G76 Fine boring cycle — feed to Z, oriented spindle stop, tool shift Q, rapid retract, shift back. public const string G76 = \"G76\" Field Value string G80 Canned cycle cancel — deactivates G81–G89. public const string G80 = \"G80\" Field Value string G81 Drilling cycle — rapid to R, feed to Z, rapid retract. public const string G81 = \"G81\" Field Value string G82 Drilling cycle with dwell — same as G81 plus dwell P seconds at bottom. public const string G82 = \"G82\" Field Value string G83 Peck drilling cycle — drills in increments of Q with full retract to R between strokes. public const string G83 = \"G83\" Field Value string G84 Right-hand tapping cycle — feed to Z with CW spindle, reverse to CCW, feed retract. public const string G84 = \"G84\" Field Value string G85 Boring cycle — rapid to R, feed to Z, feed retract. public const string G85 = \"G85\" Field Value string G86 Boring cycle — rapid to R, feed to Z, spindle stop, rapid retract. public const string G86 = \"G86\" Field Value string G87 Back boring cycle — OSS + shift, rapid to Z, shift back, spindle on, feed up to R, OSS + shift, retract. public const string G87 = \"G87\" Field Value string G89 Boring cycle with dwell — rapid to R, feed to Z, dwell P, feed retract. public const string G89 = \"G89\" Field Value string G90 Absolute positioning — axis values specify the target position directly. public const string G90 = \"G90\" Field Value string G91 Incremental positioning — axis values specify the distance to move from the current position. public const string G91 = \"G91\" Field Value string G94 Feed per minute — feedrate F is in mm/min (or inch/min). public const string G94 = \"G94\" Field Value string G95 Feed per revolution — feedrate F is in mm/rev (or inch/rev), synchronized to spindle speed. public const string G95 = \"G95\" Field Value string G98 Canned cycle return to initial level. public const string G98 = \"G98\" Field Value string G99 Canned cycle return to R-point level. public const string G99 = \"G99\" Field Value string M00 Program stop (unconditional) — halts execution; operator must press Cycle Start to resume. Modal state preserved. public const string M00 = \"M00\" Field Value string M01 Optional program stop — halts execution only when the Optional Stop switch on the panel is ON; otherwise ignored. Modal state preserved. public const string M01 = \"M01\" Field Value string M02 Program end (no rewind) — stops execution and resets modal state. public const string M02 = \"M02\" Field Value string M03 Spindle ON clockwise — starts spindle rotation in the CW direction. public const string M03 = \"M03\" Field Value string M04 Spindle ON counter-clockwise — starts spindle rotation in the CCW direction. public const string M04 = \"M04\" Field Value string M05 Spindle stop — halts spindle rotation. public const string M05 = \"M05\" Field Value string M06 Tool change — executes automatic tool change. public const string M06 = \"M06\" Field Value string M07 Coolant ON (mist) — activates a fine oil-mist / air-blast coolant stream. public const string M07 = \"M07\" Field Value string M08 Coolant ON (flood) — activates flood coolant. public const string M08 = \"M08\" Field Value string M09 Coolant OFF — deactivates all coolant. public const string M09 = \"M09\" Field Value string M30 Program end — stops execution, resets modal state, rewinds to start. public const string M30 = \"M30\" Field Value string PlaneSelectCodes All plane selection codes. public static readonly string[] PlaneSelectCodes Field Value string[] ProgramEndCodes All program end codes. public static readonly string[] ProgramEndCodes Field Value string[] ProgramStopCodes All program-stop codes (M00 unconditional, M01 optional). public static readonly string[] ProgramStopCodes Field Value string[] UnitModeCodes All unit-mode codes (Group 06). public static readonly string[] UnitModeCodes Field Value string[]"
  },
  "api/Hi.NcParsers.Keywords.Generic.MotionForm.html": {
    "href": "api/Hi.NcParsers.Keywords.Generic.MotionForm.html",
    "title": "Class MotionForm | HiAPI-C# 2025",
    "summary": "Class MotionForm Namespace Hi.NcParsers.Keywords.Generic Assembly HiMech.dll Motion interpolation form constants used in Form. Each form corresponds to a specialized INcSemantic that resolves the motion into IAct sequences. public static class MotionForm Inheritance object MotionForm Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields ClArc Circular interpolation (arc/helix) purely at cutter-location (CL) level — no machine coordinates involved. Consumed by CL-source runners (e.g. NX CLSF) whose motion semantics emit ActClArc. public const string ClArc = \"ClArc\" Field Value string ClLinear Linear interpolation at cutter-location (CL) level with per-step inverse kinematics. Used when RTCP (G43.4/TRAORI/M128) is active and rotary axes move, so the tool orientation changes during interpolation. Resolved by ClLinearMcMotionSemantic. public const string ClLinear = \"ClLinear\" Field Value string ClTeleport Non-cutting reposition purely at cutter-location (CL) level (no path swept, no machining step). Consumed by CL-source runners whose motion semantics emit ActClTeleport. public const string ClTeleport = \"ClTeleport\" Field Value string McArc Circular interpolation (arc/helix) in program coordinates, transformed to machine coordinates via ActMcXyzSpiralContour. Resolved by McArcMotionSemantic. public const string McArc = \"McArc\" Field Value string McLinear Linear interpolation in machine coordinates. McLinearMotionSemantic discriminates XYZ-only vs XYZABC by checking for rotary axis values in MachineCoordinateState. public const string McLinear = \"McLinear\" Field Value string McPolarArc Circular interpolation (arc/helix) on the polar hypothetical plane while Polar Coordinate Interpolation (Fanuc G12.1) is active. Resolved by McPolarArcMotionSemantic into ActMcPolarSpiralContour. public const string McPolarArc = \"McPolarArc\" Field Value string McPolarLinear Linear interpolation on the polar hypothetical plane while Polar Coordinate Interpolation (Fanuc G12.1) is active. Resolved by McPolarLinearMotionSemantic into ActMcPolarLinearContour. public const string McPolarLinear = \"McPolarLinear\" Field Value string"
  },
  "api/Hi.NcParsers.Keywords.Generic.html": {
    "href": "api/Hi.NcParsers.Keywords.Generic.html",
    "title": "Namespace Hi.NcParsers.Keywords.Generic | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.Keywords.Generic Classes ArcCenterSource Where an arc's center came from when it was NOT read off the arc block's own words — the values of CenterSource. An arc whose block states its center (I/J/K offsets, absolute I/J/K, R) carries no stamp at all. Written by HeidenhainCircularMotionSyntax (the klartext C … DR± block never carries center words); read by the NcOpt splition write-back, which must know whether the block's text has center words to rebuild per fragment and whether the center even survives a split. IsoKeywords ISO/RS274 standard G-code and M-code constants. Shared across Fanuc, Mazak, Okuma, and other ISO-compatible controllers. Brand-specific codes belong in their own keyword classes (e.g., FanucKeywords, Siemens, Heidenhain). MotionForm Motion interpolation form constants used in Form. Each form corresponds to a specialized INcSemantic that resolves the motion into IAct sequences."
  },
  "api/Hi.NcParsers.Keywords.Heidenhain.HeidenhainCall.html": {
    "href": "api/Hi.NcParsers.Keywords.Heidenhain.HeidenhainCall.html",
    "title": "Class HeidenhainCall | HiAPI-C# 2025",
    "summary": "Class HeidenhainCall Namespace Hi.NcParsers.Keywords.Heidenhain Assembly HiMech.dll Block-root record left on a CALL LBL/CALL PGM host block by HeidenhainSubProgramCallSyntax. Inlined callee blocks are stamped with a clone of the same record. public class HeidenhainCall Inheritance object HeidenhainCall Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties FileName Bare matched file name for a resolved CALL PGM. public string FileName { get; set; } Property Value string Name Label number/name or called program name (quotes stripped). public string Name { get; set; } Property Value string Rep Repeat count of the CALL LBL n REP m program-section-repeat form (the section between LBL n and the call line runs m extra times). Absent on the plain subprogram-call form. public int Rep { get; set; } Property Value int Skipped true when the call was consumed without inlining (unresolved program file, label not found, missing LBL 0, or the call-depth rail) — structured safe-skip, no motion effect. public bool Skipped { get; set; } Property Value bool Target Call target kind: “LBL” or “PGM”. public string Target { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Heidenhain.HeidenhainCyclCall.html": {
    "href": "api/Hi.NcParsers.Keywords.Heidenhain.HeidenhainCyclCall.html",
    "title": "Class HeidenhainCyclCall | HiAPI-C# 2025",
    "summary": "Class HeidenhainCyclCall Namespace Hi.NcParsers.Keywords.Heidenhain Assembly HiMech.dll Block-root record left on a cycle-call host block by HeidenhainCannedCycleSyntax, making the consumed call visible in cache dumps and carrying the deferred M140 retract hand-off for HeidenhainCycleRetractSyntax. public class HeidenhainCyclCall Inheritance object HeidenhainCyclCall Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties IsoTerm Mapped ISO term the call fired as; absent when the call was consumed without motion effect. public string IsoTerm { get; set; } Property Value string Number Cycle number of the definition the call resolved against. public int Number { get; set; } Property Value int Term Triggering spelling: CYCL CALL, CYCL CALL POS, M99 or M89. public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Heidenhain.HeidenhainCyclCallPos.html": {
    "href": "api/Hi.NcParsers.Keywords.Heidenhain.HeidenhainCyclCallPos.html",
    "title": "Class HeidenhainCyclCallPos | HiAPI-C# 2025",
    "summary": "Class HeidenhainCyclCallPos Namespace Hi.NcParsers.Keywords.Heidenhain Assembly HiMech.dll Block-root section carrying the coordinates last programmed with CYCL CALL POS: the reference the control uses for the I-prefixed words of a later CYCL CALL POS (its error 1A0-0108 “Incremental values without reference” names exactly these coordinates, not the tool position). Written by HeidenhainCannedCycleSyntax on the block whose POS call resolved and then single-step carried on every following block (the MachiningCycleDef pattern); a later POS call overwrites the axes it programs and keeps the others, and a new CYCL DEF does not clear it. An axis that is absent here has no reference: the control refuses an increment on it, the simulation warns and falls back to the last programmed position. public class HeidenhainCyclCallPos Inheritance object HeidenhainCyclCallPos Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties X X coordinate of the last CYCL CALL POS, resolved to absolute; absent until a POS call programmed X. public double? X { get; set; } Property Value double? Y Y coordinate of the last CYCL CALL POS, resolved to absolute; absent until a POS call programmed Y. public double? Y { get; set; } Property Value double? Z Z coordinate (the pre-position) of the last CYCL CALL POS, resolved to absolute; absent until a POS call programmed Z. public double? Z { get; set; } Property Value double?"
  },
  "api/Hi.NcParsers.Keywords.Heidenhain.HeidenhainGoto.html": {
    "href": "api/Hi.NcParsers.Keywords.Heidenhain.HeidenhainGoto.html",
    "title": "Class HeidenhainGoto | HiAPI-C# 2025",
    "summary": "Class HeidenhainGoto Namespace Hi.NcParsers.Keywords.Heidenhain Assembly HiMech.dll Heidenhain FN 9–12 conditional jump record (FN 12: IF +Q1 LT +5 GOTO LBL n). Two lifetimes share the shape: Parsing.HeidenhainGoto — written by HeidenhainGotoParsingSyntax for all four opcodes, in both the spaced standard spelling and the compressed post spelling (FN12:IF+Q94 LT+1GOTOLBL\"NAME\"). block-root HeidenhainGoto — stamped by HeidenhainGotoSyntax after the control-flow decision, with Fired flipped true on a successful redirect. Unlike the Fanuc / Siemens jump records the condition is not one expression string: the klartext jump grammar is strictly <value> <comparator> <value>, and the Heidenhain expression grammar deliberately has no comparison layer (its bare-word rejection is what keeps the evaluator's Parsing-tree pass off non-expression strings). The parsing owner therefore pre-normalises the statement: Lhs/Rhs are captured as separate value operands (pure literals typed numeric at capture, Q references kept as strings for the evaluator's pass-2 substitution) and the comparator spelling is normalised to the shared comparison words (EQU→EQ; NE/GT/LT as written). The comparison itself happens in the evaluation syntax. Klartext has no unconditional jump statement and no direction mnemonic — a TNC label is unique per program, so the consumer scans the whole host file and takes the first matching definition (LBL n / LBL \"name\"), forward or backward alike. public class HeidenhainGoto Inheritance object HeidenhainGoto Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields OpEq Op normalised from the klartext EQU spelling. public const string OpEq = \"EQ\" Field Value string OpGt Op for the klartext GT comparator. public const string OpGt = \"GT\" Field Value string OpLt Op for the klartext LT comparator. public const string OpLt = \"LT\" Field Value string OpNe Op for the klartext NE comparator. public const string OpNe = \"NE\" Field Value string TermFn10 Term of the FN 10 (not-equal) jump. public const string TermFn10 = \"FN10\" Field Value string TermFn11 Term of the FN 11 (greater-than) jump. public const string TermFn11 = \"FN11\" Field Value string TermFn12 Term of the FN 12 (less-than) jump. public const string TermFn12 = \"FN12\" Field Value string TermFn9 Term of the FN 9 (equal) jump. public const string TermFn9 = \"FN9\" Field Value string Properties ConditionEvaluated Tri-state comparison outcome stamped by the evaluation syntax: true — condition met (jump proceeds); false — not met (falls through silently); null — an operand did not resolve to a finite numeric (warns HeidenhainGoto–ConditionNotEvaluated and falls through — the FN 18 SYSREAD target staying vacant is the designed source of this state). public bool? ConditionEvaluated { get; set; } Property Value bool? Fired True when the redirect actually replaced the source layer. public bool Fired { get; set; } Property Value bool Label Target label number or name as written (quotes stripped: GOTOLBL\"SLOW_FEED\" captures SLOW_FEED). Numeric labels canonicalize at match time (“01” ≡ 1 on a TNC). If a quoted name collides with a set Q spelling the evaluator may have substituted a numeric here; the consumer recovers the original text from the Formula.HeidenhainGoto.Label mirror. public string Label { get; set; } Property Value string Lhs Left comparison operand. Parsing-side a pure numeric literal is typed numeric at capture; a Q-reference operand (\"+Q94\") stays a string and is substituted in place by VariableEvaluatorSyntax's pass-2 walk when it resolves (original text mirrored to Formula.HeidenhainGoto.Lhs). A still-string operand at the evaluation syntax means “unresolved” — the jump falls through with HeidenhainGoto–ConditionNotEvaluated. public string Lhs { get; set; } Property Value string Op Comparator normalised to the shared comparison words: one of OpEq, OpNe, OpGt, OpLt. Captured from the spelled word (which on a real TNC always agrees with the opcode). public string Op { get; set; } Property Value string Rhs Right comparison operand; same contract as Lhs. public string Rhs { get; set; } Property Value string Term Statement opcode: one of TermFn9 … TermFn12, as spelled in the source (whitespace dropped). public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Heidenhain.HeidenhainLbl.html": {
    "href": "api/Hi.NcParsers.Keywords.Heidenhain.HeidenhainLbl.html",
    "title": "Class HeidenhainLbl | HiAPI-C# 2025",
    "summary": "Class HeidenhainLbl Namespace Hi.NcParsers.Keywords.Heidenhain Assembly HiMech.dll Block-root record left on a consumed LBL marker block by HeidenhainSubProgramReturnSyntax. A plain definition marker produces no motion; the record keeps the label visible for cache dumps (and the P5 jump family). public class HeidenhainLbl Inheritance object HeidenhainLbl Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Name Label number or name (quotes stripped); “0” is the end-of-subprogram sentinel. public string Name { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Heidenhain.ICyclDef.html": {
    "href": "api/Hi.NcParsers.Keywords.Heidenhain.ICyclDef.html",
    "title": "Interface ICyclDef | HiAPI-C# 2025",
    "summary": "Interface ICyclDef Namespace Hi.NcParsers.Keywords.Heidenhain Assembly HiMech.dll JSON section schema for Heidenhain CYCL DEF blocks. The CyclHead string captures either the cycle title (e.g. “DATUM SETTING”) or a parameter line (e.g. “Q339=+1”). public interface ICyclDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties CyclHead Head content of the CYCL DEF (can be title like “DATUM SETTING” or parameters like “Q339=+1”). string CyclHead { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Heidenhain.MachiningCycleDef.html": {
    "href": "api/Hi.NcParsers.Keywords.Heidenhain.MachiningCycleDef.html",
    "title": "Class MachiningCycleDef | HiAPI-C# 2025",
    "summary": "Class MachiningCycleDef Namespace Hi.NcParsers.Keywords.Heidenhain Assembly HiMech.dll Block-root section carrying the stored Heidenhain machining-cycle definition (the CYCL DEF 2xx “setup half”). Written by HeidenhainCannedCycleSyntax on every block (self-carrying modal state, the P1 datum-shift pattern) — a klartext definition never executes by itself; execution is gated on CYCL CALL/M99 (call-once) or M89 (modal call on positioning blocks), which convert this store into a direct ISO cycle sub-section under Parsing. public class MachiningCycleDef Inheritance object MachiningCycleDef Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Armable Whether a call can execute this definition. false for unsupported cycle numbers and for definitions whose required parameters were missing or non-literal. public bool Armable { get; set; } Property Value bool Modal true while M89 modality is active: the cycle fires on every positioning block until M99 clears it or a new CYCL DEF replaces the store. public bool Modal { get; set; } Property Value bool Number Heidenhain cycle number (e.g. 232, 251, 252, 253, 200). public int Number { get; set; } Property Value int Params Mapped ISO parameter slots (absolute Z/R, optional X/Y/Q/F/P) ready for the direct Parsing.G8x section on a call block. public JsonObject Params { get; set; } Property Value JsonObject Term Mapped ISO canned-cycle term (G81/G82/G83). Absent when the cycle is recognized but not simulated. public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Heidenhain.html": {
    "href": "api/Hi.NcParsers.Keywords.Heidenhain.html",
    "title": "Namespace Hi.NcParsers.Keywords.Heidenhain | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.Keywords.Heidenhain Classes HeidenhainCall Block-root record left on a CALL LBL/CALL PGM host block by HeidenhainSubProgramCallSyntax. Inlined callee blocks are stamped with a clone of the same record. HeidenhainCyclCall Block-root record left on a cycle-call host block by HeidenhainCannedCycleSyntax, making the consumed call visible in cache dumps and carrying the deferred M140 retract hand-off for HeidenhainCycleRetractSyntax. HeidenhainCyclCallPos Block-root section carrying the coordinates last programmed with CYCL CALL POS: the reference the control uses for the I-prefixed words of a later CYCL CALL POS (its error 1A0-0108 “Incremental values without reference” names exactly these coordinates, not the tool position). Written by HeidenhainCannedCycleSyntax on the block whose POS call resolved and then single-step carried on every following block (the MachiningCycleDef pattern); a later POS call overwrites the axes it programs and keeps the others, and a new CYCL DEF does not clear it. An axis that is absent here has no reference: the control refuses an increment on it, the simulation warns and falls back to the last programmed position. HeidenhainGoto Heidenhain FN 9–12 conditional jump record (FN 12: IF +Q1 LT +5 GOTO LBL n). Two lifetimes share the shape: Parsing.HeidenhainGoto — written by HeidenhainGotoParsingSyntax for all four opcodes, in both the spaced standard spelling and the compressed post spelling (FN12:IF+Q94 LT+1GOTOLBL\"NAME\"). block-root HeidenhainGoto — stamped by HeidenhainGotoSyntax after the control-flow decision, with Fired flipped true on a successful redirect. Unlike the Fanuc / Siemens jump records the condition is not one expression string: the klartext jump grammar is strictly <value> <comparator> <value>, and the Heidenhain expression grammar deliberately has no comparison layer (its bare-word rejection is what keeps the evaluator's Parsing-tree pass off non-expression strings). The parsing owner therefore pre-normalises the statement: Lhs/Rhs are captured as separate value operands (pure literals typed numeric at capture, Q references kept as strings for the evaluator's pass-2 substitution) and the comparator spelling is normalised to the shared comparison words (EQU→EQ; NE/GT/LT as written). The comparison itself happens in the evaluation syntax. Klartext has no unconditional jump statement and no direction mnemonic — a TNC label is unique per program, so the consumer scans the whole host file and takes the first matching definition (LBL n / LBL \"name\"), forward or backward alike. HeidenhainLbl Block-root record left on a consumed LBL marker block by HeidenhainSubProgramReturnSyntax. A plain definition marker produces no motion; the record keeps the label visible for cache dumps (and the P5 jump family). MachiningCycleDef Block-root section carrying the stored Heidenhain machining-cycle definition (the CYCL DEF 2xx “setup half”). Written by HeidenhainCannedCycleSyntax on every block (self-carrying modal state, the P1 datum-shift pattern) — a klartext definition never executes by itself; execution is gated on CYCL CALL/M99 (call-once) or M89 (modal call on positioning blocks), which convert this store into a direct ISO cycle sub-section under Parsing. Interfaces ICyclDef JSON section schema for Heidenhain CYCL DEF blocks. The CyclHead string captures either the cycle title (e.g. “DATUM SETTING”) or a parameter line (e.g. “Q339=+1”)."
  },
  "api/Hi.NcParsers.Keywords.IArcMotionDef.html": {
    "href": "api/Hi.NcParsers.Keywords.IArcMotionDef.html",
    "title": "Interface IArcMotionDef | HiAPI-C# 2025",
    "summary": "Interface IArcMotionDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Arc motion data written by CircularMotionSyntax. Stored under the MotionEvent JSON section alongside IMotionEventDef properties. The arc plane is read from the modal PlaneSelect section via GetPlaneNormalDir(JsonObject) rather than cached on the event — same source of truth as IsoG68RotationSyntax. public interface IArcMotionDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples \"MotionEvent\": { \"Form\": \"McArc\", \"ArcCenter\": { \"X\": 10.0, \"Y\": 5.0, \"Z\": 0.0 }, \"IsCcw\": false, \"AdditionalCircleNum\": 0 } Properties AdditionalCircleNum Number of additional full circles (for helix with L parameter). int AdditionalCircleNum { get; } Property Value int ArcCenter Arc center in program coordinates (absolute). object ArcCenter { get; } Property Value object CenterSource Where the center came from when it is NOT stated by this block's own words — a ArcCenterSource value (ModalCircleCenter: the modal klartext CC section; StartPoint: the arc's own start point, the missing- or partial-CC degrade). Absent for a block that states its center (I/J/K offsets, absolute I/J/K — see IsIjkAbsolute — or R). Read by the NcOpt splition write-back: a modal-center arc splits into fragments that keep the block's words (nothing to rebuild) around the unchanged CC line; a start-point center cannot be shared by fragments at all. string CenterSource { get; } Property Value string IsCcw True for G03 (CCW), false for G02 (CW). bool IsCcw { get; } Property Value bool IsIjkAbsolute True when the source block's I/J/K words addressed the center as absolute program coordinates (Heidenhain DIN/ISO, G90 in effect). Stamped only when true — absent means the ordinary start-to-center offsets. Read by the NcOpt splition write-back, which must emit the same absolute center on every fragment instead of per-fragment offsets. bool IsIjkAbsolute { get; } Property Value bool"
  },
  "api/Hi.NcParsers.Keywords.ICannedCycleDef.html": {
    "href": "api/Hi.NcParsers.Keywords.ICannedCycleDef.html",
    "title": "Interface ICannedCycleDef | HiAPI-C# 2025",
    "summary": "Interface ICannedCycleDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Canned cycle modal state (Group 09). Captures which cycle is currently active, its return mode (G98/G99), and the resolved absolute parameter set used for modal lookback. Written by CannedCycleResolveSyntax on every block that belongs to the canned-cycle group: cycle code present (G81/G82/G83/G73/G84/G74/G85/G86/G89/G76/G87), modal repeat (cycle still active, only coordinates given), or explicit cancel (G80). Term = \"G80\" is the explicit-cancel sentinel used by FindPreviousActiveCycle(LazyLinkedListNode<SyntaxPiece>, string[]) to terminate modal lookback without ambiguity; regular blocks (e.g. G00 X.. Y..) simply omit the section entirely. public interface ICannedCycleDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples // Active G81 block \"CannedCycle\": { \"Term\": \"G81\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 20, \"Y\": 52, \"Z\": -31, \"R\": 3, \"F\": 600 } } // Explicit cancel block (G80 alone) \"CannedCycle\": { \"Term\": \"G80\" } Properties Params Resolved absolute cycle parameters: X, Y, Z, R, Q, F, P, K. Used for modal lookback so the next repeat block can merge its own overrides with the previously-resolved values. Absent on G80 blocks. JsonObject Params { get; set; } Property Value JsonObject ReturnMode Return level mode: “G98” (initial Z) or “G99” (R-point). Only meaningful when Term is an active cycle code; absent on G80 blocks. string ReturnMode { get; set; } Property Value string Term NC term of the canned-cycle-group code on this block (“G81”, “G82”, ..., “G89”, or “G80” for explicit cancel). Modal-repeat blocks carry the same term as the most recent active cycle. string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.ICompoundMotionDef.html": {
    "href": "api/Hi.NcParsers.Keywords.ICompoundMotionDef.html",
    "title": "Interface ICompoundMotionDef | HiAPI-C# 2025",
    "summary": "Interface ICompoundMotionDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Compound motion section definition for commands that produce multiple sub-operations (G28, G53.1, G81, G82, etc.). Contains a ItemsKey array resolved by Hi.NcParsers.Semantics.CompoundMotionSemanticUtil. Item types (discriminated by key presence): Hi.Motion — rapid/feed linear motion (IMotionEventDef + IMachineCoordinateStateDef) Dwell — pause (Time in seconds) SpindleControl — spindle direction change (Direction) SpindleOrientation — oriented spindle stop (OSS) (Angle_deg) public interface ICompoundMotionDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Term CNC term that triggered this compound motion (e.g., “G28”, “G81”). string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.ICoolantDef.html": {
    "href": "api/Hi.NcParsers.Keywords.ICoolantDef.html",
    "title": "Interface ICoolantDef | HiAPI-C# 2025",
    "summary": "Interface ICoolantDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Coolant state (M07 mist / M08 flood / M09 off). Written by CoolantSyntax. Modal — persists until changed. IsOn is the on/off convenience flag (true for M07 and M08, false for M09). Mode carries the abstract kind (Flood / Mist / Off) for consumers that need to distinguish flood vs mist. public interface ICoolantDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples \"Coolant\": { \"IsOn\": true, \"Mode\": \"Flood\" } \"Coolant\": { \"IsOn\": true, \"Mode\": \"Mist\" } \"Coolant\": { \"IsOn\": false, \"Mode\": \"Off\" } Properties IsOn Whether any coolant is currently active. bool IsOn { get; set; } Property Value bool Mode Abstract coolant mode (Flood / Mist / Off). string Mode { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.IDwellDef.html": {
    "href": "api/Hi.NcParsers.Keywords.IDwellDef.html",
    "title": "Interface IDwellDef | HiAPI-C# 2025",
    "summary": "Interface IDwellDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Dwell/pause section definition for use inside Sequence items. Resolved by Hi.NcParsers.Semantics.CompoundMotionSemanticUtil into ActDelay. public interface IDwellDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples { \"Dwell\": { \"Time\": 0.5 } } Properties Time Dwell time in seconds. double Time { get; set; } Property Value double"
  },
  "api/Hi.NcParsers.Keywords.IFanucHpccDef.html": {
    "href": "api/Hi.NcParsers.Keywords.IFanucHpccDef.html",
    "title": "Interface IFanucHpccDef | HiAPI-C# 2025",
    "summary": "Interface IFanucHpccDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Block-root section recording a consumed bare Fanuc G05 P{n} (HPCC family selection), written by FanucPathSmoothingSyntax. P is a function-selection code — not a quantity, dwell time, or look-ahead block count. P10000 enters high-precision contour control (HPCC: RISC-board multi-block look-ahead, pre-interpolation acceleration/deceleration, curvature-based feed clamping); P0 cancels it. P10001–P10999 call high-speed cycle machining: the control executes cycle data pre-registered in its variable area — real axis motion, so an offline run that ignores the call misses that machining (FanucPathSmoothingSyntax emits a Warning for it). Small P values select the high-speed remote buffer modes (binary DNC transfer; exact semantics vary by model). HPCC itself never alters the programmed coordinates, so P10000/P0 are recognized, intentionally not simulated, safe offline (the SiemensStopreSyntax pattern). Deliberately separate from the modal PathSmoothing section (G05.1, IFanucPathSmoothingDef): this section is block-local like Stopre and is NOT tracked by ModalCarrySyntax — it exists for diagnostics and bidirectional NC-text reconstruction only. public interface IFanucHpccDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples \"FanucHpcc\": { \"Term\": \"G05\", \"IsEnabled\": true, \"FunctionCode\": 10000 } Properties FunctionCode Raw P function-selection value, preserved for NC-text write-back; null when the source block carried no P word or the P value was an unevaluated variable/expression. int? FunctionCode { get; set; } Property Value int? IsEnabled True only for P10000 (HPCC entered); false for the cancel (P0) and the non-HPCC functions. bool IsEnabled { get; set; } Property Value bool Term Source spelling that carried the selection (G05 or G5). string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.IFanucPathSmoothingDef.html": {
    "href": "api/Hi.NcParsers.Keywords.IFanucPathSmoothingDef.html",
    "title": "Interface IFanucPathSmoothingDef | HiAPI-C# 2025",
    "summary": "Interface IFanucPathSmoothingDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Fanuc-specific path smoothing state written by FanucPathSmoothingSyntax. Extends IPathSmoothingDef with the Fanuc G05.1 R argument (precision / smoothness level number, R1..R10 mapping to controller-internal tuning macro variables). Q is binary in current Fanuc firmware (Q0 disable / Q1 enable), so IsEnabled covers it directly — no raw Q field is stored. JSON section key remains nameof(PathSmoothing) so generic readers (cache dumps, modal carry, UI) can cast to IPathSmoothingDef across all controller brands; brand-specific readers cast to IFanucPathSmoothingDef for the extra fields. public interface IFanucPathSmoothingDef : IPathSmoothingDef Inherited Members IPathSmoothingDef.IsEnabled IPathSmoothingDef.Term Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples \"PathSmoothing\": { \"IsEnabled\": true, \"Term\": \"G05.1\", \"Level\": 1 } Properties Level Fanuc G05.1 R precision / smoothness level number (typically 1..10). null when the source NC line did not specify R. Ignored when IsEnabled is false. int? Level { get; set; } Property Value int?"
  },
  "api/Hi.NcParsers.Keywords.IFeedrateDef.html": {
    "href": "api/Hi.NcParsers.Keywords.IFeedrateDef.html",
    "title": "Interface IFeedrateDef | HiAPI-C# 2025",
    "summary": "Interface IFeedrateDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Feedrate state written by FeedrateSyntax. Property names are used as JSON keys via nameof. ISO standard: F command + G94 (per minute) / G95 (per revolution). Supported by all major CNC brands. public interface IFeedrateDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples \"Feedrate\": { \"FeedrateValue\": 300.0, \"Term\": \"G94\", \"Unit\": \"mm/min\" } Properties FeedrateValue Feedrate value (mm/min for G94, mm/rev for G95). double FeedrateValue { get; set; } Property Value double Term “G94” (per minute) or “G95” (per revolution). See IsoKeywords. string Term { get; set; } Property Value string Unit Display unit derived from Term: “mm/min” for G94, “mm/rev” for G95. string Unit { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.IFlagsDef.html": {
    "href": "api/Hi.NcParsers.Keywords.IFlagsDef.html",
    "title": "Interface IFlagsDef | HiAPI-C# 2025",
    "summary": "Interface IFlagsDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll JSON section schema describing the modal/non-modal flags that take effect on an NC block. Each entry in Flags is a brand-specific keyword recognized by the soft-NC runtime. public interface IFlagsDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Flags Known flags that it takes effect. List<string> Flags { get; set; } Property Value List<string>"
  },
  "api/Hi.NcParsers.Keywords.IMachineCoordinateStateDef.html": {
    "href": "api/Hi.NcParsers.Keywords.IMachineCoordinateStateDef.html",
    "title": "Interface IMachineCoordinateStateDef | HiAPI-C# 2025",
    "summary": "Interface IMachineCoordinateStateDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Modal machine-coordinate state — absolute six-axis machine position after the block has executed. Written on every block by motion-related LogicSyntaxs (McAbcSyntax, McAbcXyzFallbackSyntax, McXyzSyntax, MachineCoordSelectSyntax, G53p1RotaryPositionSyntax, ReferenceReturnSyntax); seeded on the init block by HomeMcInitializer; carried across non-motion blocks — and per-key completed on partially-written blocks (an XYZ-only motion block receives the carried modal rotary values) — by ModalCarrySyntax. Only configured axes appear as keys (X/Y/Z/A/B/C). Non-existent axes (e.g., A/B/C on a 3-axis machine) are omitted rather than written as NaN sentinels. After the PostLogic carry the section is a MODAL record: key presence means \"state known\", never \"this block commanded the axis\". Consumers needing \"commanded\" must read the block's Parsing words or compare values against the previous block (see LinearMotionUtil.HasRotaryMotion). The only presence-as-commanded carve-out is CompoundMotion.Items[*] item-level sections, which the carry never touches. public interface IMachineCoordinateStateDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples \"MachineCoordinateState\": { \"X\": 100.0, \"Y\": 50.0, \"Z\": -20.0 } \"MachineCoordinateState\": { \"X\": 100.0, \"Y\": 50.0, \"Z\": -20.0, \"A\": 0.0, \"B\": 30.0 } Properties MachineCoordinateState JSON object with per-axis absolute machine coordinate. Configured axes are present; unconfigured axes are omitted. JsonObject MachineCoordinateState { get; set; } Property Value JsonObject"
  },
  "api/Hi.NcParsers.Keywords.IMotionEventDef.html": {
    "href": "api/Hi.NcParsers.Keywords.IMotionEventDef.html",
    "title": "Interface IMotionEventDef | HiAPI-C# 2025",
    "summary": "Interface IMotionEventDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll One-shot motion event — present on every block whose source programmed a motion command, regardless of whether the resulting displacement is non-zero. A redundant G01 X10 on a block already at X10 still gets a MotionEvent; the motion semantics (McLinearMotionSemantic, McArcMotionSemantic, ClLinearMcMotionSemantic) then early-return on distance <= 0 and emit no IAct. NOT carried forward across blocks. Reason for the \"programmed, not displaced\" definition: Fanuc G66 modal macro fires once per programmed motion command (per Fanuc spec — no distance gate), so FanucModalMacroSyntax.Expansion uses MotionEvent presence as its trigger. Suppressing the section on zero-distance moves would silently change G66 behaviour. The modal sibling MotionState separately latches the Group-01 mode for readers that only need to know \"what G-code is active\". Property names are used as JSON keys via nameof. public interface IMotionEventDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": false } Remarks Term source-precedence rule: modal motion (G00/G01/G02/G03) leaves Term unset because the source G-code is already latched in the sibling MotionState.Term. Non-modal one-shots that drive the block's motion themselves — currently G53.1 (rapid rotary positioning to align with the active tilted plane), and the same pattern is the intended fit for any future non-modal motion command — set Term to record the originating G-code. When Term is non-null, readers should treat it as the authoritative source for this block; the modal MotionState in this case is inherited context, not the block's actual motion driver. Properties Form Interpolation form. See MotionForm. string Form { get; set; } Property Value string IsRapid True for rapid traverse; false (default) for programmed feedrate. bool IsRapid { get; set; } Property Value bool PoseStated True when the writer solved and STATED the full six-axis pose on this block's MachineCoordinateState and wants the pose-carrying act (currently the ClToMcTransformSyntax constant-posture downgrade: its acts are expanded pose-first, so even an unchanged rotary state must ride the act). Absent/false for NC blocks: there McLinearMotionSemantic discriminates by rotary VALUE change — key presence stopped meaning “commanded” once ModalCarrySyntax completes every section with carried modal values. bool PoseStated { get; set; } Property Value bool Term Source G-code term, set only when a non-modal one-shot drove this block's motion (e.g. “G53.1”). Null/absent for modal motion blocks (G00/G01/G02/G03) whose source is recorded on the sibling Term. See type-level remarks for the precedence rule. string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.IMotionStateDef.html": {
    "href": "api/Hi.NcParsers.Keywords.IMotionStateDef.html",
    "title": "Interface IMotionStateDef | HiAPI-C# 2025",
    "summary": "Interface IMotionStateDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Modal motion state — Group 01 G-code mode (G00 / G01 / G02 / G03 ...). Written on every block by LinearMotionSyntax / CircularMotionSyntax; carried across non-motion blocks by ModalCarrySyntax. Property names are used as JSON keys via nameof. Unlike sibling modal sections (Unit, PlaneSelect, Positioning) which carry both a brand-specific Term and a brand-neutral conventional field, MotionState intentionally keeps only Term: the brand-neutral semantic (\"what kind of motion happened\") lives on the sibling one-shot MotionEvent (Form = McLinear / McArc / ClLinear / ClArc). State here is purely the modal latch of the last Group-01 G-code so downstream FindPrevious* can resume motion-mode bookkeeping. public interface IMotionStateDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples \"MotionState\": { \"Term\": \"G01\" } Properties Term CNC term that defines the modal motion mode (e.g., “G00”, “G01”, “G02”, “G03”). string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.IParsingDef.html": {
    "href": "api/Hi.NcParsers.Keywords.IParsingDef.html",
    "title": "Interface IParsingDef | HiAPI-C# 2025",
    "summary": "Interface IParsingDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll JSON section schema carrying the raw, brand-specific parsing trace for an NC block. The Parsing node holds intermediate parser output used by downstream syntaxes and diagnostics. public interface IParsingDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Parsing Raw parsing trace JSON for the current block. JsonNode Parsing { get; set; } Property Value JsonNode"
  },
  "api/Hi.NcParsers.Keywords.IPathSmoothingDef.html": {
    "href": "api/Hi.NcParsers.Keywords.IPathSmoothingDef.html",
    "title": "Interface IPathSmoothingDef | HiAPI-C# 2025",
    "summary": "Interface IPathSmoothingDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Path smoothing state. The base interface is brand-agnostic; controller brands extend it with their own argument fields (e.g. IFanucPathSmoothingDef for Fanuc G05.1 R precision-level). Fanuc-flavour writes are produced by FanucPathSmoothingSyntax. ISO/Fanuc G05.1 Q1 (enable) / G05.1 Q0 (disable): high-precision contour control / AICC / Nano Smoothing. Controller-internal interpolation black box — simulation records the state but does not alter the tool path. public interface IPathSmoothingDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples \"PathSmoothing\": { \"IsEnabled\": true, \"Term\": \"G05.1\" } Properties IsEnabled True when path smoothing is active (Q1), false when cancelled (Q0). bool IsEnabled { get; set; } Property Value bool Term CNC term that controls this feature (e.g., “G05.1”). string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.IPlaneSelectDef.html": {
    "href": "api/Hi.NcParsers.Keywords.IPlaneSelectDef.html",
    "title": "Interface IPlaneSelectDef | HiAPI-C# 2025",
    "summary": "Interface IPlaneSelectDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Active plane selection state written by PlaneSelectSyntax. Property names are used as JSON keys via nameof. ISO: G17/G18/G19. Heidenhain: implicit from L/CC syntax. Term carries the brand-specific G-code; Plane stores the conventional, brand-neutral axis-pair name (XY/ZX/YZ). public interface IPlaneSelectDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples \"PlaneSelect\": { \"Term\": \"G17\", \"Plane\": \"XY\" } Properties Plane Active plane axis-pair (XY, ZX, or YZ). string Plane { get; set; } Property Value string Term NC term of the plane-select code on this block (G17/G18/G19). string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.IPolarInterpolationDef.html": {
    "href": "api/Hi.NcParsers.Keywords.IPolarInterpolationDef.html",
    "title": "Interface IPolarInterpolationDef | HiAPI-C# 2025",
    "summary": "Interface IPolarInterpolationDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll JSON section schemas for Fanuc Polar Coordinate Interpolation (G12.1/G13.1). Property names are used as JSON keys via nameof. PolarInterpolationState is the modal valve: its presence on a block means polar interpolation is active there. It is written by PolarInterpolationSyntax on the G12.1 block and re-materialized onto every following block until a G13.1 block ends the mode (single-step lookback carry, same pattern as PositioningSyntax — not registered on ModalCarrySyntax). ProgramPolarRxcz is the per-block polar position, relative to the G12.1 anchor (InitRxcz). Rxcz axes: X = radius-direction linear axis in mm (the NC word X is a diameter and is halved on parse), Y = hypothetical rotary-substitute axis in mm, Z = real Z in mm. The absolute (rotation-center-origin) position used by the math is InitRxcz + ProgramPolarRxcz, mirroring HardNc PolarEntry.CentralProgramPolarRxcz. public interface IPolarInterpolationDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties PolarInterpolationState Modal polar-interpolation state section (the valve). Inner keys: Dir, InitRxcz. JsonObject PolarInterpolationState { get; set; } Property Value JsonObject ProgramPolarRxcz Per-block polar position (anchor-relative Rxcz, mm). JsonObject ProgramPolarRxcz { get; set; } Property Value JsonObject"
  },
  "api/Hi.NcParsers.Keywords.IPositioningDef.html": {
    "href": "api/Hi.NcParsers.Keywords.IPositioningDef.html",
    "title": "Interface IPositioningDef | HiAPI-C# 2025",
    "summary": "Interface IPositioningDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Modal positioning state — ISO Group 03 (G90 absolute / G91 incremental). Written by PositioningSyntax, consumed by IncrementalResolveSyntax, canned cycle syntaxes, and MachineCoordSelectSyntax. Property names are used as JSON keys via nameof. Term is the brand-specific G-code (Fanuc/ISO G90/G91); Mode is the conventional, brand-neutral name (Absolute / Incremental). public interface IPositioningDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples \"Positioning\": { \"Term\": \"G90\", \"Mode\": \"Absolute\" } Properties Mode Conventional positioning mode name (Absolute / Incremental). string Mode { get; set; } Property Value string Term NC term of the positioning code on this block (G90 or G91). string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.IProgramEndDef.html": {
    "href": "api/Hi.NcParsers.Keywords.IProgramEndDef.html",
    "title": "Interface IProgramEndDef | HiAPI-C# 2025",
    "summary": "Interface IProgramEndDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Program end marker (M02/M30). Written by ProgramEndSyntax. Other syntaxes (e.g. IsoLocalCoordinateOffsetSyntax) read this section to reset modal state instead of detecting M30 directly. public interface IProgramEndDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples \"ProgramEnd\": { \"Term\": \"M30\" } Properties Term The M-code that triggered program end (M02 or M30). string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.IProgramStopDef.html": {
    "href": "api/Hi.NcParsers.Keywords.IProgramStopDef.html",
    "title": "Interface IProgramStopDef | HiAPI-C# 2025",
    "summary": "Interface IProgramStopDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Program-stop marker (M00 unconditional / M01 optional). Written by ProgramStopSyntax on each block that carries an M00/M01 flag. Non-modal: the section appears only on the exact block where the stop code is present. Distinct from IProgramEndDef (M02/M30, end of program). M00 halts execution unconditionally; the operator must press Cycle Start to resume. M01 is an optional stop gated by the operator's \"Optional Stop\" panel switch — ignored when the switch is off. This parsing-layer section records the NC intent; runtime / semantic layers decide whether to actually pause. public interface IProgramStopDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples \"ProgramStop\": { \"Term\": \"M01\" } Properties Term The M-code that triggered the stop (M00 or M01). string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.IProgramXyzDef.html": {
    "href": "api/Hi.NcParsers.Keywords.IProgramXyzDef.html",
    "title": "Interface IProgramXyzDef | HiAPI-C# 2025",
    "summary": "Interface IProgramXyzDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll JSON section schema carrying the program-coordinate position commanded on the current block. Written by ProgramXyzSyntax before the ProgramToMcTransform chain composes it into machine coordinates. public interface IProgramXyzDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties ProgramXyz Program-coordinate XYZ (and optional ABC) for the current block. JsonObject ProgramXyz { get; set; } Property Value JsonObject"
  },
  "api/Hi.NcParsers.Keywords.IRadiusCompensationDef.html": {
    "href": "api/Hi.NcParsers.Keywords.IRadiusCompensationDef.html",
    "title": "Interface IRadiusCompensationDef | HiAPI-C# 2025",
    "summary": "Interface IRadiusCompensationDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Radius compensation state written by RadiusCompensationSyntax. Property names are used as JSON keys via nameof. Managed commands (ISO): G41 (left), G42 (right), G40 (cancel). Heidenhain Klartext maps RL → G41, RR → G42, R0 → G40. When active, the tool path is offset perpendicular to the programmed path by Radius_mm; Side determines left vs right. The root ProgramXyz retains the user-programmed position; MachineCoordinate is overwritten to reflect the compensated path. public interface IRadiusCompensationDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Active (G41 D5, radius 2.5 mm): \"RadiusCompensation\": { \"Side\": \"Left\", \"Term\": \"G41\", \"OffsetId\": 5, \"Radius_mm\": 2.5 } Cancelled (G40, modal D preserved): \"RadiusCompensation\": { \"Side\": \"None\", \"Term\": \"G40\", \"OffsetId\": 5 } Properties OffsetId Offset number (Fanuc D number) selecting the radius in the tool offset table. Modal — preserved across G40 blocks so the next G41/G42 without an explicit D continues to reference the same row, matching real Fanuc/Siemens behaviour. int OffsetId { get; set; } Property Value int Radius_mm Unsigned compensation radius in mm, looked up from the tool offset table. Real controller tool tables hold the radius as a non-negative geometry value (wear/delta sits in a separate column); this property mirrors that convention. Direction is encoded by Side. Omitted from the JSON section when Side is SideNone. double Radius_mm { get; set; } Property Value double Side Compensation direction: SideNone, SideLeft, or SideRight. string Side { get; set; } Property Value string Term CNC term: “G41”, “G42”, or “G40”. string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.ISpindleControlDef.html": {
    "href": "api/Hi.NcParsers.Keywords.ISpindleControlDef.html",
    "title": "Interface ISpindleControlDef | HiAPI-C# 2025",
    "summary": "Interface ISpindleControlDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Spindle control item for use inside ItemsKey arrays. Resolved by Hi.NcParsers.Semantics.CompoundMotionSemanticUtil into ActSpindleDirection. public interface ISpindleControlDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples { \"SpindleControl\": { \"Direction\": \"STOP\" } } Properties Direction Target spindle direction (STOP, CW, CCW). SpindleDirection Direction { get; set; } Property Value SpindleDirection"
  },
  "api/Hi.NcParsers.Keywords.ISpindleOrientationDef.html": {
    "href": "api/Hi.NcParsers.Keywords.ISpindleOrientationDef.html",
    "title": "Interface ISpindleOrientationDef | HiAPI-C# 2025",
    "summary": "Interface ISpindleOrientationDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Oriented spindle stop item for use inside ItemsKey arrays. Commands the spindle to stop at a specific angular position (OSS). Resolved by Hi.NcParsers.Semantics.CompoundMotionSemanticUtil into ActSpindleOrientation. public interface ISpindleOrientationDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples { \"SpindleOrientation\": { \"Angle_deg\": 0.0 } } Properties Angle_deg Target spindle stop angle in degrees. double Angle_deg { get; set; } Property Value double"
  },
  "api/Hi.NcParsers.Keywords.ISpindleSpeedDef.html": {
    "href": "api/Hi.NcParsers.Keywords.ISpindleSpeedDef.html",
    "title": "Interface ISpindleSpeedDef | HiAPI-C# 2025",
    "summary": "Interface ISpindleSpeedDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Spindle speed and direction state written by SpindleSpeedSyntax. Property names are used as JSON keys via nameof. ISO: S command for speed, M03/M04/M05 for direction. Heidenhain: M3/M4/M5. Siemens: M3/M4/M5 or SPOS. Direction is stored as the conventional SpindleDirection enum name (CW/CCW/STOP), not as brand-specific M-codes. public interface ISpindleSpeedDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples \"SpindleSpeed\": { \"SpindleSpeed_rpm\": 3000.0, \"Direction\": \"CW\" } Properties Direction Spindle rotation direction. Stored in JSON as the enum name (e.g. “CW”, “CCW”, “STOP”). SpindleDirection Direction { get; set; } Property Value SpindleDirection SpindleSpeed_rpm Spindle speed in RPM. double SpindleSpeed_rpm { get; set; } Property Value double"
  },
  "api/Hi.NcParsers.Keywords.ITiltTransformDef.html": {
    "href": "api/Hi.NcParsers.Keywords.ITiltTransformDef.html",
    "title": "Interface ITiltTransformDef | HiAPI-C# 2025",
    "summary": "Interface ITiltTransformDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Tilt transform state written by tilt transform syntaxes. Property names are used as JSON keys via nameof. Managed commands (ISO/Fanuc): G68 (2D rotation), G68.2 (tilted work plane), G69 (cancel). Siemens equivalent: CYCLE800, ROT/AROT (handled by separate syntax). Heidenhain equivalent: PLANE SPATIAL / PLANE RESET (handled by separate syntax). public interface ITiltTransformDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples \"TiltTransform\": { \"Term\": \"G68.2\", \"I\": 180, \"J\": 90, \"K\": 180, \"X\": 0, \"Y\": 55, \"Z\": -45.377 } Properties Term CNC term for tilt: “G68”, “G68.2”, “G69”, “PLANE SPATIAL”, “CYCLE800”, etc. string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.IToolHeightCompensationDef.html": {
    "href": "api/Hi.NcParsers.Keywords.IToolHeightCompensationDef.html",
    "title": "Interface IToolHeightCompensationDef | HiAPI-C# 2025",
    "summary": "Interface IToolHeightCompensationDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Tool height compensation state written by ToolHeightOffsetSyntax. Property names are used as JSON keys via nameof. The JSON section can be deserialized to an instance implementing this interface. Managed commands (ISO/Fanuc): G43, G44, G49. Fanuc extension: G43.4 (TCPM — parsed only in Fanuc syntax list). Siemens equivalent: TRAFOOF/TRAORI (handled by separate syntax). Heidenhain equivalent: TOOL CALL / M128/M129 (handled by separate syntax). public interface IToolHeightCompensationDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples \"ToolHeightCompensation\": { \"Offset_mm\": 99.98, \"Term\": \"G43\", \"OffsetId\": 1 } Remarks RTCP-rotary-dynamic state (whether the per-step MC path is non-linear while CL is commanded linearly) is signalled by a KindDynamic entry in the ProgramToMcTransform chain rather than by a flag on this section, so consumers detect it via HasDynamicEntry(JsonObject) without needing brand-specific strings. Properties OffsetId Generic offset selector: Fanuc H number, Heidenhain T number, Mazak/Okuma H number. For Siemens (T+D addressing), see ISiemensToolOffsetConfig. int OffsetId { get; set; } Property Value int Offset_mm Derived effective tool height compensation in mm. Computed from Term and OffsetId: looks up the offset table for OffsetId, obtains the effective height (geometry minus wear), then applies sign from Term (positive for G43/G43.4, negative for G44, zero for G49). double Offset_mm { get; set; } Property Value double Term CNC term for tool height compensation: “G43”, “G43.4”, “G44”, “G49”. Brand-specific syntaxes may write equivalent terms (e.g., “TRAORI” for Siemens, “M128” for Heidenhain). string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.ITransformationDef.html": {
    "href": "api/Hi.NcParsers.Keywords.ITransformationDef.html",
    "title": "Interface ITransformationDef | HiAPI-C# 2025",
    "summary": "Interface ITransformationDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Chain of named ProgramXyz → MachineCoordinate transformation entries. Stored as a JsonArray of entries, each with “Source”, “Kind”, and “Mat4d” keys. Each contributing INcSyntax adds or replaces its own entry by source name. GetComposedTransform(JsonObject) composes entries in order: McXyz = ProgramXyz * T[0] * T[1] * ... * T[n]. Kind contour-validity classification. Each entry is either: \"Static\" — the Mat4d is valid for any point along the contour. Tilt, coord-offset, and the kinematic pivot in non-RTCP / rotary-stable blocks are all Static. \"Dynamic\" — the Mat4d is a block-endpoint snapshot of a rotary-state-dependent transform (RTCP rotary-dynamic). Composition still yields a correct endpoint MC, but the matrix is not contour-valid: intermediate CL-point positions cannot be derived by applying it to an interpolated ProgramXyz. The semantic layer (ClLinearMcMotionSemantic) handles per-step IK separately. Use HasDynamicEntry(JsonObject) to detect the presence of any Dynamic entry on this block. public interface ITransformationDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples \"ProgramToMcTransform\": [ {\"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1]}, {\"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,99.98,1]}, {\"Source\": \"CoordinateOffset\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 10,20,-100,1]}, {\"Source\": \"PivotTransform\", \"Kind\": \"Dynamic\", \"Mat4d\": [cosC,sinC,0,0, -sinC,cosC,0,0, 0,0,1,0, px,py,pz,1]} ] Properties ProgramToMcTransform Ordered chain of named ProgramXyz → MachineCoordinate transformation entries. See the type-level remarks for the entry schema and composition rule. JsonArray ProgramToMcTransform { get; set; } Property Value JsonArray"
  },
  "api/Hi.NcParsers.Keywords.IUnitDef.html": {
    "href": "api/Hi.NcParsers.Keywords.IUnitDef.html",
    "title": "Interface IUnitDef | HiAPI-C# 2025",
    "summary": "Interface IUnitDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Unit-system state (ISO Group 06: G20 inch / G21 metric). Written by UnitModeSyntax. Modal. HiNC's NC pipeline works exclusively in millimetres. G21 is therefore a no-op confirmation of the default; G20 is reported as an Unsupported Error and callers are expected to pre-convert the NC program to metric before loading. public interface IUnitDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples \"Unit\": { \"Term\": \"G21\", \"System\": \"Metric\" } Properties System Abstract name of the unit system (Metric / Inch). string System { get; set; } Property Value string Term NC term of the unit code on this block (G20 or G21). string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.IUnparsedTextDef.html": {
    "href": "api/Hi.NcParsers.Keywords.IUnparsedTextDef.html",
    "title": "Interface IUnparsedTextDef | HiAPI-C# 2025",
    "summary": "Interface IUnparsedTextDef Namespace Hi.NcParsers.Keywords Assembly HiMech.dll JSON section schema carrying the residual block text that was not consumed by any registered syntax. Used for diagnostics and round-trip preservation. public interface IUnparsedTextDef Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties UnparsedText Residual NC block text not matched by any syntax. string UnparsedText { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.IndexNote.html": {
    "href": "api/Hi.NcParsers.Keywords.IndexNote.html",
    "title": "Class IndexNote | HiAPI-C# 2025",
    "summary": "Class IndexNote Namespace Hi.NcParsers.Keywords Assembly HiMech.dll JSON-section data shape pairing a single-character address symbol (e.g. ‘O’, ‘N’) with its numeric index, used to annotate program/sequence numbers on an NC block. public class IndexNote Inheritance object IndexNote Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Number Numeric value associated with Symbol. public int Number { get; set; } Property Value int Symbol Address symbol (e.g. “O” for program number, “N” for sequence number). public string Symbol { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.IsoLocalCoordinateOffset.html": {
    "href": "api/Hi.NcParsers.Keywords.IsoLocalCoordinateOffset.html",
    "title": "Class IsoLocalCoordinateOffset | HiAPI-C# 2025",
    "summary": "Class IsoLocalCoordinateOffset Namespace Hi.NcParsers.Keywords Assembly HiMech.dll ISO/Fanuc-family local coordinate offset state (G52) written by IsoLocalCoordinateOffsetSyntax. Property names are used as JSON keys via nameof. G52 X Y Z installs a local coordinate-system shift that stacks on top of the active G54-G59 work offset. The cancel mechanism is to write G52 X0 Y0 Z0 (or hit M30 / reset) — there is no separate G code for \"cancel\". The offset vector is therefore always modal: zero is a valid modal value, not a \"disabled\" state, so the section is recorded on every block. Brand-specific kin: Siemens TRANS/ATRANS (which can also carry rotation/scale/mirror) and Heidenhain TRANS DATUM are handled by their own syntaxes and write to their own sections — they do not share this key, because their data shapes are richer. public class IsoLocalCoordinateOffset Inheritance object IsoLocalCoordinateOffset Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples \"IsoLocalCoordinateOffset\": { \"Offset_X\": 10.0, \"Offset_Y\": 20.0, \"Offset_Z\": 0.0 } Properties Offset_X X offset in mm. public double Offset_X { get; set; } Property Value double Offset_Y Y offset in mm. public double Offset_Y { get; set; } Property Value double Offset_Z Z offset in mm. public double Offset_Z { get; set; } Property Value double"
  },
  "api/Hi.NcParsers.Keywords.MachineCoordinateState.html": {
    "href": "api/Hi.NcParsers.Keywords.MachineCoordinateState.html",
    "title": "Class MachineCoordinateState | HiAPI-C# 2025",
    "summary": "Class MachineCoordinateState Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section key holder for IMachineCoordinateStateDef. public class MachineCoordinateState Inheritance object MachineCoordinateState Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.NcParsers.Keywords.MacroFrame.html": {
    "href": "api/Hi.NcParsers.Keywords.MacroFrame.html",
    "title": "Class MacroFrame | HiAPI-C# 2025",
    "summary": "Class MacroFrame Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Top-level integer marker stamped onto a SyntaxPiece's JSON to identify which call frame the block belongs to. Brand-agnostic by design — written by FanucMacroCallSyntax today, reusable by any future call-inlining syntax (Fanuc G66 modal expansion, Heidenhain LBL CALL, …) that needs local-variable isolation across call boundaries. Semantics: the value is an opaque id; only equality matters. Two blocks with the same MacroFrame id share a call frame (locals visible across them via single-step carry); two blocks with different ids do not. The id 0 is reserved for the main program frame and is returned by Get(JsonObject) when the field is absent — so a plain caller block needs no stamp and yet compares distinct from any inlined frame. Stored as a top-level JSON int (not an object section) so it stays lightweight on every inlined block. Decoupled from FanucMacroCall: that section is a diagnostic record of the call (what file, what args), while MacroFrame is the purely functional marker the local-variable I/O syntaxes consult. public static class MacroFrame Inheritance object MacroFrame Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods Get(JsonObject) Reads the frame id off a block, returning 0 (main frame) when the field is absent or non-integer. public static int Get(JsonObject json) Parameters json JsonObject Returns int Set(JsonObject, int) Stamps the frame id onto a block. Overwrites any previous value. Callers writing the main-frame default (0) should simply leave the field absent rather than calling this with 0. public static void Set(JsonObject json, int frameId) Parameters json JsonObject frameId int"
  },
  "api/Hi.NcParsers.Keywords.MotionEvent.html": {
    "href": "api/Hi.NcParsers.Keywords.MotionEvent.html",
    "title": "Class MotionEvent | HiAPI-C# 2025",
    "summary": "Class MotionEvent Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section key holder + concrete implementation for IMotionEventDef. public class MotionEvent : IMotionEventDef Inheritance object MotionEvent Implements IMotionEventDef Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Form Interpolation form. See MotionForm. public string Form { get; set; } Property Value string IsRapid True for rapid traverse; false (default) for programmed feedrate. public bool IsRapid { get; set; } Property Value bool PoseStated True when the writer solved and STATED the full six-axis pose on this block's MachineCoordinateState and wants the pose-carrying act (currently the ClToMcTransformSyntax constant-posture downgrade: its acts are expanded pose-first, so even an unchanged rotary state must ride the act). Absent/false for NC blocks: there McLinearMotionSemantic discriminates by rotary VALUE change — key presence stopped meaning “commanded” once ModalCarrySyntax completes every section with carried modal values. public bool PoseStated { get; set; } Property Value bool Term Source G-code term, set only when a non-modal one-shot drove this block's motion (e.g. “G53.1”). Null/absent for modal motion blocks (G00/G01/G02/G03) whose source is recorded on the sibling Term. See type-level remarks for the precedence rule. public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.MotionState.html": {
    "href": "api/Hi.NcParsers.Keywords.MotionState.html",
    "title": "Class MotionState | HiAPI-C# 2025",
    "summary": "Class MotionState Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section key holder + concrete implementation for IMotionStateDef. public class MotionState : IMotionStateDef Inheritance object MotionState Implements IMotionStateDef Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Term CNC term that defines the modal motion mode (e.g., “G00”, “G01”, “G02”, “G03”). public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.PathSmoothing.html": {
    "href": "api/Hi.NcParsers.Keywords.PathSmoothing.html",
    "title": "Class PathSmoothing | HiAPI-C# 2025",
    "summary": "Class PathSmoothing Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section key holder for IPathSmoothingDef. public class PathSmoothing : IPathSmoothingDef Inheritance object PathSmoothing Implements IPathSmoothingDef Derived FanucPathSmoothing SiemensPathSmoothing Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties IsEnabled True when path smoothing is active (Q1), false when cancelled (Q0). public bool IsEnabled { get; set; } Property Value bool Term CNC term that controls this feature (e.g., “G05.1”). public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.PlaneSelect.html": {
    "href": "api/Hi.NcParsers.Keywords.PlaneSelect.html",
    "title": "Class PlaneSelect | HiAPI-C# 2025",
    "summary": "Class PlaneSelect Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section key holder for IPlaneSelectDef. public class PlaneSelect : IPlaneSelectDef Inheritance object PlaneSelect Implements IPlaneSelectDef Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields XY Plane identifier for the XY plane (Z normal). public const string XY = \"XY\" Field Value string YZ Plane identifier for the YZ plane (X normal). public const string YZ = \"YZ\" Field Value string ZX Plane identifier for the ZX plane (Y normal). public const string ZX = \"ZX\" Field Value string Properties Plane Active plane axis-pair (XY, ZX, or YZ). public string Plane { get; set; } Property Value string Term NC term of the plane-select code on this block (G17/G18/G19). public string Term { get; set; } Property Value string Methods GetNormalAxisIndex(string) Perpendicular (normal) axis index for the plane. XY→2 (Z normal), ZX→1 (Y normal), YZ→0 (X normal). public static int GetNormalAxisIndex(string plane) Parameters plane string Returns int"
  },
  "api/Hi.NcParsers.Keywords.PolarInterpolation.html": {
    "href": "api/Hi.NcParsers.Keywords.PolarInterpolation.html",
    "title": "Class PolarInterpolation | HiAPI-C# 2025",
    "summary": "Class PolarInterpolation Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Inner-key constants of the PolarInterpolationState section. public static class PolarInterpolation Inheritance object PolarInterpolation Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields CompensatedBeginCentral Motion-section key: where the compensated polar arc's motion begins — the previous block's CompensatedCentral (falling back to the nominal previous position when the previous block was not compensated). Present only on compensated polar arc blocks. public const string CompensatedBeginCentral = \"CompensatedBeginCentral\" Field Value string CompensatedCentral Block-root key holding the radius-compensated position of a polar block in central (anchor-origin) hypothetical-plane coordinates. Written by RadiusCompensationSyntax's polar branch; mirrors HardNc RadiusCompensationBuf.CompensatedPosOnProgramCoordinate (which stores the anchor-relative twin). Sub-object with X/Y/Z keys in mm. public const string CompensatedCentral = \"CompensatedCentral\" Field Value string CompensatedEndCentral Motion-section key: the compensated polar arc block's final position (ray intersection or perpendicular offset). Its presence marks the block's polar arc as radius-compensated, switching McPolarArcMotionSemantic to the bridged transient act structure. Mirrors HardNc RadiusCompensationBuf.CompensatedPosOnProgramCoordinate. public const string CompensatedEndCentral = \"CompensatedEndCentral\" Field Value string Dir Polar plane axis pair key; value e.g. DirXC. public const string Dir = \"Dir\" Field Value string DirXC X linear axis + C rotary axis polar pair (the standard turn-mill pair; the X radius word is a diameter). public const string DirXC = \"XC\" Field Value string DirYA Y linear axis + A rotary axis (about X) polar pair. public const string DirYA = \"YA\" Field Value string DirZB Z linear axis + B rotary axis (about Y) polar pair. public const string DirZB = \"ZB\" Field Value string InitRxcz Anchor position key — the X/C words on the G12.1 block itself (X halved from diameter to radius), zero when absent. Sub-object with X/Y/Z keys in mm. public const string InitRxcz = \"InitRxcz\" Field Value string TransientBeginCentral Motion-section key: point on the compensated arc's offset circle where the arc motion begins when the previous segment's offset path meets it at a corner; a linear bridge on the hypothetical plane connects CompensatedBeginCentral to it. Absent when the adjoining rays are parallel. Mirrors HardNc RadiusCompensationBuf.TransientBeginProgramPos. public const string TransientBeginCentral = \"TransientBeginCentral\" Field Value string TransientEndCentral Motion-section key: point on the compensated arc's offset circle where the arc motion ends when the next segment's offset path meets it at a corner; a linear bridge on the hypothetical plane connects it to CompensatedEndCentral. Absent when the adjoining rays are parallel. Mirrors HardNc RadiusCompensationBuf.TransientEndProgramPos. public const string TransientEndCentral = \"TransientEndCentral\" Field Value string"
  },
  "api/Hi.NcParsers.Keywords.Positioning.html": {
    "href": "api/Hi.NcParsers.Keywords.Positioning.html",
    "title": "Class Positioning | HiAPI-C# 2025",
    "summary": "Class Positioning Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section key holder + concrete implementation for IPositioningDef. public class Positioning : IPositioningDef Inheritance object Positioning Implements IPositioningDef Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Absolute Absolute positioning mode name (corresponds to G90). public const string Absolute = \"Absolute\" Field Value string CodedAbsolute Coded-position absolute mode name (Siemens CAC()): the word value is an indexing position number, not a coordinate — the write-stage consumers (McAbcSyntax / IncrementalResolveSyntax) look the number up in the machine's indexing table (IIndexingPositionConfig) and rewrite the entry to the plain counterpart (Absolute) once the coordinate is resolved, so the McAbcCyclicPathSyntax tail-pass never sees a coded value. Per-word PositioningOverride value only. public const string CodedAbsolute = \"CodedAbsolute\" Field Value string CodedIncremental Coded-position incremental mode name (Siemens CIC()): the word value counts indexing positions to advance (positive) or retreat (negative) from the current position; 0 does not traverse. Resolved and rewritten by the same consumers as CodedAbsolute — on a cyclic indexing axis the sign becomes a PositiveOnly / NegativeOnly approach so the swing keeps the programmed direction. public const string CodedIncremental = \"CodedIncremental\" Field Value string CodedNegativeOnly Coded-position negative-direction-only mode name (Siemens CACN()) — the mirror of CodedPositiveOnly, rewritten to NegativeOnly. public const string CodedNegativeOnly = \"CodedNegativeOnly\" Field Value string CodedPositiveOnly Coded-position positive-direction-only mode name (Siemens CACP()) — CodedAbsolute lookup rewritten to PositiveOnly. Rotary indexing axes only. public const string CodedPositiveOnly = \"CodedPositiveOnly\" Field Value string CodedShortest Coded-position shortest-path mode name (Siemens CDC()) — CodedAbsolute lookup rewritten to Shortest. Rotary indexing axes only. public const string CodedShortest = \"CodedShortest\" Field Value string Incremental Incremental positioning mode name (corresponds to G91). public const string Incremental = \"Incremental\" Field Value string NegativeOnly Rotary negative-direction-only approach mode name (Siemens ACN()) — the mirror of PositiveOnly. public const string NegativeOnly = \"NegativeOnly\" Field Value string PositiveOnly Rotary positive-direction-only approach mode name (Siemens ACP()): absolute target approached by rotating in the positive axis direction, even when that is the longer way around. Per-word PositioningOverride value only. Write-stage consumers fall through to the absolute write; the directional window swap happens in McAbcCyclicPathSyntax. public const string PositiveOnly = \"PositiveOnly\" Field Value string Shortest Rotary shortest-path mode name (Siemens DC()): absolute target reached by the shortest cyclic swing. Only meaningful as a per-word PositioningOverride value, never as the modal Mode. The write-stage consumers (McAbcSyntax / IncrementalResolveSyntax) deliberately treat every non-Incremental value as an absolute write; the shortest swing itself is the McAbcCyclicPathSyntax tail-pass default for modular rotary axes, so this value changes no consumer behavior — it preserves the DC-vs-AC distinction on the block and lets the tail-pass warn when the axis is not modular rotary (where the shortest-path promise cannot be honored). public const string Shortest = \"Shortest\" Field Value string Properties Mode Conventional positioning mode name (Absolute / Incremental). public string Mode { get; set; } Property Value string Term NC term of the positioning code on this block (G90 or G91). public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.PositioningOverride.html": {
    "href": "api/Hi.NcParsers.Keywords.PositioningOverride.html",
    "title": "Class PositioningOverride | HiAPI-C# 2025",
    "summary": "Class PositioningOverride Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Per-word positioning override — a non-modal block-root section keyed by word name (axis words and the I/J/K interpolation parameters) whose values are Absolute / Incremental / Shortest / PositiveOnly / NegativeOnly, plus the coded-position (indexing axis) family CodedAbsolute / CodedIncremental / CodedShortest / CodedPositiveOnly / CodedNegativeOnly. Overrides the modal G90/G91 Positioning state (and, for I/J/K, the default incremental center reading) for the listed words on this block only. Written by SiemensAcIcSyntax when a word carries one of the Siemens per-word coordinate function wrappers AC() / IC() / DC() / ACP() / ACN() or their coded-position counterparts CAC() / CIC() / CDC() / CACP() / CACN(), and by the Heidenhain L / C / CC / CYCL CALL POS parsers (through HeidenhainIncrementalAxisWordUtil) for the klartext I-prefixed incremental words IX+20 / IC+90 — always Incremental there, keyed by the plain axis letter. Not written for the CYCL DEF 7 datum-shift words: those are increments of the active shift, not of the tool position, and stay inside the cycle's own record. Consumed by IncrementalResolveSyntax (linear axes) and McAbcSyntax (rotary axes) — both treat every non-Incremental value as an absolute write, and both resolve a coded entry's indexing position number through CodedPositionUtil and rewrite the entry to its plain counterpart in place — by McAbcCyclicPathSyntax (the directional window for PositiveOnly / NegativeOnly and the non-modular-axis boundary warning; it never sees a coded value), and by SiemensCircularMotionSyntax (absolute I/J/K center components) — and, ahead of the shared resolve, by two consumers that take the raw word before it can see it: HeidenhainCannedCycleSyntax (CYCL CALL POS words and the M99/M89 root words, resolved against the last programmed position on the spot) and MachineCoordSelectSyntax (a distance in the machine frame); words without an entry keep the default behavior unchanged. The section is not listed in any ModalCarry key set — it never carries to later blocks. public static class PositioningOverride Inheritance object PositioningOverride Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Examples \"PositioningOverride\": { \"C\": \"Shortest\" }"
  },
  "api/Hi.NcParsers.Keywords.ProgramEnd.html": {
    "href": "api/Hi.NcParsers.Keywords.ProgramEnd.html",
    "title": "Class ProgramEnd | HiAPI-C# 2025",
    "summary": "Class ProgramEnd Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section key holder for IProgramEndDef. public class ProgramEnd : IProgramEndDef Inheritance object ProgramEnd Implements IProgramEndDef Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Term The M-code that triggered program end (M02 or M30). public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.ProgramStop.html": {
    "href": "api/Hi.NcParsers.Keywords.ProgramStop.html",
    "title": "Class ProgramStop | HiAPI-C# 2025",
    "summary": "Class ProgramStop Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section key holder + concrete implementation for IProgramStopDef. public class ProgramStop : IProgramStopDef Inheritance object ProgramStop Implements IProgramStopDef Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Term The M-code that triggered the stop (M00 or M01). public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.RadiusCompensation.html": {
    "href": "api/Hi.NcParsers.Keywords.RadiusCompensation.html",
    "title": "Class RadiusCompensation | HiAPI-C# 2025",
    "summary": "Class RadiusCompensation Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section key holder + concrete implementation for IRadiusCompensationDef. public class RadiusCompensation : IRadiusCompensationDef Inheritance object RadiusCompensation Implements IRadiusCompensationDef Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields SideLeft Left of programmed path (G41 / Heidenhain RL). public const string SideLeft = \"Left\" Field Value string SideNone No active compensation (G40 / Heidenhain R0). public const string SideNone = \"None\" Field Value string SideRight Right of programmed path (G42 / Heidenhain RR). public const string SideRight = \"Right\" Field Value string Properties OffsetId Offset number (Fanuc D number) selecting the radius in the tool offset table. Modal — preserved across G40 blocks so the next G41/G42 without an explicit D continues to reference the same row, matching real Fanuc/Siemens behaviour. public int OffsetId { get; set; } Property Value int Radius_mm Unsigned compensation radius in mm, looked up from the tool offset table. Real controller tool tables hold the radius as a non-negative geometry value (wear/delta sits in a separate column); this property mirrors that convention. Direction is encoded by Side. Omitted from the JSON section when Side is SideNone. public double Radius_mm { get; set; } Property Value double Side Compensation direction: SideNone, SideLeft, or SideRight. public string Side { get; set; } Property Value string Term CNC term: “G41”, “G42”, or “G40”. public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Siemens.ISiemensPathSmoothingDef.html": {
    "href": "api/Hi.NcParsers.Keywords.Siemens.ISiemensPathSmoothingDef.html",
    "title": "Interface ISiemensPathSmoothingDef | HiAPI-C# 2025",
    "summary": "Interface ISiemensPathSmoothingDef Namespace Hi.NcParsers.Keywords.Siemens Assembly HiMech.dll Siemens path-control / smoothing modal registers recorded by SiemensPathSmoothingSyntax under the brand-invariant PathSmoothing section key. Record-only — simulation does not alter the tool path; the registers exist for bidirectional NC-text reconstruction and UI display. Each property mirrors one orthogonal Sinumerik modal group; a property is absent from the JSON section until its group is first programmed. IsEnabled is derived: true while a CYCLE832 high-speed setting is armed (Tolerance present) or a continuous-path mode (G64/G641/G642) is active. Term records the token that last changed the path-control state (a G code or CYCLE832). public interface ISiemensPathSmoothingDef : IPathSmoothingDef Inherited Members IPathSmoothingDef.IsEnabled IPathSmoothingDef.Term Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties AccelProfile Acceleration profile group: SOFT (jerk-limited) / BRISK. string AccelProfile { get; set; } Property Value string Compressor Compressor group: COMPCAD / COMPON / COMPOF. string Compressor { get; set; } Property Value string ExactStopCriterion Exact-stop criterion group: G601 (fine) / G602 (coarse). string ExactStopCriterion { get; set; } Property Value string FeedForward Feedforward group: FFWON / FFWOF. string FeedForward { get; set; } Property Value string FeedProfile Feedrate profile group: FNORM. string FeedProfile { get; set; } Property Value string Mode CYCLE832 technology/mode argument verbatim (e.g. _ORI_FINISH, 1) while armed. string Mode { get; set; } Property Value string PathControl Path-control group: G60 (exact stop) / G64 / G641 / G642 (continuous path). string PathControl { get; set; } Property Value string PathReference Path-reference group: UPATH / SPATH. string PathReference { get; set; } Property Value string Tolerance CYCLE832 machining tolerance (first argument, mm) while armed; absent when CYCLE832 is cancelled. A non-numeric source argument (variable/expression) is preserved verbatim as a string in the JSON section for the future evaluator. double? Tolerance { get; set; } Property Value double?"
  },
  "api/Hi.NcParsers.Keywords.Siemens.Msg.html": {
    "href": "api/Hi.NcParsers.Keywords.Siemens.Msg.html",
    "title": "Class Msg | HiAPI-C# 2025",
    "summary": "Class Msg Namespace Hi.NcParsers.Keywords.Siemens Assembly HiMech.dll Block-root section recording a Siemens MSG(\"...\") operator display message, written by SiemensMsgSyntax. A section without Text records the bare MSG() clear form. Record-only: simulation ignores it; the section exists for bidirectional NC-text reconstruction and UI display. public class Msg Inheritance object Msg Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Text Verbatim message text between the quotes; absent for the MSG() clear form. public string Text { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Siemens.SiemensCall.html": {
    "href": "api/Hi.NcParsers.Keywords.Siemens.SiemensCall.html",
    "title": "Class SiemensCall | HiAPI-C# 2025",
    "summary": "Class SiemensCall Namespace Hi.NcParsers.Keywords.Siemens Assembly HiMech.dll Siemens subprogram-call record. Two lifetimes share the shape: Parsing.SiemensCall — written by SiemensCallStatementSyntax when a whole-line call statement is captured (L9810, L123 P3, HQ_FC(1,2)). Carries Name, optional verbatim Args, optional P. block-root SiemensCall — written by SiemensSubProgramCallSyntax on the host block and on every inlined body block once the call is consumed. FileName records the resolved subprogram file; Skipped marks the safe-skip outcome (no file found — OEM / measuring cycles like HQ_FC, Renishaw L9810) where the call is consumed with zero motion effect and a structured warning replaces the raw unparsed-text noise. public class SiemensCall Inheritance object SiemensCall Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Args Verbatim positional argument strings from the parenthesized form (HQ_FC(1,2) → [“1”,“2”]). Absent for bare calls. P4 records but does not bind them — argument-to-PROC-parameter binding is a later work item; a resolved call with arguments emits SiemensCall–ArgsNotBound. public string[] Args { get; set; } Property Value string[] FileName Bare matched file name (e.g. “L9810.SPF”) when the call resolved; null when skipped. public string FileName { get; set; } Property Value string Name Called name exactly as written: “L9810”, “HQ_FC”, “MY_SUB”. public string Name { get; set; } Property Value string P Repeat count from the trailing P word (L123 P3); defaults to 1 when absent. public int P { get; set; } Property Value int Skipped True when no subprogram file resolved and the call was consumed as a structured safe-skip. public bool Skipped { get; set; } Property Value bool"
  },
  "api/Hi.NcParsers.Keywords.Siemens.SiemensFor.html": {
    "href": "api/Hi.NcParsers.Keywords.Siemens.SiemensFor.html",
    "title": "Class SiemensFor | HiAPI-C# 2025",
    "summary": "Class SiemensFor Namespace Hi.NcParsers.Keywords.Siemens Assembly HiMech.dll Siemens FOR <var> = <start> TO <end> ... ENDFOR counting-loop record. The Parsing capture stores the start expression as a single-entry Init map ({ “R1”: 0 }) — the variable name is a JSON key, which the evaluator's pass-2 tree walk never rewrites (values only), so a loop variable whose name matches a set named variable is not clobbered; the start/end values are substituted normally. The block-root stamp records the loop variable and its per-iteration Value. public class SiemensFor Inheritance object SiemensFor Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields InitKey JSON key of the single-entry init map under Parsing.SiemensFor: Init = { <var>: <start> }. public const string InitKey = \"Init\" Field Value string TermEndfor Loop terminator term. public const string TermEndfor = \"ENDFOR\" Field Value string TermFor Loop entry term. public const string TermFor = \"FOR\" Field Value string Properties End Inclusive end bound. Parsing-side it is the raw end expression (literal written numeric, expression written string for the evaluator); the loop frame captures the resolved value once at loop entry — Sinumerik evaluates FOR bounds once, not per iteration. public double End { get; set; } Property Value double Term One of TermFor, TermEndfor. public string Term { get; set; } Property Value string Value Current counter value assigned on this FOR arrival, stamp-side. public double Value { get; set; } Property Value double Var Loop variable name (“R1” or a named variable), stamp-side. public string Var { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Siemens.SiemensGoto.html": {
    "href": "api/Hi.NcParsers.Keywords.Siemens.SiemensGoto.html",
    "title": "Class SiemensGoto | HiAPI-C# 2025",
    "summary": "Class SiemensGoto Namespace Hi.NcParsers.Keywords.Siemens Assembly HiMech.dll Siemens GOTOF/GOTOB jump record. Two lifetimes share the shape: Parsing.SiemensGoto — written by SiemensGotoParsingSyntax for both the bare jump (GOTOF LBL1) and the single-line conditional (IF R1==1 GOTOF LBL1). block-root SiemensGoto — stamped by SiemensGotoSyntax after the control-flow decision, with Fired flipped true on a successful redirect. Unlike Fanuc's numbered GOTO n, the target is a named label (LBL1: line) or an N<num> block number; direction is explicit in the mnemonic — GOTOF scans forward from the host line, GOTOB scans backward to the nearest label above. public class SiemensGoto Inheritance object SiemensGoto Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields TermGotob Bare backward jump term. public const string TermGotob = \"GOTOB\" Field Value string TermGotof Bare forward jump term. public const string TermGotof = \"GOTOF\" Field Value string TermIfGotob Conditional backward jump term (IF <cond> GOTOB <label>). public const string TermIfGotob = \"IF...GOTOB\" Field Value string TermIfGotof Conditional forward jump term (IF <cond> GOTOF <label>). public const string TermIfGotof = \"IF...GOTOF\" Field Value string Properties Condition Raw boolean expression text of the conditional forms at Parsing time; substituted to a numeric JSON value in place by VariableEvaluatorSyntax when it evaluates successfully. Absent for the bare forms. Not written on the host-level stamp; the gate outcome lives at ConditionEvaluated and the original text at Formula.SiemensGoto.Condition. public string Condition { get; set; } Property Value string ConditionEvaluated Tri-state outcome of the conditional forms: true — condition met (jump proceeds); false — not met (falls through silently); null — evaluator could not produce a finite truth value (warns SiemensGoto–ConditionNotEvaluated and falls through). Absent on the bare forms. public bool? ConditionEvaluated { get; set; } Property Value bool? Fired True when the redirect actually replaced the source layer. public bool Fired { get; set; } Property Value bool Label Target label identifier as written (“LBL1”, “MARKE_A”, or an N-number form like “N100”). If the identifier collides with a set named variable, the evaluator's pass-2 tree walk may substitute a numeric here; the consumer recovers the original text from the Formula.SiemensGoto.Label mirror. public string Label { get; set; } Property Value string Term Triggering phrase: one of TermGotof, TermGotob, TermIfGotof, TermIfGotob. public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Siemens.SiemensIf.html": {
    "href": "api/Hi.NcParsers.Keywords.Siemens.SiemensIf.html",
    "title": "Class SiemensIf | HiAPI-C# 2025",
    "summary": "Class SiemensIf Namespace Hi.NcParsers.Keywords.Siemens Assembly HiMech.dll Siemens IF/ELSE/ENDIF block-conditional record. Parsing.SiemensIf carries the captured phrase; the block-root stamp written by SiemensIfSyntax adds the gate outcome. Unlike the loop family there is no frame stack: an ELSE reached in the normal stream always means the true branch just finished (a false condition jumps past the ELSE line directly), so ELSE unconditionally skips to its matching ENDIF and ENDIF itself is a consumed no-op. public class SiemensIf Inheritance object SiemensIf Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields TermElse Alternative-branch separator term. public const string TermElse = \"ELSE\" Field Value string TermEndif Block-conditional terminator term. public const string TermEndif = \"ENDIF\" Field Value string TermIf Block-conditional entry term. public const string TermIf = \"IF\" Field Value string Properties Condition Raw condition text on the IF phrase (no brackets on Sinumerik); substituted in place by the evaluator's pass-2 walk. Absent on ELSE/ENDIF. Original text survives at Formula.SiemensIf.Condition. public string Condition { get; set; } Property Value string ConditionEvaluated Tri-state gate outcome stamped on the IF host: true — then-branch executes; false — forward-jump to after the matching ELSE (or ENDIF when no else-branch exists); null — unresolved condition, warns and falls through into the then-branch (no redirect on unresolved input). public bool? ConditionEvaluated { get; set; } Property Value bool? Term One of TermIf, TermElse, TermEndif. public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Siemens.SiemensKeywords.html": {
    "href": "api/Hi.NcParsers.Keywords.Siemens.SiemensKeywords.html",
    "title": "Class SiemensKeywords | HiAPI-C# 2025",
    "summary": "Class SiemensKeywords Namespace Hi.NcParsers.Keywords.Siemens Assembly HiMech.dll Siemens Sinumerik G-code and M-code constants. public static class SiemensKeywords Inheritance object SiemensKeywords Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields Amirror AMIRROR: Additive programmable-frame mirroring. public const string Amirror = \"AMIRROR\" Field Value string Arot AROT: Additive programmable-frame rotation. public const string Arot = \"AROT\" Field Value string Arots AROTS: Additive programmable-frame rotation via solid angles (behaves like Arot). public const string Arots = \"AROTS\" Field Value string Ascale ASCALE: Additive programmable-frame scaling. public const string Ascale = \"ASCALE\" Field Value string Atrans ATRANS: Additive programmable-frame translation. public const string Atrans = \"ATRANS\" Field Value string Brisk BRISK: Stepped (brisk) axis acceleration profile. public const string Brisk = \"BRISK\" Field Value string CompCad COMPCAD: CAD-quality compressor on. public const string CompCad = \"COMPCAD\" Field Value string CompOf COMPOF: Compressor off. public const string CompOf = \"COMPOF\" Field Value string CompOn COMPON: Compressor on. public const string CompOn = \"COMPON\" Field Value string CrTag CR: Arc radius address (equals form, e.g. CR=5.5); sign selects the ≤180°/>180° arc. public const string CrTag = \"CR\" Field Value string Crots CROTS: Frame rotation with solid angles referencing the valid frame in the control's frame database — not simulated (no database frame chain offline). public const string Crots = \"CROTS\" Field Value string Cut3dc CUT3DC: 3D circumferential cutter compensation mode word (used with TRAORI) — recognized, not simulated (radius compensation stays 2D offline). public const string Cut3dc = \"CUT3DC\" Field Value string Cycle800 CYCLE800: Swivel cycle (tilted work plane + implicit rotary positioning). public const string Cycle800 = \"CYCLE800\" Field Value string Cycle81 CYCLE81: Drilling / centering cycle (rapid retract). public const string Cycle81 = \"CYCLE81\" Field Value string Cycle82 CYCLE82: Drilling / counterboring cycle (dwell at depth). public const string Cycle82 = \"CYCLE82\" Field Value string Cycle83 CYCLE83: Deep-hole drilling cycle (chip-break / stock-removal pecking). public const string Cycle83 = \"CYCLE83\" Field Value string Cycle832 CYCLE832: High-speed-settings cycle (tolerance + machining mode). public const string Cycle832 = \"CYCLE832\" Field Value string Cycle85 CYCLE85: Reaming / boring cycle (feed in, feed out). public const string Cycle85 = \"CYCLE85\" Field Value string Else ELSE: Alternative branch of a block conditional. public const string Else = \"ELSE\" Field Value string Endfor ENDFOR: Counting loop terminator. public const string Endfor = \"ENDFOR\" Field Value string Endif ENDIF: Block-conditional terminator. public const string Endif = \"ENDIF\" Field Value string Endloop ENDLOOP: Endless loop terminator (back-jump; offline replay bounded by the loop watchdog). public const string Endloop = \"ENDLOOP\" Field Value string Endwhile ENDWHILE: Pre-test loop terminator. public const string Endwhile = \"ENDWHILE\" Field Value string ExtendedCoordinateSeries G54–G57 supported as ISO-compatible. Extended via G505–G599. public static readonly string[] ExtendedCoordinateSeries Field Value string[] Ffwof FFWOF: Feedforward control off. public const string Ffwof = \"FFWOF\" Field Value string Ffwon FFWON: Feedforward control on. public const string Ffwon = \"FFWON\" Field Value string Fnorm FNORM: Feedrate profile — F value applies as a constant per block (DIN 66025 default). public const string Fnorm = \"FNORM\" Field Value string For FOR: Counting loop entry (FOR var = start TO end ... ENDFOR). public const string For = \"FOR\" Field Value string G153 G153: Suppress all frames (incl. base/system) for one block. public const string G153 = \"G153\" Field Value string G500 G500: Cancel all work coordinate offsets (machine coordinate mode). public const string G500 = \"G500\" Field Value string G60 G60: Exact stop (modal). public const string G60 = \"G60\" Field Value string G601 G601: Exact-stop criterion — fine positioning window. public const string G601 = \"G601\" Field Value string G602 G602: Exact-stop criterion — coarse positioning window. public const string G602 = \"G602\" Field Value string G64 G64: Continuous-path mode. public const string G64 = \"G64\" Field Value string G641 G641: Continuous-path mode with programmable blending distance (ADIS). public const string G641 = \"G641\" Field Value string G642 G642: Continuous-path mode with axis-tolerance blending. public const string G642 = \"G642\" Field Value string G70 G70: Inch input system (geometry words only; feed stays as configured). public const string G70 = \"G70\" Field Value string G700 G700: Inch input system incl. feedrate interpretation. public const string G700 = \"G700\" Field Value string G71 G71: Metric input system (geometry words only). public const string G71 = \"G71\" Field Value string G710 G710: Metric input system incl. feedrate interpretation. public const string G710 = \"G710\" Field Value string G74 G74: Reference-point approach — the axes written in the block travel to their machine reference point (not the Fanuc LH tapping cycle; the Siemens preset excludes G74 from the canned-cycle vocabulary). Non-modal; axis values are dummies; machine coordinates, frames bypassed. Consumed by SiemensFixedPointReturnSyntax. public const string G74 = \"G74\" Field Value string G75 G75: Fixed-point approach — like G74 but targeting a machine-data fixed point (MD30600 $MA_FIX_POINT_POS, not yet modeled — see SiemensFixedPointReturnSyntax). public const string G75 = \"G75\" Field Value string Gotob GOTOB: Jump backward (toward start of program) to a label or block number. public const string Gotob = \"GOTOB\" Field Value string Gotof GOTOF: Jump forward (toward end of program) to a label or block number. public const string Gotof = \"GOTOF\" Field Value string If IF: Conditional — block form (IF cond ... ENDIF) or single-line jump (IF cond GOTOF lbl). public const string If = \"IF\" Field Value string Loop LOOP: Endless loop entry (LOOP ... ENDLOOP; exits via jump or return). public const string Loop = \"LOOP\" Field Value string M17 M17: Subprogram end (return to caller). public const string M17 = \"M17\" Field Value string Mcall MCALL: Modal subprogram/cycle call — re-executed at every subsequent motion block; bare MCALL cancels. public const string Mcall = \"MCALL\" Field Value string Mirror MIRROR: Absolute programmable-frame mirroring. public const string Mirror = \"MIRROR\" Field Value string Proc PROC: Subprogram declaration header (program name + parameter list). public const string Proc = \"PROC\" Field Value string Repeat REPEAT: Repeat the program section between two labels (REPEAT LBL1 LBL0 P=n). public const string Repeat = \"REPEAT\" Field Value string Ret RET: Subprogram return without function output (M17 sibling). public const string Ret = \"RET\" Field Value string Rot ROT: Absolute programmable-frame rotation (resets the whole programmable frame). public const string Rot = \"ROT\" Field Value string Rots ROTS: Absolute programmable-frame rotation via solid angles (behaves like Rot; two angles orient a plane, the first-named axis stays in its old plane). public const string Rots = \"ROTS\" Field Value string RplTag RPL: Rotation in the active plane (equals form, e.g. ROT RPL=45) — around the G17/G18/G19 plane normal. public const string RplTag = \"RPL\" Field Value string Scale SCALE: Absolute programmable-frame scaling. public const string Scale = \"SCALE\" Field Value string Soft SOFT: Jerk-limited (soft) axis acceleration profile. public const string Soft = \"SOFT\" Field Value string Spath SPATH: Path parameter follows arc length (path-reference group, vs UPATH). public const string Spath = \"SPATH\" Field Value string Stopre STOPRE: Stop the preprocessing run (block-search buffer sync). No offline effect. public const string Stopre = \"STOPRE\" Field Value string Supa SUPA: Suppress all frames plus handwheel (DRF) / external offsets for one block. Superset of G153; in this pipeline both reduce to a one-shot machine-coordinate move. public const string Supa = \"SUPA\" Field Value string To TO: Bound separator inside the FOR statement. public const string To = \"TO\" Field Value string Trafoof TRAFOOF: All kinematic transformations off (ends TRAORI; plain length compensation stays). public const string Trafoof = \"TRAFOOF\" Field Value string Trans TRANS: Absolute programmable-frame translation (resets the whole programmable frame). public const string Trans = \"TRANS\" Field Value string Traori TRAORI: Orientation transformation on (RTCP — tool length follows tool orientation). public const string Traori = \"TRAORI\" Field Value string TurnTag TURN: Additional full-circle count for helices (equals form, e.g. TURN=16). public const string TurnTag = \"TURN\" Field Value string Until UNTIL: Post-test loop condition (REPEAT ... UNTIL cond; the bare REPEAT opens the loop). public const string Until = \"UNTIL\" Field Value string Upath UPATH: Path parameter follows spline parameter (path-reference group, vs SPATH). public const string Upath = \"UPATH\" Field Value string While WHILE: Pre-test loop entry (WHILE cond ... ENDWHILE). public const string While = \"WHILE\" Field Value string"
  },
  "api/Hi.NcParsers.Keywords.Siemens.SiemensLabel.html": {
    "href": "api/Hi.NcParsers.Keywords.Siemens.SiemensLabel.html",
    "title": "Class SiemensLabel | HiAPI-C# 2025",
    "summary": "Class SiemensLabel Namespace Hi.NcParsers.Keywords.Siemens Assembly HiMech.dll Block-root record for a Siemens label line (LBL1:), written by SiemensLabelSyntax. Labels are passive jump targets — the record only makes the consumed token visible to cache dumps and lets SiemensRepeatSyntax's scan probe match candidates. public class SiemensLabel Inheritance object SiemensLabel Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Name Label identifier without the trailing colon. public string Name { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Siemens.SiemensLoop.html": {
    "href": "api/Hi.NcParsers.Keywords.Siemens.SiemensLoop.html",
    "title": "Class SiemensLoop | HiAPI-C# 2025",
    "summary": "Class SiemensLoop Namespace Hi.NcParsers.Keywords.Siemens Assembly HiMech.dll Siemens LOOP ... ENDLOOP endless-loop record. The construct has no exit condition — real programs leave it via GOTOF/GOTOB or a subprogram return; offline replay is bounded by SiemensLoopIterationDependency, which is therefore a hard requirement for the ENDLOOP back-jump (a missing watchdog suppresses the jump instead of hanging the pipeline). public class SiemensLoop Inheritance object SiemensLoop Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields TermEndloop Endless-loop terminator term. public const string TermEndloop = \"ENDLOOP\" Field Value string TermLoop Endless-loop entry term. public const string TermLoop = \"LOOP\" Field Value string Properties Term One of TermLoop, TermEndloop. public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Siemens.SiemensLoopFrame.html": {
    "href": "api/Hi.NcParsers.Keywords.Siemens.SiemensLoopFrame.html",
    "title": "Class SiemensLoopFrame | HiAPI-C# 2025",
    "summary": "Class SiemensLoopFrame Namespace Hi.NcParsers.Keywords.Siemens Assembly HiMech.dll One entry on the SiemensLoopFrames stack. Identity is (Kind, FilePath, BeginLineNo) — the file path disambiguates a loop line in the main program from the same line number inside an inlined subprogram, and lets the terminator refuse a cross-file mismatch. public class SiemensLoopFrame Inheritance object SiemensLoopFrame Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields KindFor Kind value for FOR frames. public const string KindFor = \"FOR\" Field Value string KindLoop Kind value for LOOP frames. public const string KindLoop = \"LOOP\" Field Value string KindRepeat Kind value for REPEAT/UNTIL frames. public const string KindRepeat = \"REPEAT\" Field Value string KindWhile Kind value for WHILE frames. public const string KindWhile = \"WHILE\" Field Value string Properties AdvancePending FOR frames only: set by the ENDFOR back-jump just before it rewinds, cleared by the FOR head on arrival. Distinguishes the legitimate iteration re-arrival (advance the counter) from a re-entry via GOTOF/GOTOB while the frame is still on the stack — Sinumerik restarts the construct in that case, so the FOR head drops the stale frame and re-initialises. public bool AdvancePending { get; set; } Property Value bool BeginLineNo 0-based file line index of the loop-entry block — the back-jump target. public int BeginLineNo { get; set; } Property Value int End FOR frames only: inclusive end bound resolved once at loop entry. public double End { get; set; } Property Value double FilePath Source-level file path of the loop-entry block (Sentence.FilePath relative form). public string FilePath { get; set; } Property Value string Kind Construct kind: one of the Kind* constants. public string Kind { get; set; } Property Value string Value FOR frames only: current counter value. public double Value { get; set; } Property Value double Var FOR frames only: loop variable name. public string Var { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Siemens.SiemensLoopFrames.html": {
    "href": "api/Hi.NcParsers.Keywords.Siemens.SiemensLoopFrames.html",
    "title": "Class SiemensLoopFrames | HiAPI-C# 2025",
    "summary": "Class SiemensLoopFrames Namespace Hi.NcParsers.Keywords.Siemens Assembly HiMech.dll Block-root carrier for the active Siemens loop-construct stack, mutated by SiemensLoopSyntax at the Evaluation stage and carried block-to-block by ModalCarrySyntax's Logic tracked-key list (plus an eager previous-block clone inside the loop syntax itself, mirroring the Fanuc WhileFrames pattern). Wrapped in a JSON object ({ “Frames”: [ ... ] }) rather than a bare array so the ModalCarry deep-clone JsonObject carry applies — the same reason CallStack wraps its frame list. A single shared stack (rather than one per construct kind) is what makes mixed-construct nesting work: a FOR inside a WHILE pushes on top of the WHILE frame, and each terminator validates that the innermost (last) frame carries its own Kind. public class SiemensLoopFrames Inheritance object SiemensLoopFrames Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields FramesKey JSON key of the frame array (bottom of stack first). public const string FramesKey = \"Frames\" Field Value string"
  },
  "api/Hi.NcParsers.Keywords.Siemens.SiemensPathSmoothing.html": {
    "href": "api/Hi.NcParsers.Keywords.Siemens.SiemensPathSmoothing.html",
    "title": "Class SiemensPathSmoothing | HiAPI-C# 2025",
    "summary": "Class SiemensPathSmoothing Namespace Hi.NcParsers.Keywords.Siemens Assembly HiMech.dll Section data holder for ISiemensPathSmoothingDef. public class SiemensPathSmoothing : PathSmoothing, ISiemensPathSmoothingDef, IPathSmoothingDef Inheritance object PathSmoothing SiemensPathSmoothing Implements ISiemensPathSmoothingDef IPathSmoothingDef Inherited Members PathSmoothing.IsEnabled PathSmoothing.Term object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties AccelProfile Acceleration profile group: SOFT (jerk-limited) / BRISK. public string AccelProfile { get; set; } Property Value string Compressor Compressor group: COMPCAD / COMPON / COMPOF. public string Compressor { get; set; } Property Value string ExactStopCriterion Exact-stop criterion group: G601 (fine) / G602 (coarse). public string ExactStopCriterion { get; set; } Property Value string FeedForward Feedforward group: FFWON / FFWOF. public string FeedForward { get; set; } Property Value string FeedProfile Feedrate profile group: FNORM. public string FeedProfile { get; set; } Property Value string Mode CYCLE832 technology/mode argument verbatim (e.g. _ORI_FINISH, 1) while armed. public string Mode { get; set; } Property Value string PathControl Path-control group: G60 (exact stop) / G64 / G641 / G642 (continuous path). public string PathControl { get; set; } Property Value string PathReference Path-reference group: UPATH / SPATH. public string PathReference { get; set; } Property Value string Tolerance CYCLE832 machining tolerance (first argument, mm) while armed; absent when CYCLE832 is cancelled. A non-numeric source argument (variable/expression) is preserved verbatim as a string in the JSON section for the future evaluator. public double? Tolerance { get; set; } Property Value double?"
  },
  "api/Hi.NcParsers.Keywords.Siemens.SiemensProc.html": {
    "href": "api/Hi.NcParsers.Keywords.Siemens.SiemensProc.html",
    "title": "Class SiemensProc | HiAPI-C# 2025",
    "summary": "Class SiemensProc Namespace Hi.NcParsers.Keywords.Siemens Assembly HiMech.dll Block-root record for a Siemens PROC declaration header, written by SiemensProcSyntax. The declaration is consumed whole (parameter binding is a later work item); Statement keeps the verbatim remainder visible. public class SiemensProc Inheritance object SiemensProc Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Name Declared subprogram name. public string Name { get; set; } Property Value string Statement Verbatim declaration remainder after the name (parameter list, SAVE/DISPLOF attributes); null when empty. public string Statement { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Siemens.SiemensRepeat.html": {
    "href": "api/Hi.NcParsers.Keywords.Siemens.SiemensRepeat.html",
    "title": "Class SiemensRepeat | HiAPI-C# 2025",
    "summary": "Class SiemensRepeat Namespace Hi.NcParsers.Keywords.Siemens Assembly HiMech.dll Siemens REPEAT record. Parsing.SiemensRepeat carries the captured label pair; the block-root section written by SiemensRepeatSyntax adds the firing outcome, and every inlined repetition block is stamped with a clone carrying Iteration so cache-dump readers can see which pass a block belongs to. public class SiemensRepeat Inheritance object SiemensRepeat Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties End End label name; null for the single-label form (not simulated in P4). public string End { get; set; } Property Value string Fired True when the section was actually inlined for re-execution. public bool Fired { get; set; } Property Value bool Iteration 1-based repetition ordinal stamped on inlined body blocks. public int Iteration { get; set; } Property Value int P Repetition count from P=n; defaults to 1 when absent. public int P { get; set; } Property Value int Start Start label name (REPEAT LBL1 LBL0 → “LBL1”). public string Start { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Siemens.SiemensRepeatUntil.html": {
    "href": "api/Hi.NcParsers.Keywords.Siemens.SiemensRepeatUntil.html",
    "title": "Class SiemensRepeatUntil | HiAPI-C# 2025",
    "summary": "Class SiemensRepeatUntil Namespace Hi.NcParsers.Keywords.Siemens Assembly HiMech.dll Siemens REPEAT ... UNTIL <cond> post-test loop record. The bare REPEAT line (no label — the labelled forms belong to SiemensRepeat) opens the loop; UNTIL evaluates the exit condition after each pass. public class SiemensRepeatUntil Inheritance object SiemensRepeatUntil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields TermRepeat Post-test loop entry term (bare REPEAT). public const string TermRepeat = \"REPEAT\" Field Value string TermUntil Post-test loop condition term. public const string TermUntil = \"UNTIL\" Field Value string Properties Condition Raw exit-condition text on the UNTIL phrase; substituted in place by the evaluator. Absent on REPEAT. Original text survives at Formula.SiemensRepeatUntil.Condition. public string Condition { get; set; } Property Value string ConditionEvaluated Tri-state exit outcome per UNTIL arrival: true — loop exits (falls through); false — back-jump to the matching REPEAT line for another pass; null — unresolved condition, warns and exits defensively (no redirect on unresolved input). public bool? ConditionEvaluated { get; set; } Property Value bool? Term One of TermRepeat, TermUntil. public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Siemens.SiemensWhile.html": {
    "href": "api/Hi.NcParsers.Keywords.Siemens.SiemensWhile.html",
    "title": "Class SiemensWhile | HiAPI-C# 2025",
    "summary": "Class SiemensWhile Namespace Hi.NcParsers.Keywords.Siemens Assembly HiMech.dll Siemens WHILE ... ENDWHILE pre-test loop record. Parsing.SiemensWhile carries the captured phrase; the block-root stamp adds the per-arrival gate outcome. Loop state lives on the shared SiemensLoopFrames stack managed by SiemensLoopSyntax. public class SiemensWhile Inheritance object SiemensWhile Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields TermEndwhile Loop terminator term. public const string TermEndwhile = \"ENDWHILE\" Field Value string TermWhile Loop entry term. public const string TermWhile = \"WHILE\" Field Value string Properties Condition Raw condition text on the WHILE phrase; substituted in place by the evaluator. Absent on ENDWHILE. Original text survives at Formula.SiemensWhile.Condition. public string Condition { get; set; } Property Value string ConditionEvaluated Tri-state gate outcome per WHILE arrival: true — body executes; false — loop exits (forward-jump past the matching ENDWHILE); null — unresolved condition, warns and exits the loop defensively (Fanuc WHILE precedent). public bool? ConditionEvaluated { get; set; } Property Value bool? Term One of TermWhile, TermEndwhile. public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Siemens.Stopre.html": {
    "href": "api/Hi.NcParsers.Keywords.Siemens.Stopre.html",
    "title": "Class Stopre | HiAPI-C# 2025",
    "summary": "Class Stopre Namespace Hi.NcParsers.Keywords.Siemens Assembly HiMech.dll Block-root section recording a consumed Siemens STOPRE (stop preprocessing / block-search buffer sync), written by SiemensStopreSyntax. STOPRE has no effect in offline simulation — the section exists solely so the token survives for bidirectional NC-text reconstruction. public class Stopre Inheritance object Stopre Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Term Source token, always STOPRE. public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Siemens.html": {
    "href": "api/Hi.NcParsers.Keywords.Siemens.html",
    "title": "Namespace Hi.NcParsers.Keywords.Siemens | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.Keywords.Siemens Classes Msg Block-root section recording a Siemens MSG(\"...\") operator display message, written by SiemensMsgSyntax. A section without Text records the bare MSG() clear form. Record-only: simulation ignores it; the section exists for bidirectional NC-text reconstruction and UI display. SiemensCall Siemens subprogram-call record. Two lifetimes share the shape: Parsing.SiemensCall — written by SiemensCallStatementSyntax when a whole-line call statement is captured (L9810, L123 P3, HQ_FC(1,2)). Carries Name, optional verbatim Args, optional P. block-root SiemensCall — written by SiemensSubProgramCallSyntax on the host block and on every inlined body block once the call is consumed. FileName records the resolved subprogram file; Skipped marks the safe-skip outcome (no file found — OEM / measuring cycles like HQ_FC, Renishaw L9810) where the call is consumed with zero motion effect and a structured warning replaces the raw unparsed-text noise. SiemensFor Siemens FOR <var> = <start> TO <end> ... ENDFOR counting-loop record. The Parsing capture stores the start expression as a single-entry Init map ({ “R1”: 0 }) — the variable name is a JSON key, which the evaluator's pass-2 tree walk never rewrites (values only), so a loop variable whose name matches a set named variable is not clobbered; the start/end values are substituted normally. The block-root stamp records the loop variable and its per-iteration Value. SiemensGoto Siemens GOTOF/GOTOB jump record. Two lifetimes share the shape: Parsing.SiemensGoto — written by SiemensGotoParsingSyntax for both the bare jump (GOTOF LBL1) and the single-line conditional (IF R1==1 GOTOF LBL1). block-root SiemensGoto — stamped by SiemensGotoSyntax after the control-flow decision, with Fired flipped true on a successful redirect. Unlike Fanuc's numbered GOTO n, the target is a named label (LBL1: line) or an N<num> block number; direction is explicit in the mnemonic — GOTOF scans forward from the host line, GOTOB scans backward to the nearest label above. SiemensIf Siemens IF/ELSE/ENDIF block-conditional record. Parsing.SiemensIf carries the captured phrase; the block-root stamp written by SiemensIfSyntax adds the gate outcome. Unlike the loop family there is no frame stack: an ELSE reached in the normal stream always means the true branch just finished (a false condition jumps past the ELSE line directly), so ELSE unconditionally skips to its matching ENDIF and ENDIF itself is a consumed no-op. SiemensKeywords Siemens Sinumerik G-code and M-code constants. SiemensLabel Block-root record for a Siemens label line (LBL1:), written by SiemensLabelSyntax. Labels are passive jump targets — the record only makes the consumed token visible to cache dumps and lets SiemensRepeatSyntax's scan probe match candidates. SiemensLoop Siemens LOOP ... ENDLOOP endless-loop record. The construct has no exit condition — real programs leave it via GOTOF/GOTOB or a subprogram return; offline replay is bounded by SiemensLoopIterationDependency, which is therefore a hard requirement for the ENDLOOP back-jump (a missing watchdog suppresses the jump instead of hanging the pipeline). SiemensLoopFrame One entry on the SiemensLoopFrames stack. Identity is (Kind, FilePath, BeginLineNo) — the file path disambiguates a loop line in the main program from the same line number inside an inlined subprogram, and lets the terminator refuse a cross-file mismatch. SiemensLoopFrames Block-root carrier for the active Siemens loop-construct stack, mutated by SiemensLoopSyntax at the Evaluation stage and carried block-to-block by ModalCarrySyntax's Logic tracked-key list (plus an eager previous-block clone inside the loop syntax itself, mirroring the Fanuc WhileFrames pattern). Wrapped in a JSON object ({ “Frames”: [ ... ] }) rather than a bare array so the ModalCarry deep-clone JsonObject carry applies — the same reason CallStack wraps its frame list. A single shared stack (rather than one per construct kind) is what makes mixed-construct nesting work: a FOR inside a WHILE pushes on top of the WHILE frame, and each terminator validates that the innermost (last) frame carries its own Kind. SiemensPathSmoothing Section data holder for ISiemensPathSmoothingDef. SiemensProc Block-root record for a Siemens PROC declaration header, written by SiemensProcSyntax. The declaration is consumed whole (parameter binding is a later work item); Statement keeps the verbatim remainder visible. SiemensRepeat Siemens REPEAT record. Parsing.SiemensRepeat carries the captured label pair; the block-root section written by SiemensRepeatSyntax adds the firing outcome, and every inlined repetition block is stamped with a clone carrying Iteration so cache-dump readers can see which pass a block belongs to. SiemensRepeatUntil Siemens REPEAT ... UNTIL <cond> post-test loop record. The bare REPEAT line (no label — the labelled forms belong to SiemensRepeat) opens the loop; UNTIL evaluates the exit condition after each pass. SiemensWhile Siemens WHILE ... ENDWHILE pre-test loop record. Parsing.SiemensWhile carries the captured phrase; the block-root stamp adds the per-arrival gate outcome. Loop state lives on the shared SiemensLoopFrames stack managed by SiemensLoopSyntax. Stopre Block-root section recording a consumed Siemens STOPRE (stop preprocessing / block-search buffer sync), written by SiemensStopreSyntax. STOPRE has no effect in offline simulation — the section exists solely so the token survives for bidirectional NC-text reconstruction. Interfaces ISiemensPathSmoothingDef Siemens path-control / smoothing modal registers recorded by SiemensPathSmoothingSyntax under the brand-invariant PathSmoothing section key. Record-only — simulation does not alter the tool path; the registers exist for bidirectional NC-text reconstruction and UI display. Each property mirrors one orthogonal Sinumerik modal group; a property is absent from the JSON section until its group is first programmed. IsEnabled is derived: true while a CYCLE832 high-speed setting is armed (Tolerance present) or a continuous-path mode (G64/G641/G642) is active. Term records the token that last changed the path-control state (a G code or CYCLE832)."
  },
  "api/Hi.NcParsers.Keywords.SpindleControl.html": {
    "href": "api/Hi.NcParsers.Keywords.SpindleControl.html",
    "title": "Class SpindleControl | HiAPI-C# 2025",
    "summary": "Class SpindleControl Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section key holder + concrete implementation for ISpindleControlDef. public class SpindleControl : ISpindleControlDef Inheritance object SpindleControl Implements ISpindleControlDef Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Direction Target spindle direction (STOP, CW, CCW). public SpindleDirection Direction { get; set; } Property Value SpindleDirection"
  },
  "api/Hi.NcParsers.Keywords.SpindleOrientation.html": {
    "href": "api/Hi.NcParsers.Keywords.SpindleOrientation.html",
    "title": "Class SpindleOrientation | HiAPI-C# 2025",
    "summary": "Class SpindleOrientation Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section key holder + concrete implementation for ISpindleOrientationDef. public class SpindleOrientation : ISpindleOrientationDef Inheritance object SpindleOrientation Implements ISpindleOrientationDef Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Angle_deg Target spindle stop angle in degrees. public double Angle_deg { get; set; } Property Value double"
  },
  "api/Hi.NcParsers.Keywords.SpindleSpeed.html": {
    "href": "api/Hi.NcParsers.Keywords.SpindleSpeed.html",
    "title": "Class SpindleSpeed | HiAPI-C# 2025",
    "summary": "Class SpindleSpeed Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section key holder + concrete implementation for ISpindleSpeedDef. public class SpindleSpeed : ISpindleSpeedDef Inheritance object SpindleSpeed Implements ISpindleSpeedDef Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Direction Spindle rotation direction. Stored in JSON as the enum name (e.g. “CW”, “CCW”, “STOP”). public SpindleDirection Direction { get; set; } Property Value SpindleDirection SpindleSpeed_rpm Spindle speed in RPM. public double SpindleSpeed_rpm { get; set; } Property Value double"
  },
  "api/Hi.NcParsers.Keywords.SubProgramCall.html": {
    "href": "api/Hi.NcParsers.Keywords.SubProgramCall.html",
    "title": "Class SubProgramCall | HiAPI-C# 2025",
    "summary": "Class SubProgramCall Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Subprogram call record left by SubProgramCallSyntax on the M98 / M198 host block and on every inlined body block. The call itself emits no motion act; this section is bookkeeping so cache dumps and diagnostic readers can see \"this block triggered (or sits inside) an inline of program P\". M98 and M198 share the exact same section shape. The difference between them is purely environmental — which folder the resolver looks in (SubProgramFolderConfig.InternalFolder vs ExternalFolder) — and that lives on the dependency, not in this JSON record. public class SubProgramCall Inheritance object SubProgramCall Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties FileName Bare matched file name (e.g. “O1234.NC”). The resolver tries several fallback patterns (FilenamePatterns); this records which one hit. JSON-portable across environments — the folder context (internal vs external storage) is captured by the host's SubProgramFolderConfig dependency, not encoded here. public string FileName { get; set; } Property Value string L Repeat count from the L parameter; defaults to 1 when absent. public int L { get; set; } Property Value int P Subprogram number from the P parameter (e.g., 1234 for O1234). public int P { get; set; } Property Value int Term Triggering keyword: “M98” (internal) or “M198” (external storage). public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.SubProgramReturn.html": {
    "href": "api/Hi.NcParsers.Keywords.SubProgramReturn.html",
    "title": "Class SubProgramReturn | HiAPI-C# 2025",
    "summary": "Class SubProgramReturn Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Subprogram return record left on the M99 host block by SubProgramReturnSyntax. Return blocks produce no motion acts; this section makes the consumed M99 visible in cache dumps and surfaces the M99 P{seq} jump decision. public class SubProgramReturn Inheritance object SubProgramReturn Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties JumpedToN Set to P when the M99 actually redirected control flow to the caller's N{seq} block via ReplaceSource(IEnumerable<T>). Null on plain M99 (no P), and on M99 P{seq} that fell through because the jump could not be carried out. public int? JumpedToN { get; set; } Property Value int? P Optional caller sequence number from the P parameter (M99 P{seq}). Null on a plain M99. When non-null and the jump fires, JumpedToN is set to the same value; when the jump is suppressed (no caller frame, label not found, iteration limit reached) JumpedToN stays null and a warning is emitted. public int? P { get; set; } Property Value int? Term Triggering keyword (always “M99” for now). public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.TapeBoundary.html": {
    "href": "api/Hi.NcParsers.Keywords.TapeBoundary.html",
    "title": "Class TapeBoundary | HiAPI-C# 2025",
    "summary": "Class TapeBoundary Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Tape leader / trailer line — the literal % that historically marked the start and end of a punched paper-tape program. ISO-style controllers (Fanuc, Mazak, Syntec, Siemens) all preserve it as a file-level boundary marker. Distinct from a comment: the controller uses it as a tape/file delimiter, not as embedded operator text. public class TapeBoundary Inheritance object TapeBoundary Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Text Free-form content after the % on the same line, typically empty. public string Text { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.TiltTransform.html": {
    "href": "api/Hi.NcParsers.Keywords.TiltTransform.html",
    "title": "Class TiltTransform | HiAPI-C# 2025",
    "summary": "Class TiltTransform Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Concrete class for ITiltTransformDef section serialization. public class TiltTransform : ITiltTransformDef Inheritance object TiltTransform Implements ITiltTransformDef Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Term CNC term for tilt: “G68”, “G68.2”, “G69”, “PLANE SPATIAL”, “CYCLE800”, etc. public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.ToolHeightCompensation.html": {
    "href": "api/Hi.NcParsers.Keywords.ToolHeightCompensation.html",
    "title": "Class ToolHeightCompensation | HiAPI-C# 2025",
    "summary": "Class ToolHeightCompensation Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section key holder for IToolHeightCompensationDef. public class ToolHeightCompensation : IToolHeightCompensationDef Inheritance object ToolHeightCompensation Implements IToolHeightCompensationDef Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties OffsetId Generic offset selector: Fanuc H number, Heidenhain T number, Mazak/Okuma H number. For Siemens (T+D addressing), see ISiemensToolOffsetConfig. public int OffsetId { get; set; } Property Value int Offset_mm Derived effective tool height compensation in mm. Computed from Term and OffsetId: looks up the offset table for OffsetId, obtains the effective height (geometry minus wear), then applies sign from Term (positive for G43/G43.4, negative for G44, zero for G49). public double Offset_mm { get; set; } Property Value double Term CNC term for tool height compensation: “G43”, “G43.4”, “G44”, “G49”. Brand-specific syntaxes may write equivalent terms (e.g., “TRAORI” for Siemens, “M128” for Heidenhain). public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Unit.html": {
    "href": "api/Hi.NcParsers.Keywords.Unit.html",
    "title": "Class Unit | HiAPI-C# 2025",
    "summary": "Class Unit Namespace Hi.NcParsers.Keywords Assembly HiMech.dll Section key holder + concrete implementation for IUnitDef. public class Unit : IUnitDef Inheritance object Unit Implements IUnitDef Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Inch Inch unit-system name (corresponds to G20). public const string Inch = \"Inch\" Field Value string Metric Metric unit-system name (corresponds to G21). public const string Metric = \"Metric\" Field Value string Properties System Abstract name of the unit system (Metric / Inch). public string System { get; set; } Property Value string Term NC term of the unit code on this block (G20 or G21). public string Term { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Keywords.Vars.html": {
    "href": "api/Hi.NcParsers.Keywords.Vars.html",
    "title": "Class Vars | HiAPI-C# 2025",
    "summary": "Class Vars Namespace Hi.NcParsers.Keywords Assembly HiMech.dll JSON section schema for per-block variable storage. Each sub-property names a sub-section that holds a { “#nnn”: value } dictionary keyed by Fanuc-style variable id. The sub-sections partition the variable space by lifetime: Local — #1-#33, scope: macro call frame (pushed/popped by G65 / G66 / M99). Volatile — #100-#499, non-retained common; carries block-to-block, cleared by ProgramEndCleanSyntax on M02 / M30. SystemControl — #3000-#3999, controller-side system variables; offline-only round-trip record (real controller effects such as clock reset / alarm trigger / message pause are not simulated). The property types are JsonObject rather than strongly-typed dictionaries because each sub-section's keys are dynamic Fanuc variable ids (#100, #5001, …) discovered at parse time, not a fixed schema. This class exists solely to give the section name and sub-keys stable nameof() targets — instances are never constructed at runtime. public class Vars Inheritance object Vars Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Local Macro-local sub-section (#1-#33). public JsonObject Local { get; set; } Property Value JsonObject Named Named program-variable sub-section (Siemens GUD/LUD identifiers such as _X_HOME). Carried forward block-by-block by SiemensNamedVariableReadingSyntax. public JsonObject Named { get; set; } Property Value JsonObject SystemControl System-control sub-section (#3000-#3999). public JsonObject SystemControl { get; set; } Property Value JsonObject SystemNamed Named system-variable sub-section (Siemens $ variables the pipeline records but does not simulate). Carried forward block-by-block by SiemensSystemVariableSyntax. public JsonObject SystemNamed { get; set; } Property Value JsonObject Volatile Non-retained common sub-section (#100-#499). public JsonObject Volatile { get; set; } Property Value JsonObject"
  },
  "api/Hi.NcParsers.Keywords.html": {
    "href": "api/Hi.NcParsers.Keywords.html",
    "title": "Namespace Hi.NcParsers.Keywords | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.Keywords Classes BlockSkip Optional block skip marker extracted from the head of an NC block. ISO 6983 / Fanuc calls this feature Block Delete (BDT switch); Siemens / Syntec / Mazak use the same / prefix with matching behaviour. The section is only present on blocks that carry a / prefix. Whether the block's NC commands are actually skipped at runtime depends on IBlockSkipConfig: Config absent or the Layer bit OFF → the / prefix is consumed, Body is left null, and the rest of the line parses as a regular NC block (comments still take effect). Config present and the Layer bit ON → the rest of the line is moved into Body and cleared from UnparsedText, so downstream parsing syntaxes see nothing and no NC action is emitted. Comment syntaxes run before this one so comments (and any embedded CsScript) still take effect. Not a comment: a comment is static metadata, block skip is a runtime toggle that can change per machine/operator setting. CallFrame One entry in Frames. Holds the caller-side information consumers need to “unwind” or “look back” — currently only the relative file path of the caller, used by SubProgramReturnSyntax on M99 P{seq} to locate the caller's N{seq} block. CallStack JSON-section data shape representing the active call-frame stack on a block — pushed by call-and-inline syntaxes (SubProgramCallSyntax for M98/M198, FanucMacroCallSyntax for G65, and FanucModalMacroSyntax's expansion phase for G66 implicit triggers) and popped by SubProgramReturnSyntax on M99. Every block between push and pop carries the section forward via ModalCarrySyntax; the caller's blocks before push and after pop carry the surrounding stack state (typically empty when running from the main file). The section is wrapped in a JsonObject rather than exposed as a bare JsonArray so it fits ModalCarry's \"deep-clone JsonObject\" carry pattern — the array of frames lives inside Frames. CannedCycle Section key holder + concrete implementation for ICannedCycleDef. Comment Comment extracted from an NC block. Symbol identifies the comment style; Text holds the content without the symbol. Downstream syntaxes (e.g., CsScript) may further trim Text after extracting embedded markers. CompoundMotion Section key holder + concrete implementation for ICompoundMotionDef. Coolant Section key holder + concrete implementation for ICoolantDef. CoordinateOffset Work coordinate offset state written by IsoCoordinateOffsetSyntax. Property names are used as JSON keys via nameof. Managed commands (ISO): G54, G55, G56, G57, G58, G59, G59.1–G59.9. Siemens: G54–G57 + G505–G599 (extended), G500 to cancel. Heidenhain: CYCL DEF 247 (Datum Preset) / CYCL DEF 7 (Datum Shift). CsScript Section-key holder for inline C# scripts attached to an NC block. Carries BeginScript (run before the block's acts) and EndScript (run after). Resolved by CsScriptBeginSemantic and CsScriptEndSemantic. Dwell Section key holder + concrete implementation for IDwellDef. FanucGoto Fanuc Custom Macro B GOTO record. Stamped on the host block by FanucGotoSyntax after the control-flow decision has been made; produced earlier by FanucGotoParsingSyntax as a parsing-stage sub-section (Parsing.FanucGoto) carrying the raw captured fields. Two source forms map to the same shape: GOTO <n> — unconditional jump. Condition is null. IF [<bool-expr>] GOTO <n> — conditional jump. Condition holds the expression text from inside the brackets. At parsing time N is a raw token from the source — it may be a literal (\"100\"), a variable reference (\"#1\"), or a bracketed expression (\"#[#2+5]\"). VariableEvaluatorSyntax substitutes a resolved literal back into the same field in the Evaluation bundle; FanucGotoSyntax then int.TryParses the final string to produce an int target. Lifecycle of the condition fields. Condition is written at Parsing time as the raw expression text and substituted in place by VariableEvaluatorSyntax pass-2 — the original text is preserved at Formula.FanucGoto.Condition when substitution succeeds. ConditionEvaluated is the host-level stamp written by FanucGotoSyntax carrying the tri-state truthy outcome. FanucHpcc Section data holder for IFanucHpccDef. FanucIfThen Fanuc Custom Macro B IF [<cond>] THEN <body> single-block conditional record. Stamped on the host block by FanucIfThenSyntax after the gate decision; produced earlier by FanucIfThenParsingSyntax as a parsing-stage sub-section (Parsing.FanucIfThen) carrying the raw captured fields plus an internal PendingAssignments sub-object harvested from the body text. Spec: IF [bool-expr] THEN <stmt> executes <stmt> only when the condition is truthy. Unlike FanucGoto's conditional form there is no jump — the body affects the current block only, no source splice, no label scan, no iteration watchdog. The most common body shape is a single Custom Macro B assignment (#nnn = <expr>); multiple assignments in one body are also accepted and lifted together. Condition is held as a string at parsing time so VariableEvaluatorSyntax's pass-2 tree walk can substitute it to a numeric JsonValue in place; the FanucIfThenSyntax tail then reads the resolved node polymorphically via the same ReadCondition shape used by FanucGotoSyntax. FanucMacroCall One-shot custom-macro-call record written by FanucMacroCallSyntax. Lives on both the G65 host block (the caller) and every inlined block of the macro body — so a cache-dump reader can land on any block inside the macro and immediately see “this block belongs to a G65 call of FileName with these argument bindings” without back-walking to find the host. Each inlined block additionally carries the resolved Vars.Local #1-#26 bindings derived from Args (see FanucMacroArgumentMap), so LocalVariableLookup resolves macro args in a single-block lookup. Frame isolation is structural: caller blocks never have Vars.Local written, so after the macro body ends, the next caller block reads null for any #1-#26 without any explicit frame marker. FanucModalMacro Modal-macro-call record left by FanucModalMacroSyntax. Carries Fanuc G66 setup state forward block-to-block until cancelled by G67. The section is also written on the G67 block itself (with Term = “G67”) so cache dumps show the cancel edge; subsequent blocks then carry no section at all. Per-block expansion of the modal call into an actual macro inline at every positioning move is not yet implemented — a FanucModalMacro--NotExpanded warning is emitted on the setup block to flag the simulation gap. The setup state itself is captured faithfully so external tooling can detect \"this block sits inside a G66 modal\" via the carried section. FanucPathSmoothing Section data holder for IFanucPathSmoothingDef. FanucProgramNumber Fanuc-family program identifier header that follows a TapeBoundary line — e.g. O1234 or <O1234>. Wrapper records the surface form so a parsed block can be emitted back to the original notation. FanucWhileDo Fanuc Custom Macro B WHILE/END bounded-loop record. Stamped on the host block by FanucWhileDoSyntax after the control-flow decision has been made; produced earlier by FanucWhileDoParsingSyntax as a parsing-stage sub-section (Parsing.FanucWhileDo) carrying the raw captured fields. Two phrases map to the same shape, distinguished by Term: WHILE [<bool-expr>] DO <m> — loop entry. Condition holds the expression text from inside the brackets at parsing time; substituted to a numeric JsonValue by VariableEvaluatorSyntax in place. ConditionEvaluated carries the host-level truthy outcome at stamp time. END <m> — loop terminator. Carries no condition; unconditionally reverse-jumps to the matching WHILE block on every execution (re-evaluation of the entry condition is the WHILE block's responsibility). LoopId is the spec-named \"identification number for nesting\" (the m in DO m / END m). Nested loops must use distinct LoopIds; matching is by exact value. Same-LoopId nesting is spec-undefined and not given special handling here. Active loop frames are carried block-to-block via the top-level WhileFrames JSON section (a JsonObject keyed by LoopId-as-string, each entry recording the BeginLineNo of the WHILE block that opened that frame). Carried by ModalCarrySyntax as part of its Logic tracked keys (mutated in Evaluation, must reach Logic-stage consumers and downstream blocks unchanged). Feedrate Section key holder + concrete implementation for IFeedrateDef. IndexNote JSON-section data shape pairing a single-character address symbol (e.g. ‘O’, ‘N’) with its numeric index, used to annotate program/sequence numbers on an NC block. IsoLocalCoordinateOffset ISO/Fanuc-family local coordinate offset state (G52) written by IsoLocalCoordinateOffsetSyntax. Property names are used as JSON keys via nameof. G52 X Y Z installs a local coordinate-system shift that stacks on top of the active G54-G59 work offset. The cancel mechanism is to write G52 X0 Y0 Z0 (or hit M30 / reset) — there is no separate G code for \"cancel\". The offset vector is therefore always modal: zero is a valid modal value, not a \"disabled\" state, so the section is recorded on every block. Brand-specific kin: Siemens TRANS/ATRANS (which can also carry rotation/scale/mirror) and Heidenhain TRANS DATUM are handled by their own syntaxes and write to their own sections — they do not share this key, because their data shapes are richer. MachineCoordinateState Section key holder for IMachineCoordinateStateDef. MacroFrame Top-level integer marker stamped onto a SyntaxPiece's JSON to identify which call frame the block belongs to. Brand-agnostic by design — written by FanucMacroCallSyntax today, reusable by any future call-inlining syntax (Fanuc G66 modal expansion, Heidenhain LBL CALL, …) that needs local-variable isolation across call boundaries. Semantics: the value is an opaque id; only equality matters. Two blocks with the same MacroFrame id share a call frame (locals visible across them via single-step carry); two blocks with different ids do not. The id 0 is reserved for the main program frame and is returned by Get(JsonObject) when the field is absent — so a plain caller block needs no stamp and yet compares distinct from any inlined frame. Stored as a top-level JSON int (not an object section) so it stays lightweight on every inlined block. Decoupled from FanucMacroCall: that section is a diagnostic record of the call (what file, what args), while MacroFrame is the purely functional marker the local-variable I/O syntaxes consult. MotionEvent Section key holder + concrete implementation for IMotionEventDef. MotionState Section key holder + concrete implementation for IMotionStateDef. PathSmoothing Section key holder for IPathSmoothingDef. PlaneSelect Section key holder for IPlaneSelectDef. PolarInterpolation Inner-key constants of the PolarInterpolationState section. Positioning Section key holder + concrete implementation for IPositioningDef. PositioningOverride Per-word positioning override — a non-modal block-root section keyed by word name (axis words and the I/J/K interpolation parameters) whose values are Absolute / Incremental / Shortest / PositiveOnly / NegativeOnly, plus the coded-position (indexing axis) family CodedAbsolute / CodedIncremental / CodedShortest / CodedPositiveOnly / CodedNegativeOnly. Overrides the modal G90/G91 Positioning state (and, for I/J/K, the default incremental center reading) for the listed words on this block only. Written by SiemensAcIcSyntax when a word carries one of the Siemens per-word coordinate function wrappers AC() / IC() / DC() / ACP() / ACN() or their coded-position counterparts CAC() / CIC() / CDC() / CACP() / CACN(), and by the Heidenhain L / C / CC / CYCL CALL POS parsers (through HeidenhainIncrementalAxisWordUtil) for the klartext I-prefixed incremental words IX+20 / IC+90 — always Incremental there, keyed by the plain axis letter. Not written for the CYCL DEF 7 datum-shift words: those are increments of the active shift, not of the tool position, and stay inside the cycle's own record. Consumed by IncrementalResolveSyntax (linear axes) and McAbcSyntax (rotary axes) — both treat every non-Incremental value as an absolute write, and both resolve a coded entry's indexing position number through CodedPositionUtil and rewrite the entry to its plain counterpart in place — by McAbcCyclicPathSyntax (the directional window for PositiveOnly / NegativeOnly and the non-modular-axis boundary warning; it never sees a coded value), and by SiemensCircularMotionSyntax (absolute I/J/K center components) — and, ahead of the shared resolve, by two consumers that take the raw word before it can see it: HeidenhainCannedCycleSyntax (CYCL CALL POS words and the M99/M89 root words, resolved against the last programmed position on the spot) and MachineCoordSelectSyntax (a distance in the machine frame); words without an entry keep the default behavior unchanged. The section is not listed in any ModalCarry key set — it never carries to later blocks. ProgramEnd Section key holder for IProgramEndDef. ProgramStop Section key holder + concrete implementation for IProgramStopDef. RadiusCompensation Section key holder + concrete implementation for IRadiusCompensationDef. SpindleControl Section key holder + concrete implementation for ISpindleControlDef. SpindleOrientation Section key holder + concrete implementation for ISpindleOrientationDef. SpindleSpeed Section key holder + concrete implementation for ISpindleSpeedDef. SubProgramCall Subprogram call record left by SubProgramCallSyntax on the M98 / M198 host block and on every inlined body block. The call itself emits no motion act; this section is bookkeeping so cache dumps and diagnostic readers can see \"this block triggered (or sits inside) an inline of program P\". M98 and M198 share the exact same section shape. The difference between them is purely environmental — which folder the resolver looks in (SubProgramFolderConfig.InternalFolder vs ExternalFolder) — and that lives on the dependency, not in this JSON record. SubProgramReturn Subprogram return record left on the M99 host block by SubProgramReturnSyntax. Return blocks produce no motion acts; this section makes the consumed M99 visible in cache dumps and surfaces the M99 P{seq} jump decision. TapeBoundary Tape leader / trailer line — the literal % that historically marked the start and end of a punched paper-tape program. ISO-style controllers (Fanuc, Mazak, Syntec, Siemens) all preserve it as a file-level boundary marker. Distinct from a comment: the controller uses it as a tape/file delimiter, not as embedded operator text. TiltTransform Concrete class for ITiltTransformDef section serialization. ToolHeightCompensation Section key holder for IToolHeightCompensationDef. Unit Section key holder + concrete implementation for IUnitDef. Vars JSON section schema for per-block variable storage. Each sub-property names a sub-section that holds a { “#nnn”: value } dictionary keyed by Fanuc-style variable id. The sub-sections partition the variable space by lifetime: Local — #1-#33, scope: macro call frame (pushed/popped by G65 / G66 / M99). Volatile — #100-#499, non-retained common; carries block-to-block, cleared by ProgramEndCleanSyntax on M02 / M30. SystemControl — #3000-#3999, controller-side system variables; offline-only round-trip record (real controller effects such as clock reset / alarm trigger / message pause are not simulated). The property types are JsonObject rather than strongly-typed dictionaries because each sub-section's keys are dynamic Fanuc variable ids (#100, #5001, …) discovered at parse time, not a fixed schema. This class exists solely to give the section name and sub-keys stable nameof() targets — instances are never constructed at runtime. Interfaces IArcMotionDef Arc motion data written by CircularMotionSyntax. Stored under the MotionEvent JSON section alongside IMotionEventDef properties. The arc plane is read from the modal PlaneSelect section via GetPlaneNormalDir(JsonObject) rather than cached on the event — same source of truth as IsoG68RotationSyntax. ICannedCycleDef Canned cycle modal state (Group 09). Captures which cycle is currently active, its return mode (G98/G99), and the resolved absolute parameter set used for modal lookback. Written by CannedCycleResolveSyntax on every block that belongs to the canned-cycle group: cycle code present (G81/G82/G83/G73/G84/G74/G85/G86/G89/G76/G87), modal repeat (cycle still active, only coordinates given), or explicit cancel (G80). Term = \"G80\" is the explicit-cancel sentinel used by FindPreviousActiveCycle(LazyLinkedListNode<SyntaxPiece>, string[]) to terminate modal lookback without ambiguity; regular blocks (e.g. G00 X.. Y..) simply omit the section entirely. ICompoundMotionDef Compound motion section definition for commands that produce multiple sub-operations (G28, G53.1, G81, G82, etc.). Contains a ItemsKey array resolved by Hi.NcParsers.Semantics.CompoundMotionSemanticUtil. Item types (discriminated by key presence): Hi.Motion — rapid/feed linear motion (IMotionEventDef + IMachineCoordinateStateDef) Dwell — pause (Time in seconds) SpindleControl — spindle direction change (Direction) SpindleOrientation — oriented spindle stop (OSS) (Angle_deg) ICoolantDef Coolant state (M07 mist / M08 flood / M09 off). Written by CoolantSyntax. Modal — persists until changed. IsOn is the on/off convenience flag (true for M07 and M08, false for M09). Mode carries the abstract kind (Flood / Mist / Off) for consumers that need to distinguish flood vs mist. IDwellDef Dwell/pause section definition for use inside Sequence items. Resolved by Hi.NcParsers.Semantics.CompoundMotionSemanticUtil into ActDelay. IFanucHpccDef Block-root section recording a consumed bare Fanuc G05 P{n} (HPCC family selection), written by FanucPathSmoothingSyntax. P is a function-selection code — not a quantity, dwell time, or look-ahead block count. P10000 enters high-precision contour control (HPCC: RISC-board multi-block look-ahead, pre-interpolation acceleration/deceleration, curvature-based feed clamping); P0 cancels it. P10001–P10999 call high-speed cycle machining: the control executes cycle data pre-registered in its variable area — real axis motion, so an offline run that ignores the call misses that machining (FanucPathSmoothingSyntax emits a Warning for it). Small P values select the high-speed remote buffer modes (binary DNC transfer; exact semantics vary by model). HPCC itself never alters the programmed coordinates, so P10000/P0 are recognized, intentionally not simulated, safe offline (the SiemensStopreSyntax pattern). Deliberately separate from the modal PathSmoothing section (G05.1, IFanucPathSmoothingDef): this section is block-local like Stopre and is NOT tracked by ModalCarrySyntax — it exists for diagnostics and bidirectional NC-text reconstruction only. IFanucPathSmoothingDef Fanuc-specific path smoothing state written by FanucPathSmoothingSyntax. Extends IPathSmoothingDef with the Fanuc G05.1 R argument (precision / smoothness level number, R1..R10 mapping to controller-internal tuning macro variables). Q is binary in current Fanuc firmware (Q0 disable / Q1 enable), so IsEnabled covers it directly — no raw Q field is stored. JSON section key remains nameof(PathSmoothing) so generic readers (cache dumps, modal carry, UI) can cast to IPathSmoothingDef across all controller brands; brand-specific readers cast to IFanucPathSmoothingDef for the extra fields. IFeedrateDef Feedrate state written by FeedrateSyntax. Property names are used as JSON keys via nameof. ISO standard: F command + G94 (per minute) / G95 (per revolution). Supported by all major CNC brands. IFlagsDef JSON section schema describing the modal/non-modal flags that take effect on an NC block. Each entry in Flags is a brand-specific keyword recognized by the soft-NC runtime. IMachineCoordinateStateDef Modal machine-coordinate state — absolute six-axis machine position after the block has executed. Written on every block by motion-related LogicSyntaxs (McAbcSyntax, McAbcXyzFallbackSyntax, McXyzSyntax, MachineCoordSelectSyntax, G53p1RotaryPositionSyntax, ReferenceReturnSyntax); seeded on the init block by HomeMcInitializer; carried across non-motion blocks — and per-key completed on partially-written blocks (an XYZ-only motion block receives the carried modal rotary values) — by ModalCarrySyntax. Only configured axes appear as keys (X/Y/Z/A/B/C). Non-existent axes (e.g., A/B/C on a 3-axis machine) are omitted rather than written as NaN sentinels. After the PostLogic carry the section is a MODAL record: key presence means \"state known\", never \"this block commanded the axis\". Consumers needing \"commanded\" must read the block's Parsing words or compare values against the previous block (see LinearMotionUtil.HasRotaryMotion). The only presence-as-commanded carve-out is CompoundMotion.Items[*] item-level sections, which the carry never touches. IMotionEventDef One-shot motion event — present on every block whose source programmed a motion command, regardless of whether the resulting displacement is non-zero. A redundant G01 X10 on a block already at X10 still gets a MotionEvent; the motion semantics (McLinearMotionSemantic, McArcMotionSemantic, ClLinearMcMotionSemantic) then early-return on distance <= 0 and emit no IAct. NOT carried forward across blocks. Reason for the \"programmed, not displaced\" definition: Fanuc G66 modal macro fires once per programmed motion command (per Fanuc spec — no distance gate), so FanucModalMacroSyntax.Expansion uses MotionEvent presence as its trigger. Suppressing the section on zero-distance moves would silently change G66 behaviour. The modal sibling MotionState separately latches the Group-01 mode for readers that only need to know \"what G-code is active\". Property names are used as JSON keys via nameof. IMotionStateDef Modal motion state — Group 01 G-code mode (G00 / G01 / G02 / G03 ...). Written on every block by LinearMotionSyntax / CircularMotionSyntax; carried across non-motion blocks by ModalCarrySyntax. Property names are used as JSON keys via nameof. Unlike sibling modal sections (Unit, PlaneSelect, Positioning) which carry both a brand-specific Term and a brand-neutral conventional field, MotionState intentionally keeps only Term: the brand-neutral semantic (\"what kind of motion happened\") lives on the sibling one-shot MotionEvent (Form = McLinear / McArc / ClLinear / ClArc). State here is purely the modal latch of the last Group-01 G-code so downstream FindPrevious* can resume motion-mode bookkeeping. IParsingDef JSON section schema carrying the raw, brand-specific parsing trace for an NC block. The Parsing node holds intermediate parser output used by downstream syntaxes and diagnostics. IPathSmoothingDef Path smoothing state. The base interface is brand-agnostic; controller brands extend it with their own argument fields (e.g. IFanucPathSmoothingDef for Fanuc G05.1 R precision-level). Fanuc-flavour writes are produced by FanucPathSmoothingSyntax. ISO/Fanuc G05.1 Q1 (enable) / G05.1 Q0 (disable): high-precision contour control / AICC / Nano Smoothing. Controller-internal interpolation black box — simulation records the state but does not alter the tool path. IPlaneSelectDef Active plane selection state written by PlaneSelectSyntax. Property names are used as JSON keys via nameof. ISO: G17/G18/G19. Heidenhain: implicit from L/CC syntax. Term carries the brand-specific G-code; Plane stores the conventional, brand-neutral axis-pair name (XY/ZX/YZ). IPolarInterpolationDef JSON section schemas for Fanuc Polar Coordinate Interpolation (G12.1/G13.1). Property names are used as JSON keys via nameof. PolarInterpolationState is the modal valve: its presence on a block means polar interpolation is active there. It is written by PolarInterpolationSyntax on the G12.1 block and re-materialized onto every following block until a G13.1 block ends the mode (single-step lookback carry, same pattern as PositioningSyntax — not registered on ModalCarrySyntax). ProgramPolarRxcz is the per-block polar position, relative to the G12.1 anchor (InitRxcz). Rxcz axes: X = radius-direction linear axis in mm (the NC word X is a diameter and is halved on parse), Y = hypothetical rotary-substitute axis in mm, Z = real Z in mm. The absolute (rotation-center-origin) position used by the math is InitRxcz + ProgramPolarRxcz, mirroring HardNc PolarEntry.CentralProgramPolarRxcz. IPositioningDef Modal positioning state — ISO Group 03 (G90 absolute / G91 incremental). Written by PositioningSyntax, consumed by IncrementalResolveSyntax, canned cycle syntaxes, and MachineCoordSelectSyntax. Property names are used as JSON keys via nameof. Term is the brand-specific G-code (Fanuc/ISO G90/G91); Mode is the conventional, brand-neutral name (Absolute / Incremental). IProgramEndDef Program end marker (M02/M30). Written by ProgramEndSyntax. Other syntaxes (e.g. IsoLocalCoordinateOffsetSyntax) read this section to reset modal state instead of detecting M30 directly. IProgramStopDef Program-stop marker (M00 unconditional / M01 optional). Written by ProgramStopSyntax on each block that carries an M00/M01 flag. Non-modal: the section appears only on the exact block where the stop code is present. Distinct from IProgramEndDef (M02/M30, end of program). M00 halts execution unconditionally; the operator must press Cycle Start to resume. M01 is an optional stop gated by the operator's \"Optional Stop\" panel switch — ignored when the switch is off. This parsing-layer section records the NC intent; runtime / semantic layers decide whether to actually pause. IProgramXyzDef JSON section schema carrying the program-coordinate position commanded on the current block. Written by ProgramXyzSyntax before the ProgramToMcTransform chain composes it into machine coordinates. IRadiusCompensationDef Radius compensation state written by RadiusCompensationSyntax. Property names are used as JSON keys via nameof. Managed commands (ISO): G41 (left), G42 (right), G40 (cancel). Heidenhain Klartext maps RL → G41, RR → G42, R0 → G40. When active, the tool path is offset perpendicular to the programmed path by Radius_mm; Side determines left vs right. The root ProgramXyz retains the user-programmed position; MachineCoordinate is overwritten to reflect the compensated path. ISpindleControlDef Spindle control item for use inside ItemsKey arrays. Resolved by Hi.NcParsers.Semantics.CompoundMotionSemanticUtil into ActSpindleDirection. ISpindleOrientationDef Oriented spindle stop item for use inside ItemsKey arrays. Commands the spindle to stop at a specific angular position (OSS). Resolved by Hi.NcParsers.Semantics.CompoundMotionSemanticUtil into ActSpindleOrientation. ISpindleSpeedDef Spindle speed and direction state written by SpindleSpeedSyntax. Property names are used as JSON keys via nameof. ISO: S command for speed, M03/M04/M05 for direction. Heidenhain: M3/M4/M5. Siemens: M3/M4/M5 or SPOS. Direction is stored as the conventional SpindleDirection enum name (CW/CCW/STOP), not as brand-specific M-codes. ITiltTransformDef Tilt transform state written by tilt transform syntaxes. Property names are used as JSON keys via nameof. Managed commands (ISO/Fanuc): G68 (2D rotation), G68.2 (tilted work plane), G69 (cancel). Siemens equivalent: CYCLE800, ROT/AROT (handled by separate syntax). Heidenhain equivalent: PLANE SPATIAL / PLANE RESET (handled by separate syntax). IToolHeightCompensationDef Tool height compensation state written by ToolHeightOffsetSyntax. Property names are used as JSON keys via nameof. The JSON section can be deserialized to an instance implementing this interface. Managed commands (ISO/Fanuc): G43, G44, G49. Fanuc extension: G43.4 (TCPM — parsed only in Fanuc syntax list). Siemens equivalent: TRAFOOF/TRAORI (handled by separate syntax). Heidenhain equivalent: TOOL CALL / M128/M129 (handled by separate syntax). ITransformationDef Chain of named ProgramXyz → MachineCoordinate transformation entries. Stored as a JsonArray of entries, each with “Source”, “Kind”, and “Mat4d” keys. Each contributing INcSyntax adds or replaces its own entry by source name. GetComposedTransform(JsonObject) composes entries in order: McXyz = ProgramXyz * T[0] * T[1] * ... * T[n]. Kind contour-validity classification. Each entry is either: \"Static\" — the Mat4d is valid for any point along the contour. Tilt, coord-offset, and the kinematic pivot in non-RTCP / rotary-stable blocks are all Static. \"Dynamic\" — the Mat4d is a block-endpoint snapshot of a rotary-state-dependent transform (RTCP rotary-dynamic). Composition still yields a correct endpoint MC, but the matrix is not contour-valid: intermediate CL-point positions cannot be derived by applying it to an interpolated ProgramXyz. The semantic layer (ClLinearMcMotionSemantic) handles per-step IK separately. Use HasDynamicEntry(JsonObject) to detect the presence of any Dynamic entry on this block. IUnitDef Unit-system state (ISO Group 06: G20 inch / G21 metric). Written by UnitModeSyntax. Modal. HiNC's NC pipeline works exclusively in millimetres. G21 is therefore a no-op confirmation of the default; G20 is reported as an Unsupported Error and callers are expected to pre-convert the NC program to metric before loading. IUnparsedTextDef JSON section schema carrying the residual block text that was not consumed by any registered syntax. Used for diagnostics and round-trip preservation."
  },
  "api/Hi.NcParsers.LogicSyntaxs.BackBoringSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.BackBoringSyntax.html",
    "title": "Class BackBoringSyntax | HiAPI-C# 2025",
    "summary": "Class BackBoringSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll G87 back boring cycle. Supports modal repetition. Cuts upward from Z to R — used to bore the back side of a workpiece. Cycle sequence: Oriented spindle stop (OSS) at current position Rapid (shifted) to init position, then down to bottom Z — tool enters pre-drilled hole without contacting bore wall Shift back to hole center at bottom Spindle start (CW) Feed upward from Z to R-point (back boring cut) Oriented spindle stop at R Tool shift, rapid retract (shifted) to final Z Shift back to center, spindle restart Q specifies the lateral shift distance (mm). Shift direction defaults to +X (OSS angle 0°). Reads absolute coordinates from the cycle section, which is resolved by CannedCycleResolveSyntax before this syntax runs. public class BackBoringSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object BackBoringSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples G87 G98 — pre-populated CannedCycle, no #Previous: so initZ = 0, F=600 → 10 mm/s, shift Q=1. Eleven items — the longest canned-cycle item list — split into three phases: enter shifted (OSS, shifted-init, shifted-bottom, back-to- center, spindle-CW); cut upward (feed bottom → R); retract shifted (OSS again, shifted-at-R, shifted-final, back-to-center, spindle- restart). Note that the feed step goes UP (Z=-10 → Z=2), not down, which is the defining feature of back boring: #BeforeBuild: { \"Parsing\": { \"G87\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2, \"Q\": 1, \"F\": 600 } }, \"CannedCycle\": { \"Term\": \"G87\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2, \"Q\": 1 } } } #AfterBuild: { \"CannedCycle\": { \"Term\": \"G87\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2, \"Q\": 1 } }, \"Feedrate\": { \"FeedrateValue\": 600, \"Term\": \"G94\", \"Unit\": \"mm/min\" }, \"CompoundMotion\": { \"Term\": \"G87\", \"Items\": [ { \"SpindleOrientation\": { \"Angle_deg\": 0 } }, { \"ProgramXyz\": { \"X\": 51, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 51, \"Y\": 30, \"Z\": -10 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": -10 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"SpindleControl\": { \"Direction\": \"CW\" } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 2 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"Feedrate_mmds\": 10 } }, { \"SpindleOrientation\": { \"Angle_deg\": 0 } }, { \"ProgramXyz\": { \"X\": 51, \"Y\": 30, \"Z\": 2 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 51, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"SpindleControl\": { \"Direction\": \"CW\" } } ] }, \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 } } Constructors BackBoringSyntax() Initializes a new instance with default settings. public BackBoringSyntax() BackBoringSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public BackBoringSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.BareG28Behavior.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.BareG28Behavior.html",
    "title": "Enum BareG28Behavior | HiAPI-C# 2025",
    "summary": "Enum BareG28Behavior Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Configurable handling for a G28 block with no axis specifiers (“bare G28”) — value of BareG28. Real Fanuc-class controllers vary: older 0i-M alarms (PS010), some 30i variants send every configured axis to home. Default to Alarm so silent NC bugs surface; opt into AllAxesHome per syntax instance. public enum BareG28Behavior Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Alarm = 0 Emit Coord-RefReturn–003 validation error and consume the bare G28 without emitting motion. AllAxesHome = 1 Interpret bare G28 as if every configured axis were listed at its current modal value, so item 0 (intermediate) is a no-op and item 1 sends each configured axis to its home. Requires an IMachineAxisConfig dep; without one the syntax falls back to Alarm."
  },
  "api/Hi.NcParsers.LogicSyntaxs.BoringCycleSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.BoringCycleSyntax.html",
    "title": "Class BoringCycleSyntax | HiAPI-C# 2025",
    "summary": "Class BoringCycleSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll G85/G86/G89 boring cycles. Cycle sequence: Rapid to init position (target XY, previous Z) Rapid from init to R-point Feed from R-point to bottom Z [G86 only] Spindle stop at bottom [G89 only] Dwell P seconds at bottom Retract: G85/G89 → feed retract, G86 → rapid retract [G86 only] Spindle restart (CW) after retract G85: feed to Z, feed retract — smooth bore finish. G86: feed to Z, spindle stop (implicit), rapid retract. G89: feed to Z, dwell P, feed retract — like G85 with bottom dwell. Reads absolute coordinates from the cycle section, which is resolved by CannedCycleResolveSyntax (modal repetition, G91 conversion, missing-axis fallback) before this syntax runs. Must be placed after CannedCycleResolveSyntax and before IncrementalResolveSyntax in the syntax chain. public class BoringCycleSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object BoringCycleSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples All cases below pre-populate CannedCycle as CannedCycleResolveSyntax would have written it. There is no #Previous:, so GetLastProgramXyz returns Vec3d.Zero → initZ = 0. F is supplied inside the cycle section so ResolveFeedrate(JsonObject, JsonObject, ISentenceCarrier, NcDiagnosticProgress) writes block-level Feedrate (G94 default, 600 mm/min → 10 mm/s) before items are emitted. All cases use G98 return mode so finalZ = initZ = 0. G85 — feed to bottom, feed retract (smooth bore finish). The retract item carries the same Feedrate_mmds as the down-stroke. Four items: #BeforeBuild: { \"Parsing\": { \"G85\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2, \"F\": 600 } }, \"CannedCycle\": { \"Term\": \"G85\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2 } } } #AfterBuild: { \"CannedCycle\": { \"Term\": \"G85\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2 } }, \"Feedrate\": { \"FeedrateValue\": 600, \"Term\": \"G94\", \"Unit\": \"mm/min\" }, \"CompoundMotion\": { \"Term\": \"G85\", \"Items\": [ { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 2 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": -10 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"Feedrate_mmds\": 10 } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"Feedrate_mmds\": 10 } } ] }, \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 } } G86 — feed to bottom, spindle stop, rapid retract, spindle restart CW. First marker to spell out { \"SpindleControl\": { \"Direction\": ... } } items. The retract item carries IsRapid: true rather than a feedrate. Six items: #BeforeBuild: { \"Parsing\": { \"G86\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2, \"F\": 600 } }, \"CannedCycle\": { \"Term\": \"G86\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2 } } } #AfterBuild: { \"CannedCycle\": { \"Term\": \"G86\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2 } }, \"Feedrate\": { \"FeedrateValue\": 600, \"Term\": \"G94\", \"Unit\": \"mm/min\" }, \"CompoundMotion\": { \"Term\": \"G86\", \"Items\": [ { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 2 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": -10 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"Feedrate_mmds\": 10 } }, { \"SpindleControl\": { \"Direction\": \"STOP\" } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"SpindleControl\": { \"Direction\": \"CW\" } } ] }, \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 } } G89 with P=0.3s dwell — like G85 but inserts a { Dwell: { Time: 0.3 } } item at the bottom before the feed retract. Five items: #BeforeBuild: { \"Parsing\": { \"G89\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2, \"F\": 600, \"P\": 0.3 } }, \"CannedCycle\": { \"Term\": \"G89\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2 } } } #AfterBuild: { \"CannedCycle\": { \"Term\": \"G89\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2 } }, \"Feedrate\": { \"FeedrateValue\": 600, \"Term\": \"G94\", \"Unit\": \"mm/min\" }, \"CompoundMotion\": { \"Term\": \"G89\", \"Items\": [ { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 2 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": -10 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"Feedrate_mmds\": 10 } }, { \"Dwell\": { \"Time\": 0.3 } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"Feedrate_mmds\": 10 } } ] }, \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 } } Remarks G86 emits SpindleControl items for spindle stop (before retract) and spindle restart CW (after retract). The restart assumes the previous direction was CW (M03), which is the typical boring setup. Constructors BoringCycleSyntax() Initializes a new instance with default settings. public BoringCycleSyntax() BoringCycleSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public BoringCycleSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.CannedCycleResolveSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.CannedCycleResolveSyntax.html",
    "title": "Class CannedCycleResolveSyntax | HiAPI-C# 2025",
    "summary": "Class CannedCycleResolveSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Resolves the canned-cycle Group-09 state for the current block and writes the result to the CannedCycle section. Active cycle (direct G81..G89 or modal repeat): merges Parsing overrides with previous-cycle stored params, applies G91 incremental-to-absolute conversion and missing-axis fallback, writes CannedCycle with Term, ReturnMode, and Params. The resolved cycle sub-section is left in Parsing under the cycle code for downstream cycle syntaxes (DrillingCycleSyntax, etc.) to read. Explicit cancel (G80 flag present on a non-cycle block): consumes the G80 flag and writes CannedCycle = { Term: \"G80\" }, acting as a hard sentinel for Hi.NcParsers.LogicSyntaxs.CannedCycleSyntaxUtil modal lookback. No Group-09 activity: leaves the block untouched. Must be placed after PositioningSyntax and before the individual cycle syntaxes in the chain. public class CannedCycleResolveSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object CannedCycleResolveSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Direct G81 active cycle, no #Previous: (so lastProgramXyz = Vec3d.Zero) and no Positioning mode (so the absolute-coordinate path runs, not G91 incremental). The resolved cycle sub-section is left in Parsing under the cycle code for downstream cycle syntaxes to consume; the CannedCycle section carries the snapshot used for modal lookback. ReturnMode defaults to G98 when neither the current block nor a previous block declares G98/G99: #BeforeBuild: { \"Parsing\": { \"G81\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2 } } } #AfterBuild: { \"Parsing\": { \"G81\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2 } }, \"CannedCycle\": { \"Term\": \"G81\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2 } } } Modal repeat: the current block carries only an X override and no cycle code, but #Previous: has an active G81 with stored params. MergeModalCycleSection(JsonObject, JsonObject, ISentenceCarrier, NcDiagnosticProgress) merges X=60 (override) with Y/Z/R from stored params, removes the consumed X from Parsing root, and writes the merged section back to Parsing.G81. ReturnMode inherits “G98” from the previous block's ReturnMode: #Previous: { \"CannedCycle\": { \"Term\": \"G81\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2 } }, \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 } } #BeforeBuild: { \"Parsing\": { \"X\": 60 } } #AfterBuild: { \"Parsing\": { \"G81\": { \"X\": 60, \"Y\": 30, \"Z\": -10, \"R\": 2 } }, \"CannedCycle\": { \"Term\": \"G81\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 60, \"Y\": 30, \"Z\": -10, \"R\": 2 } } } Explicit G80 cancel: standalone G80 flag with no cycle data. The G80 flag is consumed and CannedCycle = { Term: G80 } is written as a hard sentinel that FindPreviousActiveCycle(LazyLinkedListNode<SyntaxPiece>, string[]) reads to terminate modal lookback. No ReturnMode hint here (no G98/G99 flag on the same block): #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G80\"] } } #AfterBuild: { \"CannedCycle\": { \"Term\": \"G80\" } } The first block after a program end — #Previous: carries the ProgramEnd section next to a still-active G81, and the block itself has an X word that would have repeated the cycle. This is the reset edge (ProgramEndSyntax): the controller's reset cancels the canned cycle, so no repeat is resolved (the X word stays for the positioning syntaxes) and the G80 sentinel is written explicitly — an authored section, so the modal carry does not clone the active cycle across the edge. No ReturnMode: the G98 default applies after reset: #Previous: { \"ProgramEnd\": { \"Term\": \"M30\" }, \"CannedCycle\": { \"Term\": \"G81\", \"ReturnMode\": \"G99\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2 } } } #BeforeBuild: { \"Parsing\": { \"X\": 60 } } #AfterBuild: { \"Parsing\": { \"X\": 60 }, \"CannedCycle\": { \"Term\": \"G80\" } } Properties Default Default instance with standard settings. public static CannedCycleResolveSyntax Default { get; } Property Value CannedCycleResolveSyntax Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.CircularMotionSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.CircularMotionSyntax.html",
    "title": "Class CircularMotionSyntax | HiAPI-C# 2025",
    "summary": "Class CircularMotionSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Writes McArc motion for circular commands (ISO G02/G03). Detects motion mode from Flags, reads I/J/K center offsets or R radius from Parsing, computes arc center in program coordinates, and writes a one-shot MotionEvent (form + arc params) plus a modal MotionState (Term). G02/G03 mode is modal (Group 01) — persists across blocks via Term. Arc parameters (I/J/K/R) are per-block and must be present in every arc block. Must be placed before LinearMotionSyntax in the syntax chain. Both share the Group 01 motion slot; whichever writes a MotionEvent first claims it. IsIjkAbsolute switches the I/J/K reading to absolute center coordinates (Heidenhain DIN/ISO — the ISO twin of the Klartext CC pole; the Heidenhain list sets it, every other brand keeps the offset default). In that mode the center is modal: letters not written in a block inherit the previous absolute pole (AbsoluteIjkPoleKey, carried by the brand's ModalCarrySyntax), a letter never written falls back to the arc start's component, a letters-free block that commands an endpoint continues the modal arc off the pole (a flags-only block stays motionless), a G91 block reads offsets again and breaks the pole chain, and the plane-normal letter is a center coordinate — never the per-turn helix pitch. Behavior mirrors HardNcLine.BuildArcNcArg + ArcNcArg.GetCenterOrCenterOnBeginPlane (HiUniNc 3.1.152.2) bit for bit. public class CircularMotionSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object CircularMotionSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples All cases below have the current block's ProgramXyz already set (as a prior ProgramXyzSyntax would have produced) and run with no #Previous:, so GetLastProgramXyz returns Vec3d.Zero. The G17 XY plane is implicit (no PlaneSelect section means GetPlaneNormalDir(JsonObject) returns 2 — the XY-plane default — so arc math runs with Z as the perpendicular axis). G02 with I/J — quarter arc from (0,0,0) to (10,0,0) around (5,0,0); I=5 J=0 are incremental offsets from start to center. The G02 flag is consumed (Parsing removed once empty); MotionState + MotionEvent are written: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G02\"], \"I\": 5, \"J\": 0 }, \"ProgramXyz\": { \"X\": 10, \"Y\": 0, \"Z\": 0 } } #AfterBuild: { \"ProgramXyz\": { \"X\": 10, \"Y\": 0, \"Z\": 0 }, \"MotionState\": { \"Term\": \"G02\" }, \"MotionEvent\": { \"Form\": \"McArc\", \"ArcCenter\": { \"X\": 5, \"Y\": 0, \"Z\": 0 }, \"IsCcw\": false, \"AdditionalCircleNum\": 0 } } Modal carry of G02: no motion flag on the current block but a #Previous: MotionState.Term = \"G02\" tells us we are still in circular mode. I/J on the current block describe the arc the same way: #Previous: { \"MotionState\": { \"Term\": \"G02\" } } #BeforeBuild: { \"Parsing\": { \"I\": 5, \"J\": 0 }, \"ProgramXyz\": { \"X\": 10, \"Y\": 0, \"Z\": 0 } } #AfterBuild: { \"ProgramXyz\": { \"X\": 10, \"Y\": 0, \"Z\": 0 }, \"MotionState\": { \"Term\": \"G02\" }, \"MotionEvent\": { \"Form\": \"McArc\", \"ArcCenter\": { \"X\": 5, \"Y\": 0, \"Z\": 0 }, \"IsCcw\": false, \"AdditionalCircleNum\": 0 } } No I/J/K/R on the block — the per-block arc data is missing, so the syntax bails out early; the G02 flag stays in Parsing.Flags for some other syntax to act on (or to surface as residue if no one does): #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G02\"] }, \"ProgramXyz\": { \"X\": 10, \"Y\": 0, \"Z\": 0 } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"G02\"] }, \"ProgramXyz\": { \"X\": 10, \"Y\": 0, \"Z\": 0 } } R-format degenerate (chord = 2R, semicircle): start (0,0,0) → end (10,0,0), R=5. perpDistSq resolves to 0 so the computed center collapses to the chord midpoint (5,0,0); no sqrt drift on this branch: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G02\"], \"R\": 5 }, \"ProgramXyz\": { \"X\": 10, \"Y\": 0, \"Z\": 0 } } #AfterBuild: { \"ProgramXyz\": { \"X\": 10, \"Y\": 0, \"Z\": 0 }, \"MotionState\": { \"Term\": \"G02\" }, \"MotionEvent\": { \"Form\": \"McArc\", \"ArcCenter\": { \"X\": 5, \"Y\": 0, \"Z\": 0 }, \"IsCcw\": false, \"AdditionalCircleNum\": 0 } } R-format non-trivial: G02 90° arc from (0,0,0) to (10,10,0) with R=10. The center comes from the cross-product + sqrt + normalize path inside ResolveCenterFromSignedRadius(Vec3d, Vec3d, int, bool, double), but for this particular axis-aligned chord the rounding errors cancel and the center lands at exactly (10, 0, 0) — i.e. no ULP drift here, in contrast to e.g. McAbcCyclicPathSyntax's rad/deg round-trip: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G02\"], \"R\": 10 }, \"ProgramXyz\": { \"X\": 10, \"Y\": 10, \"Z\": 0 } } #AfterBuild: { \"ProgramXyz\": { \"X\": 10, \"Y\": 10, \"Z\": 0 }, \"MotionState\": { \"Term\": \"G02\" }, \"MotionEvent\": { \"Form\": \"McArc\", \"ArcCenter\": { \"X\": 10, \"Y\": 0, \"Z\": 0 }, \"IsCcw\": false, \"AdditionalCircleNum\": 0 } } G03 CCW with I/J — same geometry as case 0 (start (0,0,0), end (10,0,0), I=5 J=0 → center (5,0,0)) but the G03 flag flips IsCcw to true. Direction is the only differentiating output; arc-center math is unchanged: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G03\"], \"I\": 5, \"J\": 0 }, \"ProgramXyz\": { \"X\": 10, \"Y\": 0, \"Z\": 0 } } #AfterBuild: { \"ProgramXyz\": { \"X\": 10, \"Y\": 0, \"Z\": 0 }, \"MotionState\": { \"Term\": \"G03\" }, \"MotionEvent\": { \"Form\": \"McArc\", \"ArcCenter\": { \"X\": 5, \"Y\": 0, \"Z\": 0 }, \"IsCcw\": true, \"AdditionalCircleNum\": 0 } } Full circle G02 — start == end (both (0,0,0)), I=5 J=0 places center off-start at (5,0,0). Plane-restricted closure (IsClosedOnPlane(Vec3d, Vec3d, int, double)) flips AdditionalCircleNum to 1 so a downstream motion semantic knows to draw the closed loop: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G02\"], \"I\": 5, \"J\": 0 }, \"ProgramXyz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } } #AfterBuild: { \"ProgramXyz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 }, \"MotionState\": { \"Term\": \"G02\" }, \"MotionEvent\": { \"Form\": \"McArc\", \"ArcCenter\": { \"X\": 5, \"Y\": 0, \"Z\": 0 }, \"IsCcw\": false, \"AdditionalCircleNum\": 1 } } Fanuc L parameter (helix turn count, 1-based) — L3 on a start==end closed loop means three total turns, so AdditionalCircleNum = L − 1 = 2. Matches the legacy HardNc reading; the L parameter is consumed alongside I/J/K/R: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G02\"], \"I\": 5, \"J\": 0, \"L\": 3 }, \"ProgramXyz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } } #AfterBuild: { \"ProgramXyz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 }, \"MotionState\": { \"Term\": \"G02\" }, \"MotionEvent\": { \"Form\": \"McArc\", \"ArcCenter\": { \"X\": 5, \"Y\": 0, \"Z\": 0 }, \"IsCcw\": false, \"AdditionalCircleNum\": 2 } } K-as-pitch helix on G17 (XY plane) — when the plane-normal axis letter (K for G17, J for G18, I for G19) is present on an IJK-format arc, it is the per-turn axial pitch, not a center offset. Here K = −3 mm/turn over ΔZ = −9 mm gives AdditionalCircleNum = floor(−9 / −3) = 3. The center stays on the begin-plane (Z = 0) — ResolveCenterFromIjk zeros the plane-normal component before adding to begin. Matches the legacy HardNc reading: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G02\"], \"I\": 5, \"J\": 0, \"K\": -3 }, \"ProgramXyz\": { \"X\": 0, \"Y\": 0, \"Z\": -9 } } #AfterBuild: { \"ProgramXyz\": { \"X\": 0, \"Y\": 0, \"Z\": -9 }, \"MotionState\": { \"Term\": \"G02\" }, \"MotionEvent\": { \"Form\": \"McArc\", \"ArcCenter\": { \"X\": 5, \"Y\": 0, \"Z\": 0 }, \"IsCcw\": false, \"AdditionalCircleNum\": 3 } } Absolute I/J (IsIjkAbsolute = true on the SUT — the Heidenhain DIN/ISO reading; values taken from a real production program): I/J ARE the center's program coordinates, the center is locked onto the begin plane (Z from the previous block), the post-inheritance letters are recorded as the modal AbsoluteIjkPole section and the event is stamped IsIjkAbsolute for the NcOpt splition write-back (the arc start comes from the predecessor's MachineCoordinateState — the modal anchor GetLastProgramXyz reads; no transform chain here, so it equals the program position): #Previous: { \"MachineCoordinateState\": { \"X\": -23.958, \"Y\": -0.0965, \"Z\": 3.4338 } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G02\"], \"I\": -23.3261, \"J\": -1.2062 }, \"ProgramXyz\": { \"X\": -23.3253, \"Y\": 0.0708, \"Z\": 3.4338 } } #AfterBuild: { \"ProgramXyz\": { \"X\": -23.3253, \"Y\": 0.0708, \"Z\": 3.4338 }, \"AbsoluteIjkPole\": { \"I\": -23.3261, \"J\": -1.2062 }, \"MotionState\": { \"Term\": \"G02\" }, \"MotionEvent\": { \"Form\": \"McArc\", \"ArcCenter\": { \"X\": -23.3261, \"Y\": -1.2062, \"Z\": 3.4338 }, \"IsCcw\": false, \"AdditionalCircleNum\": 0, \"IsIjkAbsolute\": true } } Absolute modal pole (the CC-pole twin): a continuation block writes only J — the I component inherits the previous block's AbsoluteIjkPole, the G03 mode continues via #Previous: MotionState.Term, and the refreshed pole is written back: #Previous: { \"MachineCoordinateState\": { \"X\": -25.2297, \"Y\": 0.0704, \"Z\": 0 }, \"AbsoluteIjkPole\": { \"I\": -25.2029, \"J\": -0.9154 }, \"MotionState\": { \"Term\": \"G03\" } } #BeforeBuild: { \"Parsing\": { \"J\": -0.9154 }, \"ProgramXyz\": { \"X\": -24.9288, \"Y\": 0.5929, \"Z\": 0 } } #AfterBuild: { \"ProgramXyz\": { \"X\": -24.9288, \"Y\": 0.5929, \"Z\": 0 }, \"AbsoluteIjkPole\": { \"I\": -25.2029, \"J\": -0.9154 }, \"MotionState\": { \"Term\": \"G03\" }, \"MotionEvent\": { \"Form\": \"McArc\", \"ArcCenter\": { \"X\": -25.2029, \"Y\": -0.9154, \"Z\": 0 }, \"IsCcw\": true, \"AdditionalCircleNum\": 0, \"IsIjkAbsolute\": true } } G91 on an IsIjkAbsolute SUT switches the block back to the ordinary start-to-center offsets (center = begin + (I, J)), ignores the inherited pole and BREAKS the pole chain — the emptied section blocks the ModalCarry copy, so a later absolute block falls back to the arc start (the preArcNcArg.IsIjkAbsolute check of HardNcLine.BuildArcNcArg): #Previous: { \"MachineCoordinateState\": { \"X\": 10, \"Y\": 0, \"Z\": 0 }, \"AbsoluteIjkPole\": { \"I\": -25.2029, \"J\": -0.9154 } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G02\"], \"I\": 10, \"J\": 0 }, \"Positioning\": { \"Term\": \"G91\", \"Mode\": \"Incremental\" }, \"ProgramXyz\": { \"X\": 20, \"Y\": 10, \"Z\": 0 } } #AfterBuild: { \"Positioning\": { \"Term\": \"G91\", \"Mode\": \"Incremental\" }, \"ProgramXyz\": { \"X\": 20, \"Y\": 10, \"Z\": 0 }, \"AbsoluteIjkPole\": {}, \"MotionState\": { \"Term\": \"G02\" }, \"MotionEvent\": { \"Form\": \"McArc\", \"ArcCenter\": { \"X\": 20, \"Y\": 0, \"Z\": 0 }, \"IsCcw\": false, \"AdditionalCircleNum\": 0 } } Constructors CircularMotionSyntax() Initializes a new instance with default settings. public CircularMotionSyntax() CircularMotionSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public CircularMotionSyntax(XElement src) Parameters src XElement Source XML element. Fields AbsoluteIjkPoleKey Root-section key of the modal absolute-center pole (the letters of the last absolute arc, post-inheritance — the SoftNc dual of HardNcLine.ArcNcArg.Ijk). Written by every effective-absolute arc block, emptied by a G91 arc block to break the chain, and carried across intermediate blocks by the brand list's ModalCarrySyntax Logic track. Kept apart from HeidenhainCircleCenterSyntax's Klartext CC section — the two dialect poles never share a key. public const string AbsoluteIjkPoleKey = \"AbsoluteIjkPole\" Field Value string Properties IsIjkAbsolute When true, I/J/K address the circle center as absolute program coordinates instead of start-to-center offsets, with the modal-pole / G91 semantics described on the class doc. Set by the Heidenhain list (DIN/ISO dialect); every other brand keeps the offset default. public bool IsIjkAbsolute { get; set; } Property Value bool Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.CodedPositionUtil.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.CodedPositionUtil.html",
    "title": "Class CodedPositionUtil | HiAPI-C# 2025",
    "summary": "Class CodedPositionUtil Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Shared coded-position resolution for the write-stage consumers (McAbcSyntax for rotary words, IncrementalResolveSyntax for linear words): turns a per-word PositioningOverride entry of the coded family (CodedAbsolute / CodedIncremental / CodedShortest / CodedPositiveOnly / CodedNegativeOnly — stamped by SiemensAcIcSyntax for CAC()/CIC()/CDC()/CACP()/CACN()) plus the evaluated position number into an axis coordinate via IIndexingPositionConfig, and names the plain override value the caller rewrites the entry to — so the McAbcCyclicPathSyntax tail-pass and every other downstream reader only ever see the established non-coded vocabulary. Failure semantics mirror the Siemens alarms as far as a simulator can: an invalid position number (alarm 17510) or a missing table reports an error diagnostic and resolves to \"hold\" — the caller writes the anchor so the axis does not move. CIC(0) also resolves to hold, by specification (\"the indexing axis is not traversed\") and silently. A CIC from between two indexing positions advances to the n-th next position in the programmed direction. On a cyclic indexing axis the incremental sign becomes a directional (PositiveOnly / NegativeOnly) approach; increments spanning more than one revolution reach the correct position but collapse the extra full turns (the tail-pass windows cover one revolution). public static class CodedPositionUtil Inheritance object CodedPositionUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields ConfigMissingDiagId Diagnostic id for a coded-position word whose axis no longer resolves an indexing table at the write stage (the unwrap stage only stamps coded overrides for configured indexing axes, so this indicates the dependency list changed between stages). The axis holds its position. public const string ConfigMissingDiagId = \"CodedPosition--ConfigMissing\" Field Value string NumberInvalidDiagId Diagnostic id for a coded position number the indexing table cannot resolve: not an integer, outside the table, or (via CIC) advanced past the end of a non-cyclic table. The Siemens control raises alarm 17510 and stops; the simulation reports this error and holds the axis. public const string NumberInvalidDiagId = \"CodedPosition--NumberInvalid\" Field Value string Methods IsCodedOverride(string) True when overrideValue is one of the five coded-position PositioningOverride values. public static bool IsCodedOverride(string overrideValue) Parameters overrideValue string Returns bool TryResolveCodedTarget(IIndexingPositionConfig, string, string, double, double, ISentenceCarrier, NcDiagnosticProgress, out double, out string) Resolves a coded-position word to its target axis coordinate. Returns true with the target position; false means “hold” — the caller writes anchorPosition instead (no motion on this axis), with any error already reported. resolvedOverride is always set to the plain override value the caller stamps over the coded entry (Absolute on every hold). public static bool TryResolveCodedTarget(IIndexingPositionConfig indexingConfig, string axis, string codedOverride, double parsedValue, double anchorPosition, ISentenceCarrier sentenceCarrier, NcDiagnosticProgress diag, out double targetPosition, out string resolvedOverride) Parameters indexingConfig IIndexingPositionConfig Indexing table, or null when the dependency list carries none. axis string Axis name (e.g., “C”). codedOverride string The coded PositioningOverride entry value. parsedValue double Evaluated word value — the position number (or count, for CodedIncremental). anchorPosition double Current axis position, used as the CIC anchor and as the hold target. sentenceCarrier ISentenceCarrier Block to anchor diagnostics to. diag NcDiagnosticProgress Diagnostic sink; may be null. targetPosition double Resolved target axis coordinate. resolvedOverride string Plain override value to stamp over the coded entry. Returns bool"
  },
  "api/Hi.NcParsers.LogicSyntaxs.CoolantSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.CoolantSyntax.html",
    "title": "Class CoolantSyntax | HiAPI-C# 2025",
    "summary": "Class CoolantSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Consumes M07 (mist ON), M08 (flood ON), and M09 (coolant OFF) from Flags and writes the ICoolantDef section with both IsOn (convenience flag) and Mode (abstract mode name: Flood / Mist / Off). Modal — persists via backward lookback. public class CoolantSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object CoolantSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M08\"] } } #AfterBuild: { \"Coolant\": { \"IsOn\": true, \"Mode\": \"Flood\" } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M09\", \"M03\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\"] }, \"Coolant\": { \"IsOn\": false, \"Mode\": \"Off\" } } #Previous: { \"Coolant\": { \"IsOn\": true, \"Mode\": \"Mist\" } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M03\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\"] }, \"Coolant\": { \"IsOn\": true, \"Mode\": \"Mist\" } } Constructors CoolantSyntax() Initializes a new instance with default settings. public CoolantSyntax() CoolantSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public CoolantSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.CoordinateOffsetUtil.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.CoordinateOffsetUtil.html",
    "title": "Class CoordinateOffsetUtil | HiAPI-C# 2025",
    "summary": "Class CoordinateOffsetUtil Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Shared utilities for all coordinate offset syntaxes (ISO, Siemens, Heidenhain). Handles section IO, backward lookback, and ProgramToMcTransform composition. public static class CoordinateOffsetUtil Inheritance object CoordinateOffsetUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields TransformSource Identifier used as the transform source key when composing the coordinate offset translation into ProgramToMcTransform. public const string TransformSource = \"CoordinateOffset\" Field Value string Methods ComposeTranslation(JsonObject, Vec3d) Composes a translation matrix from the given offset and registers it under TransformSource in the block's transform stack. public static void ComposeTranslation(JsonObject json, Vec3d offset) Parameters json JsonObject Block JSON object to update. offset Vec3d Translation offset to apply. FindPreviousCoordinateId(LazyLinkedListNode<SyntaxPiece>) Walks the previous node and returns its CoordinateId if any; used for modal lookback when the current block does not specify one. public static string FindPreviousCoordinateId(LazyLinkedListNode<SyntaxPiece> node) Parameters node LazyLinkedListNode<SyntaxPiece> Current node to look back from. Returns string GetCurrentCoordinateId(JsonObject) Gets CoordinateId from the current node's existing CoordinateOffset section (e.g., set by StaticInitializer). public static string GetCurrentCoordinateId(JsonObject json) Parameters json JsonObject Returns string ResolveOffset(IEnumerable<INcDependency>, string) Resolves the offset for coordId by scanning every IIsoCoordinateConfig in ncDependencyList and returning the first non-null result. Returns null when no provider has data for this id (callers should fall back to Zero). Multi-provider iteration lets a brand parameter table cover the hardware-mapped subset (e.g. Fanuc G54–G59, G54.1 P1–P48 backed by real parameter numbers) while a standalone IsoCoordinateTable covers HiNC-extension ids the brand table does not handle (e.g. G59.1–G59.9). public static Vec3d ResolveOffset(IEnumerable<INcDependency> ncDependencyList, string coordId) Parameters ncDependencyList IEnumerable<INcDependency> coordId string Returns Vec3d WriteSection(JsonObject, string, Vec3d) Writes the CoordinateOffset section with the given coordinate id and XYZ offset components. public static void WriteSection(JsonObject json, string coordId, Vec3d offset) Parameters json JsonObject Block JSON object to update. coordId string Coordinate system identifier (e.g., G54). offset Vec3d Offset translation in machine coordinates."
  },
  "api/Hi.NcParsers.LogicSyntaxs.DrillingCycleSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.DrillingCycleSyntax.html",
    "title": "Class DrillingCycleSyntax | HiAPI-C# 2025",
    "summary": "Class DrillingCycleSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll G81/G82 drilling cycle (rapid retract). Supports modal repetition. G82 covers G81 — the only difference is an optional dwell (P) at the bottom. Cycle sequence: Rapid to init position (target XY, previous Z) Rapid from init to R-point Feed from R-point to bottom Z [G82 only] Dwell P seconds at bottom Rapid from bottom to final (G98 → init Z, G99 → R) Reads absolute coordinates from the cycle section, which is resolved by CannedCycleResolveSyntax (modal repetition, G91 conversion, missing-axis fallback) before this syntax runs. Must be placed after CannedCycleResolveSyntax and before IncrementalResolveSyntax in the syntax chain. public class DrillingCycleSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object DrillingCycleSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples All cases below pre-populate CannedCycle as CannedCycleResolveSyntax would have written it (term, return mode, snapshot params) and leave the resolved cycle sub-section in Parsing for this syntax to consume. There is no #Previous:, so GetLastProgramXyz returns Vec3d.Zero → initZ = 0. F is supplied inside the cycle section so ResolveFeedrate(JsonObject, JsonObject, ISentenceCarrier, NcDiagnosticProgress) writes the block-level Feedrate (G94 default, mm/min → mm/s) before the items are emitted. G81 G98 — rapid to init (z=0), rapid to R, feed to bottom Z=-10 at F=600 mm/min → 10 mm/s, rapid back to init Z=0. Four items. The resolved cycle sub-section is removed by CleanupParsing(JsonObject, JsonObject, string); the empty Parsing drops off through CleanupParsing(JsonObject): #BeforeBuild: { \"Parsing\": { \"G81\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2, \"F\": 600 } }, \"CannedCycle\": { \"Term\": \"G81\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2 } } } #AfterBuild: { \"CannedCycle\": { \"Term\": \"G81\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2 } }, \"Feedrate\": { \"FeedrateValue\": 600, \"Term\": \"G94\", \"Unit\": \"mm/min\" }, \"CompoundMotion\": { \"Term\": \"G81\", \"Items\": [ { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 2 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": -10 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"Feedrate_mmds\": 10 } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } } ] }, \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 } } G82 with dwell P=0.5s — inserts a Dwell item between the feed-to-bottom rapid and the final retract, otherwise identical to G81. Five items total: #BeforeBuild: { \"Parsing\": { \"G82\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2, \"F\": 600, \"P\": 0.5 } }, \"CannedCycle\": { \"Term\": \"G82\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2 } } } #AfterBuild: { \"CannedCycle\": { \"Term\": \"G82\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2 } }, \"Feedrate\": { \"FeedrateValue\": 600, \"Term\": \"G94\", \"Unit\": \"mm/min\" }, \"CompoundMotion\": { \"Term\": \"G82\", \"Items\": [ { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 2 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": -10 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"Feedrate_mmds\": 10 } }, { \"Dwell\": { \"Time\": 0.5 } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } } ] }, \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 } } Remarks G85 (feed retract) and G86 (spindle-stop retract) have different retract behaviors and require separate syntax classes. Constructors DrillingCycleSyntax() Initializes a new instance with default settings. public DrillingCycleSyntax() DrillingCycleSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public DrillingCycleSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.DwellSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.DwellSyntax.html",
    "title": "Class DwellSyntax | HiAPI-C# 2025",
    "summary": "Class DwellSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Consumes the non-modal G4/G04 dwell sub-section captured by G4Syntax (Parsing.G4 / Parsing.G04) and emits a CompoundMotion with a single Dwell item, which Hi.NcParsers.Semantics.CompoundMotionSemanticUtil resolves into an ActDelay of the dwell duration. Argument dialects are configured per brand preset: Fanuc-family default — SecondsPrefixes = X/U (seconds), MillisecondsPrefixes = P (milliseconds), SpindleRevPrefixes = S (spindle revolutions). Siemens — G4 F<seconds> / G4 S<revolutions>: the preset sets SecondsPrefixes = F, clears the milliseconds list, keeps S revolutions. Because the capture layer owns the whole argument (the F/X/P word lands inside the dwell sub-section, never in Parsing.F / Parsing.X), a dwell block cannot poison the modal Feedrate and its X-word cannot mint a ghost motion — structural fixes for the G04 F60000 feed-poison and G04 X0.5 ghost-motion hazards. Spindle-revolution dwell needs the modal spindle speed: this syntax must be placed after SpindleSpeedSyntax in the Logic bundle so the block's own modal SpindleSpeed section is already written. When no positive rpm is known the dwell is consumed and recorded via an Unsupported Message (Dwell--SpindleRevUnresolved) instead of being time-simulated — no act is emitted. When several recognized argument prefixes appear on one block the resolution priority is seconds → milliseconds → revolutions; every recognized key is consumed either way. Unrecognized keys inside the sub-section are left in place so they surface through UnconsumedCheckSyntax. public class DwellSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object DwellSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Siemens dialect instance (SecondsPrefixes=[“F”], MillisecondsPrefixes=[], SpindleRevPrefixes=[“S”]) — the G04 F60000 corpus shape: the F is a dwell time in seconds, consumed here without ever touching the modal Feedrate: #BeforeBuild: { \"Parsing\": { \"G04\": { \"F\": 60000 } } } #AfterBuild: { \"CompoundMotion\": { \"Term\": \"G04\", \"Items\": [ { \"Dwell\": { \"Time\": 60000 } } ] } } Default Fanuc-family instance — G4 P500 milliseconds: #BeforeBuild: { \"Parsing\": { \"G4\": { \"P\": 500 } } } #AfterBuild: { \"CompoundMotion\": { \"Term\": \"G4\", \"Items\": [ { \"Dwell\": { \"Time\": 0.5 } } ] } } Siemens dialect instance — G4 S30 spindle revolutions against the block's modal 600 rpm → 3 s: #BeforeBuild: { \"Parsing\": { \"G4\": { \"S\": 30 } }, \"SpindleSpeed\": { \"SpindleSpeed_rpm\": 600, \"Direction\": \"CW\" } } #AfterBuild: { \"SpindleSpeed\": { \"SpindleSpeed_rpm\": 600, \"Direction\": \"CW\" }, \"CompoundMotion\": { \"Term\": \"G4\", \"Items\": [ { \"Dwell\": { \"Time\": 3 } } ] } } Siemens dialect instance — revolution dwell with no known spindle speed: consumed and recorded (Unsupported Message Dwell–SpindleRevUnresolved, not part of the JSON), no act: #BeforeBuild: { \"Parsing\": { \"G04\": { \"S\": 30 } } } #AfterBuild: {} Constructors DwellSyntax() Initializes a new instance with the default (Fanuc-family) dialect. public DwellSyntax() DwellSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public DwellSyntax(XElement src) Parameters src XElement Source XML element. Properties MillisecondsPrefixes Argument prefixes holding a dwell time in milliseconds. public List<string> MillisecondsPrefixes { get; set; } Property Value List<string> Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string SecondsPrefixes Argument prefixes holding a dwell time in seconds. public List<string> SecondsPrefixes { get; set; } Property Value List<string> SectionKeys Parsing sub-section keys this syntax consumes — both dwell code spellings as captured verbatim by G4Syntax. public List<string> SectionKeys { get; set; } Property Value List<string> SpindleRevPrefixes Argument prefixes holding a dwell length in spindle revolutions. public List<string> SpindleRevPrefixes { get; set; } Property Value List<string> XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.FanucPathSmoothingSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.FanucPathSmoothingSyntax.html",
    "title": "Class FanucPathSmoothingSyntax | HiAPI-C# 2025",
    "summary": "Class FanucPathSmoothingSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Consumes Fanuc G05.1 (high-precision contour / AICC II / Nano Smoothing) and records the modal state in the PathSmoothing JSON section using the FanucPathSmoothing schema. Q1 enables, Q0 disables; the optional R{n} precision-level is preserved as Level. The simulation does not alter the tool path — this is a controller-internal interpolation black box; the captured state exists for bidirectional NC-text reconstruction. Modal carry to subsequent blocks is handled by ModalCarrySyntax, which already tracks the PathSmoothing section key and deep-clones it forward. Also consumes the bare G05 P{n} HPCC family (captured by G05Syntax) into the block-local FanucHpcc section — recognized, intentionally not simulated (the SiemensStopreSyntax pattern). Ignoring P10000/P0 is safe offline; an ignored high-speed cycle machining call (P10001–P10999) means the simulation misses that machining, surfaced as a Warning. See IFanucHpccDef for the P function-selection semantics. The section is deliberately separate from the modal PathSmoothing section and is not modal-carried. public class FanucPathSmoothingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object FanucPathSmoothingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples First block of the stream (no #Previous:) — stamps the default disabled section so downstream modal lookback always sees a concrete PathSmoothing: #BeforeBuild: { } #AfterBuild: { \"PathSmoothing\": { \"IsEnabled\": false, \"Term\": \"G05.1\" } } G05.1 Q1 with no R — enables, no Level emitted: #Previous: { \"PathSmoothing\": { \"IsEnabled\": false, \"Term\": \"G05.1\" } } #BeforeBuild: { \"Parsing\": { \"G05.1\": { \"Q\": 1 } } } #AfterBuild: { \"PathSmoothing\": { \"IsEnabled\": true, \"Term\": \"G05.1\" } } G05.1 Q1 R3 — enables and preserves the precision level: #Previous: { \"PathSmoothing\": { \"IsEnabled\": false, \"Term\": \"G05.1\" } } #BeforeBuild: { \"Parsing\": { \"G05.1\": { \"Q\": 1, \"R\": 3 } } } #AfterBuild: { \"PathSmoothing\": { \"IsEnabled\": true, \"Term\": \"G05.1\", \"Level\": 3 } } G05.1 Q0 — disables; any prior Level is dropped (R only meaningful when enabling): #Previous: { \"PathSmoothing\": { \"IsEnabled\": true, \"Term\": \"G05.1\", \"Level\": 3 } } #BeforeBuild: { \"Parsing\": { \"G05.1\": { \"Q\": 0 } } } #AfterBuild: { \"PathSmoothing\": { \"IsEnabled\": false, \"Term\": \"G05.1\" } } Bare G05 P10000 — enters HPCC; consumed into the block-local FanucHpcc section, the modal PathSmoothing section is not touched: #Previous: { \"PathSmoothing\": { \"IsEnabled\": false, \"Term\": \"G05.1\" } } #BeforeBuild: { \"Parsing\": { \"G05\": { \"P\": 10000 } } } #AfterBuild: { \"FanucHpcc\": { \"Term\": \"G05\", \"IsEnabled\": true, \"FunctionCode\": 10000 } } G05 P0 — cancels HPCC; consumed silently (cancelling a no-op warrants no message): #Previous: { \"PathSmoothing\": { \"IsEnabled\": false, \"Term\": \"G05.1\" } } #BeforeBuild: { \"Parsing\": { \"G05\": { \"P\": 0 } } } #AfterBuild: { \"FanucHpcc\": { \"Term\": \"G05\", \"IsEnabled\": false, \"FunctionCode\": 0 } } G5 spelling alias — Term keeps the source spelling: #Previous: { \"PathSmoothing\": { \"IsEnabled\": false, \"Term\": \"G05.1\" } } #BeforeBuild: { \"Parsing\": { \"G5\": { \"P\": 10000 } } } #AfterBuild: { \"FanucHpcc\": { \"Term\": \"G5\", \"IsEnabled\": true, \"FunctionCode\": 10000 } } G05 P10000 on the very first block (no #Previous:) — the HPCC consumption runs ahead of the first-block early return, which then still stamps the default disabled PathSmoothing section: #BeforeBuild: { \"Parsing\": { \"G05\": { \"P\": 10000 } } } #AfterBuild: { \"FanucHpcc\": { \"Term\": \"G05\", \"IsEnabled\": true, \"FunctionCode\": 10000 }, \"PathSmoothing\": { \"IsEnabled\": false, \"Term\": \"G05.1\" } } Constructors FanucPathSmoothingSyntax() Initializes a new instance with default settings. public FanucPathSmoothingSyntax() FanucPathSmoothingSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public FanucPathSmoothingSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.FeedrateSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.FeedrateSyntax.html",
    "title": "Class FeedrateSyntax | HiAPI-C# 2025",
    "summary": "Class FeedrateSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Consumes F (feedrate) from Parsing and G94/G95 mode from Flags. Both are modal — persist across blocks via backward node lookback. Writes resolved state to a IFeedrateDef section. public class FeedrateSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object FeedrateSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples New F value with explicit G94 mode — both consumed, Unit derived as mm/min (G94 default): #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G94\"], \"F\": 100 } } #AfterBuild: { \"Feedrate\": { \"FeedrateValue\": 100, \"Term\": \"G94\", \"Unit\": \"mm/min\" } } G95 mode flag only — feedrate value inherited from #Previous:; unit recomputed (mm/rev) from the new term: #Previous: { \"Feedrate\": { \"FeedrateValue\": 50, \"Term\": \"G94\", \"Unit\": \"mm/min\" } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G95\"] } } #AfterBuild: { \"Feedrate\": { \"FeedrateValue\": 50, \"Term\": \"G95\", \"Unit\": \"mm/rev\" } } F value only (no G94/G95 on this block) alongside an unrelated M03 flag — mode inherits from #Previous:; M03 stays in Parsing.Flags because CleanupParsing is only invoked on the mode-flag branch: #Previous: { \"Feedrate\": { \"FeedrateValue\": 50, \"Term\": \"G95\", \"Unit\": \"mm/rev\" } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M03\"], \"F\": 200 } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\"] }, \"Feedrate\": { \"FeedrateValue\": 200, \"Term\": \"G95\", \"Unit\": \"mm/rev\" } } Constructors FeedrateSyntax() Initializes a new instance with default settings. public FeedrateSyntax() FeedrateSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public FeedrateSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.FineBoringSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.FineBoringSyntax.html",
    "title": "Class FineBoringSyntax | HiAPI-C# 2025",
    "summary": "Class FineBoringSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll G76 fine boring cycle. Supports modal repetition. Cycle sequence: Rapid to init position (target XY, previous Z) Rapid from init to R-point Feed from R-point to bottom Z Oriented spindle stop (OSS) Tool shift by Q in +X direction (clear bore wall) Rapid retract (shifted) to final Z Tool shift back to center Spindle restart (CW) Q specifies the lateral shift distance (mm) to avoid dragging the tool across the finished bore surface during retract. Shift direction defaults to +X (OSS angle 0°). Reads absolute coordinates from the cycle section, which is resolved by CannedCycleResolveSyntax before this syntax runs. public class FineBoringSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object FineBoringSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples G76 G98 — pre-populated CannedCycle (as CannedCycleResolveSyntax would have written), no #Previous: so initZ = 0, F=600 → 10 mm/s, shift Q=1 (lateral +X clearance for retract). First marker to spell out { “SpindleOrientation”: { “Angle_deg”: 0 } } — the OSS item produced by CreateSpindleOrientationItem(double). Eight items: init, R, feed-down, OSS, shifted-at-bottom (X=51), shifted-retract (X=51, Z=0), back-to-center (X=50, Z=0), spindle-restart CW: #BeforeBuild: { \"Parsing\": { \"G76\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2, \"Q\": 1, \"F\": 600 } }, \"CannedCycle\": { \"Term\": \"G76\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2, \"Q\": 1 } } } #AfterBuild: { \"CannedCycle\": { \"Term\": \"G76\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2, \"Q\": 1 } }, \"Feedrate\": { \"FeedrateValue\": 600, \"Term\": \"G94\", \"Unit\": \"mm/min\" }, \"CompoundMotion\": { \"Term\": \"G76\", \"Items\": [ { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 2 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": -10 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"Feedrate_mmds\": 10 } }, { \"SpindleOrientation\": { \"Angle_deg\": 0 } }, { \"ProgramXyz\": { \"X\": 51, \"Y\": 30, \"Z\": -10 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 51, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"SpindleControl\": { \"Direction\": \"CW\" } } ] }, \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 } } Constructors FineBoringSyntax() Initializes a new instance with default settings. public FineBoringSyntax() FineBoringSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public FineBoringSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.G43p4RtcpSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.G43p4RtcpSyntax.html",
    "title": "Class G43p4RtcpSyntax | HiAPI-C# 2025",
    "summary": "Class G43p4RtcpSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Handles G43.4 RTCP (Rotary Tool Center Point) activation. Writes the IToolHeightCompensationDef section and the ToolHeightCompensationSource entry in ProgramToMcTransform — a tool-normal · offset_mm translation at the block endpoint ABC. The chain entry is tagged KindDynamic when RTCP is active and ABC changes across the block, and KindStatic otherwise. The RTCP kinematic rotary part (Pn→MC rigid transform) is orthogonal to this syntax and is written by PivotTransformationSyntax on every block, because rotary state remains in effect beyond the RTCP modal (e.g. a non-RTCP G01 after G49 still inherits the last ABC from the program). The \"rotary dynamic\" distinction lives on the chain entry's KindKey alone and is read via HasDynamicEntry(JsonObject) by LinearMotionSyntax to pick ClLinear vs McLinear. G43.4 is used by Fanuc, Mazak, Syntec, and Okuma. Siemens (TRAORI) and Heidenhain (M128) are handled by separate syntaxes. Must be placed after ToolHeightOffsetSyntax (to override the ToolHeightCompensation entry when RTCP is active) and before PivotTransformationSyntax (which runs last in the chain). public class G43p4RtcpSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object G43p4RtcpSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Real-kinematics cases below wire TestDeps.CodeKinematics with the default chain code [O][Z][A][w];[O][Y][X][B][S][t] — a table-A / head-B 5-axis machine. A pivots around -X through origin (table side); B pivots around +Y through origin (head side). Both pivot axes pass through (0,0,0) because CodeXyzabcChain uses zero-offset component attachments — the head-B origin pivot is a pedagogical simplification (a real table-head machine has the spindle pivot offset from origin). Realistic MachineCoordinateState therefore carries A and B only; there is no C axis in this chain (5-axis machines have at most two rotary axes). Verification cue: with B=30° on the head side and the cutter extending +Z in tool frame at ABC=0, the tool normal after the head rotation lies at (sin 30°, 0, cos 30°); multiplying by the 10 mm tool length gives Trans ≈ (5, 0, 8.66). Explicit G43.4 H1 activation with no IMachineKinematics and no IToolOffsetConfig in the dependency list — exercises the activate path on its identity-matrix corner. The section is written with Offset_mm = 0 (no offset table → rawHeight = 0); the height-mat falls back to the no-kinematics branch new Mat4d { Trans = UnitZ * 0 } which collapses to identity; abcChanged is false (no current MC, no previous block) so the entry is tagged KindStatic. #BeforeBuild: { \"Parsing\": { \"G43.4\": { \"H\": \"1\" } } } #AfterBuild: { \"ToolHeightCompensation\": { \"Offset_mm\": 0, \"Term\": \"G43.4\", \"OffsetId\": 1 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } G43.4 H1 with ToolOffset(1 → 10 mm), the real 5-axis solver above, and current block carrying both rotary axes MachineCoordinateState.A = 0, B = 30 (as a prior McAbcSyntax would have written on this machine). The height-mat goes through MakeToolHeightMat(IMachineKinematics, Vec3d, double) which probes kinematics.McToPn(Zero, abc).Normal at abc = (0, π/6, 0) to get the tool orientation, then scales by 10 mm. With no previous block, abcChanged is false → entry stays Static: #BeforeBuild: { \"Parsing\": { \"G43.4\": { \"H\": \"1\" } }, \"MachineCoordinateState\": { \"A\": 0, \"B\": 30 } } #AfterBuild: { \"MachineCoordinateState\": { \"A\": 0, \"B\": 30 }, \"ToolHeightCompensation\": { \"Offset_mm\": 10, \"Term\": \"G43.4\", \"OffsetId\": 1 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 4.999999999999999, 0, 8.660254037844387, 1 ] } ] } Same setup plus a #Previous: block with MachineCoordinateState.B = 0 + XYZ origin — DidAbcChange(LazyLinkedListNode<SyntaxPiece>, IMachineAxisConfig) compares the rotary deltas and finds B changed across the block, so the entry is tagged KindDynamic (signalling that the tool orientation varies along the contour): #Previous: { \"MachineCoordinateState\": { \"X\": 0, \"Y\": 0, \"Z\": 0, \"A\": 0, \"B\": 0 } } #BeforeBuild: { \"Parsing\": { \"G43.4\": { \"H\": \"1\" } }, \"MachineCoordinateState\": { \"A\": 0, \"B\": 30 } } #AfterBuild: { \"MachineCoordinateState\": { \"A\": 0, \"B\": 30 }, \"ToolHeightCompensation\": { \"Offset_mm\": 10, \"Term\": \"G43.4\", \"OffsetId\": 1 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Dynamic\", \"Mat4d\": [ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 4.999999999999999, 0, 8.660254037844387, 1 ] } ] } Explicit activation whose H did not survive variable evaluation (vacant #100 stays a string) — no offset id resolves, RTCP still activates with a zero-length compensation (identity height mat) and the syntax emits the Comp-ToolHeight--001 validation warning (asserted by the integration test; the dump below pins the JSON shape only): #BeforeBuild: { \"Parsing\": { \"G43.4\": { \"H\": \"#100\" } } } #AfterBuild: { \"ToolHeightCompensation\": { \"Offset_mm\": 0, \"Term\": \"G43.4\", \"OffsetId\": 0 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } G43.4 with no H word on a block whose ToolChange section says tool 1 is in the spindle — the offset id is the equipped tool number (HardNc parity), the same ToolOffset(1 → 10 mm) and real kinematics as above, no rotary state so the tool normal is +Z and the height-mat carries Trans = (0, 0, 10). A bare G43.4 arrives as a flag (no parameter object to hang an H on): #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G43.4\"] }, \"ToolChange\": { \"ToolId\": 1, \"IsChange\": true, \"Term\": \"M06\" } } #AfterBuild: { \"ToolChange\": { \"ToolId\": 1, \"IsChange\": true, \"Term\": \"M06\" }, \"ToolHeightCompensation\": { \"Offset_mm\": 10, \"Term\": \"G43.4\", \"OffsetId\": 1 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,10,1] } ] } The first block after a program end — #Previous: carries the ProgramEnd section next to the still-active G43.4, and the block itself swings a rotary axis (as a post-M02 G0 A90. does when a CAM file chains several programs). This is the reset edge (ProgramEndSyntax): the controller's reset cancels tool-center-point control, so the modal is not carried, no Dynamic entry is written (the swing stays a plain McLinear rotary move instead of pinning the tool tip), and the block gets the G49 sentinel with the identity Mat4d — ToolHeightOffsetSyntax skipped this block because the previous term was not ISO: #Previous: { \"ProgramEnd\": { \"Term\": \"M02\" }, \"MachineCoordinateState\": { \"X\": 0, \"Y\": 0, \"Z\": 0, \"A\": 0, \"B\": 0 }, \"ToolHeightCompensation\": { \"Offset_mm\": 10, \"Term\": \"G43.4\", \"OffsetId\": 1 } } #BeforeBuild: { \"MachineCoordinateState\": { \"A\": 90, \"B\": 0 } } #AfterBuild: { \"MachineCoordinateState\": { \"A\": 90, \"B\": 0 }, \"ToolHeightCompensation\": { \"Offset_mm\": 0, \"Term\": \"G49\", \"OffsetId\": 0 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } Constructors G43p4RtcpSyntax() Initializes a new instance with default settings. public G43p4RtcpSyntax() G43p4RtcpSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public G43p4RtcpSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.G53p1RotaryPositionSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.G53p1RotaryPositionSyntax.html",
    "title": "Class G53p1RotaryPositionSyntax | HiAPI-C# 2025",
    "summary": "Class G53p1RotaryPositionSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll G53.1 — non-modal, one-shot rotary axis positioning. Positions the rotary axes (A/B/C) to align the physical tool axis with the active tilted work plane defined by G68.2. XYZ position is unchanged; only rotary axes move via rapid traverse. Requires IsoG68p2TiltSyntax (or equivalent) to have written the tilt transform. Uses IMachineKinematics to solve for the target A/B/C via inverse kinematics. Must be placed after IsoG68p2TiltSyntax (needs tilt data) and before ProgramXyzSyntax in the syntax chain. Writes A/B/C into MachineCoordinateState. Motion is handled by LinearMotionSyntax via modal G00/G01. public class G53p1RotaryPositionSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object G53p1RotaryPositionSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Real-kinematics cases below wire TestDeps.CodeKinematics with the default chain code [O][Z][A][w];[O][Y][X][B][S][t] — a table-A / head-B 5-axis machine. A pivots around -X through origin (table side); B pivots around +Y through origin (head side). Both pivot axes pass through (0,0,0) because CodeXyzabcChain uses zero-offset component attachments — the head-B origin pivot is a pedagogical simplification (real table-head machines have a spindle pivot offset). The TestDeps.AxisConfig((“A”, Rotary), (“B”, Rotary)) dep supplies the IMachineAxisConfig that the syntax queries for the rotary axis list; the rotaryAxes loop therefore writes exactly the A and B columns of MachineCoordinateState. There is no C axis on this machine (5-axis machines have at most two rotary axes). Verification cue: IK converts the active tilt's AxialNormal back to rotary degrees. For an IJK=(0,30°,0) tilt the solver picks an A angle close to 30° (drift from chain-axis-pivot offsets shows up as A≈29.94° in case 1) and leaves B at 0°. No-kinematics dep-guard early-return: standalone G53.1 with no IMachineKinematics dep in the list — the syntax emits validation error Coord-MachCoord--005 (G53.1 on a machine without rotary IK is an unexpected combination — typically a 5-axis NC file run against a 3-axis machine config, or a missing dep wire-up) and then consumes the flag via ConsumeFlag. Empty Parsing is then removed by CleanupParsing(JsonObject), so the post-Build block JSON is empty even though the diagnostic message was sent (the conformance check verifies only the JSON shape): #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G53.1\"] } } #AfterBuild: {} IK happy path — G53.1 with active G68.2 tilt on #Previous:, real XyzabcSolver (table-A / head-B 5-axis), and a TestDeps.AxisConfig(A=Rotary, B=Rotary) dep. The syntax reads the previous block's tilt Mat4d, solves OrientationToMcAbc(tiltMat.AxialNormal) for the rotary ABC, converts radians → degrees, writes MachineCoordinateState with both rotary axes (XYZ inherited from prevMc = Vec3d.Zero when no previous MC exists), and stamps ProgramXyz. The block also gets a non-modal MotionEvent with Term: \"G53.1\" so the source G-code survives in JSON for bidirectional reconstruction (per the precedence rule on Term: when set, this is the block's actual motion source; the modal MotionState remains as inherited context): #Previous: { \"TiltTransform\": { \"Term\": \"G68.2\", \"X\": 0, \"Y\": 0, \"Z\": 0, \"I\": 0, \"J\": 30, \"K\": 0 }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [ 1, 0, 0, 0, 0, 0.8660254037844388, 0.5, 0, 0, -0.5, 0.8660254037844388, 0, 0, 0, 0, 1 ] } ] } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G53.1\"] } } #AfterBuild: { \"MachineCoordinateState\": { \"X\": 0, \"Y\": 0, \"Z\": 0, \"A\": 29.99999937094331, \"B\": 0 }, \"ProgramXyz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true, \"Term\": \"G53.1\" } } Explicit ABC override — G53.1 A0 B45 on top of the same G68.2 tilt + kinematics + axis-config set up. The IK still solves, but the explicit A=0 and B=45 overrides what IK returned for those axes; C stays at the IK-solved value (C-axis is not present in the table-A/head-B layout, so the rotaryAxes loop only writes A and B): #Previous: { \"TiltTransform\": { \"Term\": \"G68.2\", \"X\": 0, \"Y\": 0, \"Z\": 0, \"I\": 0, \"J\": 30, \"K\": 0 }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [ 1, 0, 0, 0, 0, 0.8660254037844388, 0.5, 0, 0, -0.5, 0.8660254037844388, 0, 0, 0, 0, 1 ] } ] } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G53.1\"], \"A\": 0, \"B\": 45 } } #AfterBuild: { \"MachineCoordinateState\": { \"X\": 0, \"Y\": 0, \"Z\": 0, \"A\": 0, \"B\": 45 }, \"ProgramXyz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true, \"Term\": \"G53.1\" } } Remarks When IMachineKinematics is not available (3-axis config), G53.1 is silently consumed with no positional effect. When G68.2 is not active, a validation error is reported. Optional explicit A/B/C on the G53.1 line (post-processor hints) override the IK result. These are read from Parsing via ConsumeAxis(JsonObject, string, ISentenceCarrier, NcDiagnosticProgress) and consumed to prevent McAbcSyntax from double-processing. Constructors G53p1RotaryPositionSyntax() Initializes a new instance with default settings. public G53p1RotaryPositionSyntax() G53p1RotaryPositionSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public G53p1RotaryPositionSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainCannedCycleSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainCannedCycleSyntax.html",
    "title": "Class HeidenhainCannedCycleSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainCannedCycleSyntax Namespace Hi.NcParsers.LogicSyntaxs.Heidenhain Assembly HiMech.dll Bridges the klartext machining-cycle vocabulary onto the shared ISO canned-cycle machinery. Owns the self-carrying MachiningCycleDef store (single-step lookback + rewrite on every block — the P1 datum-shift pattern) and the call-once vs modal split: Definition (Parsing.MachiningCycle from HeidenhainMachiningCycleSyntax): mapped to ISO slots at definition time — 200 → G81/G82/G83 (peck when Q202 < |Q201|), 232 → G81 (start point Q225/Q226/Q227, end Q386, feed Q207), 251/252/253 → G81/G83 (surface Q203, clearance Q200, depth Q201, plunge feed Q206, step-down Q202). A definition never executes by itself. Unsupported numbers (19, …) are recognized-but-not-simulated: consumed whole with HeidenhainCycl--Unsupported, stored unarmable so a later call warns instead of moving. Required parameters that are missing or non-literal make the store unarmable with HeidenhainCycl--ParamsNotLiteral. Call-once (CYCL CALL [POS] record from HeidenhainCyclCallSyntax, or an M99 flag on a positioning block — the TNC block-wise call, unrelated to the Fanuc return M99): writes the mapped cycle as a direct Parsing.G8x sub-section on this block, which CannedCycleResolveSyntax resolves and the shared cycle syntaxes expand into a CompoundMotion. POS coordinates override the stored X/Y; the POS Z is a pre-position, recorded but never fed into the hole-bottom slot. Words carrying the klartext incremental stamp — POS words (CYCL CALL POS IX+20) and root words on the M99/M89 forms (L IX+20 R0 FMAX M99 — the manual's hole-group shape), see HeidenhainIncrementalAxisWordUtil — are resolved against the last programmed position here, on the spot: this syntax runs ahead of the shared IncrementalResolveSyntax and consumes the words, so the per-word override would otherwise be lost and the hole drilled at the raw distance. The ISO modal-lookback branch is deliberately bypassed: it has no positioning gate, so an armed CannedCycle would re-execute on flag-only blocks — wrong for klartext. Modal (M89): sets Modal; each subsequent block carrying root axis words (and no CArc statement) fires the same direct-section path with the block's X/Y consumed into the cycle. M99 fires once and clears the modality; a new CYCL DEF replaces the store. Seal: on every non-firing block whose previous block carries an active CannedCycle term, a G80 flag is injected (the P0 G00/G01 injection pattern) so CannedCycleResolveSyntax writes the cancel sentinel — the one-shot execution never leaks into ISO modal repetition. Known divergences (recorded, corpus-benign): the cycle's mapped feed enters the modal Feedrate section during expansion (ISO semantics; the Siemens MCALL precedent accepts the same leak); the final retract plane is the ISO G98 initial level, not Q204's second set-up clearance (Q204 is recorded in the definition store only) — and an incremental Z word chained off a cycle end (L IZ.., CYCL CALL POS IZ..) inherits that gap, since it adds to the simulated end plane. Must run after the tilt/RTCP family and immediately before CannedCycleResolveSyntax. public class HeidenhainCannedCycleSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainCannedCycleSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainCannedCycleSyntax() Initializes a new instance with default settings. public HeidenhainCannedCycleSyntax() HeidenhainCannedCycleSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainCannedCycleSyntax(XElement src) Parameters src XElement Source XML element. Fields M89Flag Modal cycle-call M function. public const string M89Flag = \"M89\" Field Value string M99Flag Block-wise cycle-call M function (TNC semantics, not the Fanuc return). public const string M99Flag = \"M99\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainCircleCenterSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainCircleCenterSyntax.html",
    "title": "Class HeidenhainCircleCenterSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainCircleCenterSyntax Namespace Hi.NcParsers.LogicSyntaxs.Heidenhain Assembly HiMech.dll Heidenhain-specific: turns the Parsing.CC record into the modal HeidenhainCircleCenter { X, Y, Z? } section (absolute program coordinates). Self-carrying every block (PlaneSelect pattern — detected ?? previous), so the arc syntax's single-step read always works without ModalCarry involvement; a CC with partial axes merges the missing components from the previous center. Must run before HeidenhainCircularMotionSyntax. A CC stating no coordinates (BareKey) takes the last programmed position, read at THIS block and frozen into the section — the documented klartext form whose purpose is that the tool moves away before the arc, so a later read at the arc block would take the arc's own start point instead. Being a definition, it replaces the modal center rather than inheriting the previous one's axes. public class HeidenhainCircleCenterSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainCircleCenterSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainCircleCenterSyntax() Initializes a new instance with default settings. public HeidenhainCircleCenterSyntax() HeidenhainCircleCenterSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainCircleCenterSyntax(XElement src) Parameters src XElement Source XML element. Fields SectionKey Modal section key (absolute program-coordinate center). public const string SectionKey = \"HeidenhainCircleCenter\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainCircularMotionSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainCircularMotionSyntax.html",
    "title": "Class HeidenhainCircularMotionSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainCircularMotionSyntax Namespace Hi.NcParsers.LogicSyntaxs.Heidenhain Assembly HiMech.dll Heidenhain circular motion — the Klartext half of the brand's two arc syntaxes. The shared CircularMotionSyntax (with IsIjkAbsolute set) runs right after it for the DIN/ISO dialect: the two gates are per-block exclusive (a klartext arc has CArc and no I/J/K/R; an ISO arc the reverse) and both honor the single Group 01 MotionEvent slot. Gated by the Parsing.C statement marker (klartext arcs carry no G02/G03 and no modal arc continuation): the endpoint comes from the block's resolved ProgramXyz, the center from the modal HeidenhainCircleCenterSyntax section, and the direction from DR- (CW → G02) / DR+ (CCW → G03). A closed arc on the active plane is a full circle. Two malformed shapes warn and degrade to the modal linear move to the endpoint (chord): a missing DR (Arc-DR–Missing), and a center sitting on the arc's own start point (Arc-CircleCenter–OnStartPoint) — a zero begin radius that emits no motion act at all while the endpoint still advances the modal position. A CC that states only ONE in-plane coordinate is not degraded: that arc has real geometry, and only the optimizer's splition refuses it (see below). The event is stamped with its CenterSource (ModalCircleCenter / StartPoint) because a C block never states its center — the NcOpt splition write-back reads it. public class HeidenhainCircularMotionSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainCircularMotionSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainCircularMotionSyntax() Initializes a new instance with default settings. public HeidenhainCircularMotionSyntax() HeidenhainCircularMotionSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainCircularMotionSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainCoordinateOffsetSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainCoordinateOffsetSyntax.html",
    "title": "Class HeidenhainCoordinateOffsetSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainCoordinateOffsetSyntax Namespace Hi.NcParsers.LogicSyntaxs.Heidenhain Assembly HiMech.dll Heidenhain-specific: resolves coordinate offset from CYCL DEF 247 (Datum Preset) and CYCL DEF 7 (Datum Shift). CYCL DEF 247 Q339=N: selects datum preset table entry N — written to the shared CoordinateOffset section (kept alive modally by IsoCoordinateOffsetSyntax via HeidenhainDatumTable synthetic-id resolution). CYCL DEF 7 (#N table row or direct X/Y/Z) is additive on top of the active preset (TNC semantics; HardNc oracle composes -preset + shift): it is written to its own DatumShift section with a separate ProgramToMcTransform entry (DatumShiftTransformSource) so preset and shift compose in the transform chain instead of replacing each other. The shift is carried modally by this syntax itself: on blocks without a CYCL DEF, a numbered row re-resolves from the table and a direct shift carries its values forward. Cancelling is a zero shift (CYCL DEF 7.1 X+0 Y+0 Z+0). A klartext I-prefixed word (CYCL DEF 7.2 IY+5, kept under its prefixed key in the record by the parser) shifts BY the value on top of the shift active on the previous block — the manual's \"incremental values are always referenced to the datum which was last valid, this can be a datum which has already been shifted\" — never a distance from the tool position, which is why it bypasses the PositioningOverride / IncrementalResolveSyntax route entirely. For DIN/ISO compatibility (G54–G59), use IsoCoordinateOffsetSyntax in addition to this syntax in the Heidenhain syntax list. Uses replace-by-source so both syntaxes coexist without double-composing. public class HeidenhainCoordinateOffsetSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainCoordinateOffsetSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Mat4d arrays are 16 plain doubles in column-major order; pure translation by (tx,ty,tz) is [1,0,0,0, 0,1,0,0, 0,0,1,0, tx,ty,tz,1]. The cycle keys are consumed (block text stays authoritative for round-trip emission), so datum declarations replay without unconsumed-parsing noise. CYCL DEF 247 Q339=+1 with a HeidenhainDatumTable populated so preset row 1 = (50, 50, 0) — the syntax looks up the row and writes a synthetic CoordinateId = \"DATUM_PRESET_1\" reflecting the resolved preset index: #BeforeBuild: { \"Parsing\": { \"CYCL DEF\": 247, \"Q339\": \"+1\" } } #AfterBuild: { \"CoordinateOffset\": { \"CoordinateId\": \"DATUM_PRESET_1\", \"Offset_X\": 50, \"Offset_Y\": 50, \"Offset_Z\": 0 }, \"ProgramToMcTransform\": [ { \"Source\": \"CoordinateOffset\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 50,50,0,1] } ] } CYCL DEF 7 #5 — datum shift table lookup via the # index (here mapped to (100, 200, 0)); the shift lands in its own DatumShift section and transform entry so it composes with (instead of replacing) an active preset: #BeforeBuild: { \"Parsing\": { \"CYCL DEF\": 7, \"#\": 5 } } #AfterBuild: { \"DatumShift\": { \"ShiftId\": \"DATUM_SHIFT_5\", \"Offset_X\": 100, \"Offset_Y\": 200, \"Offset_Z\": 0 }, \"ProgramToMcTransform\": [ { \"Source\": \"DatumShift\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 100,200,0,1] } ] } CYCL DEF 7.0/7.1 X+10 Y+20 Z+5 — direct X/Y/Z form: the values are read from the nested Parsing[\"DATUM SHIFT\"] record written by the datum-shift cycle parser; no HeidenhainDatumTable dep is required. ShiftId is the literal \"DATUM_SHIFT_DIRECT\" sentinel: #BeforeBuild: { \"Parsing\": { \"CYCL DEF\": 7, \"DATUM SHIFT\": { \"X\": 10, \"Y\": 20, \"Z\": 5 } } } #AfterBuild: { \"DatumShift\": { \"ShiftId\": \"DATUM_SHIFT_DIRECT\", \"Offset_X\": 10, \"Offset_Y\": 20, \"Offset_Z\": 5 }, \"ProgramToMcTransform\": [ { \"Source\": \"DatumShift\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 10,20,5,1] } ] } CYCL DEF 7.1 IX+5 / 7.2 IY-20 / 7.3 IZ+0 — klartext incremental words, kept under their prefixed keys by the parser: each shifts BY its value on top of the shift active on the previous block (here the direct (10, 20, 5)), so the result is (15, 0, 5) — not a distance from the tool position: #Previous: { \"DatumShift\": { \"ShiftId\": \"DATUM_SHIFT_DIRECT\", \"Offset_X\": 10, \"Offset_Y\": 20, \"Offset_Z\": 5 } } #BeforeBuild: { \"Parsing\": { \"CYCL DEF\": 7, \"DATUM SHIFT\": { \"IX\": 5, \"IY\": -20, \"IZ\": 0 } } } #AfterBuild: { \"DatumShift\": { \"ShiftId\": \"DATUM_SHIFT_DIRECT\", \"Offset_X\": 15, \"Offset_Y\": 0, \"Offset_Z\": 5 }, \"ProgramToMcTransform\": [ { \"Source\": \"DatumShift\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 15,0,5,1] } ] } Constructors HeidenhainCoordinateOffsetSyntax() Initializes a new instance with default settings. public HeidenhainCoordinateOffsetSyntax() HeidenhainCoordinateOffsetSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainCoordinateOffsetSyntax(XElement src) Parameters src XElement Source XML element. Fields DatumShiftSection JSON section name for the additive datum shift (CYCL DEF 7). public const string DatumShiftSection = \"DatumShift\" Field Value string DatumShiftTransformSource Transform-stack source key for the datum-shift translation (separate from the preset's so both compose). public const string DatumShiftTransformSource = \"DatumShift\" Field Value string DirectShiftId ShiftIdKey sentinel for the direct-XYZ form. public const string DirectShiftId = \"DATUM_SHIFT_DIRECT\" Field Value string ShiftIdKey Section key holding the shift identity (row id or the DIRECT sentinel). public const string ShiftIdKey = \"ShiftId\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainCyclePrePositionSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainCyclePrePositionSyntax.html",
    "title": "Class HeidenhainCyclePrePositionSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainCyclePrePositionSyntax Namespace Hi.NcParsers.LogicSyntaxs.Heidenhain Assembly HiMech.dll Lifts the expanded cycle's initial plane to the recorded TNC pre-position Z. A CYCL CALL POS … Z±n (and an M99/M89 positioning block's own Z word) positions the spindle BEFORE the cycle runs; the shared ISO expansion instead anchors its initial plane — the first rapid and the G98 final retract — on the PREVIOUS block's Z. Left unlifted, a call that climbs to a safe Z before drilling would be simulated traversing at the stale old Z (phantom collisions through fixtures) and G98 would plunge the tool back to that stale Z after the hole. Mechanics: when the HeidenhainCyclCall record carries a numeric Z and a CompoundMotion was expanded, the first item (the initial-plane rapid — both shared cycle syntaxes emit it first) and, under G98, the final item and the block's final ProgramXyz are re-anchored to the pre-position Z. G99 finals (R-plane) are untouched. Runs after the shared cycle syntaxes and before HeidenhainCycleRetractSyntax (whose appended M140 retract builds on the lifted final point). public class HeidenhainCyclePrePositionSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainCyclePrePositionSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainCyclePrePositionSyntax() Initializes a new instance with default settings. public HeidenhainCyclePrePositionSyntax() HeidenhainCyclePrePositionSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainCyclePrePositionSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainCycleRetractSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainCycleRetractSyntax.html",
    "title": "Class HeidenhainCycleRetractSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainCycleRetractSyntax Namespace Hi.NcParsers.LogicSyntaxs.Heidenhain Assembly HiMech.dll Consumes the Parsing.M140 record that HeidenhainMFunctionSyntax deferred on a may-fire-cycle block — a CYCL CALL [POS] host (… M140 MB+n is a real house.H shape), an M99/M89 flag block, or any block under armed M89 modality. WriteCompoundMotion(JsonObject, string, JsonArray, Vec3d) destroys any pre-written MotionEvent, so the retract is appended after the cycle expansion instead: Cycle expanded — a rapid item to (final X, final Y, retract Z) is appended to the CompoundMotion items and the block's final ProgramXyz is lifted to the retract plane. The MB math is ResolveRetractTargetZ(JsonObject, Vec3d, List<INcDependency>, ISentenceCarrier, NcDiagnosticProgress) verbatim. The real TNC runs M140 at block start (retract, then position + cycle); appending it is a transient-only divergence — the endpoint chain re-anchors on the next command point (the P3 PLANE MOVE precedent) and the appended order is the safer trajectory. An F on the M140 is recorded on the item but the appended retract stays rapid (corpus M140-on-call blocks are all F-less). Cycle did not expand (call consumed without motion) — the plain HeidenhainMFunctionSyntax retract behavior runs here unchanged, so a fail-soft call never silently drops the retract. Must run after the shared cycle syntaxes (DrillingCycleSyntax/PeckDrillingCycleSyntax) and before McXyzSyntax. public class HeidenhainCycleRetractSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainCycleRetractSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainCycleRetractSyntax() Initializes a new instance with default settings. public HeidenhainCycleRetractSyntax() HeidenhainCycleRetractSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainCycleRetractSyntax(XElement src) Parameters src XElement Source XML element. Fields RetractZKey Record key of the appended retract plane (program Z) on the call record. public const string RetractZKey = \"RetractZ\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainLnOrientationSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainLnOrientationSyntax.html",
    "title": "Class HeidenhainLnOrientationSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainLnOrientationSyntax Namespace Hi.NcParsers.LogicSyntaxs.Heidenhain Assembly HiMech.dll Heidenhain LN posture rules — the brand adapter between the Parsing.LN vector record (HeidenhainLnSyntax) and the shared OrientationVectorResolveSyntax. Applies the TNC640/TNC7 manual's rules verbatim: T vector present + M128/FUNCTION TCPM active → the tool axis is T (\"Tool keeps the set tool orientation\"). T absent + RTCP active → the tool axis is the surface normal N (\"the control maintains the tool perpendicular to the workpiece contour\"). RTCP inactive → the T vector is ignored, exactly like the control (\"the control ignores the direction vector T, even if it is defined in the LN block\") — diagnosed as Orientation-Vector--IgnoredNoTcpm, posture untouched. The chosen vector is written (verbatim within the unit-length tolerance; normalized with a diagnostic beyond it) to the brand-agnostic ToolOrientationKey section; the surface normal is always carried on SurfaceNormalKey — compensation along it (DR2 / 3D-ToolComp) is recognized, not simulated (SurfaceNormal--CompNotSimulated, first LN block of a run only). RTCP activity is judged dual-source — the same-block Parsing words (M128 / FUNCTION TCPM, before HeidenhainRtcpSyntax consumes them; the same-block on+off contradiction resolves off, the P1 rule) OR the most recent IToolHeightCompensationDef owner term — so an LN block that itself activates RTCP is not silently skipped. Must run after McAbcSyntax and before OrientationVectorResolveSyntax (the producer/consumer order) and before HeidenhainRtcpSyntax (which reads the resolved endpoint ABC for its Dynamic/Static marking). The vector is interpreted in the untilted program frame; combining LN with an active PLANE tilt is diagnosed (Orientation-Vector--TiltedFrameAssumed), not remapped. public class HeidenhainLnOrientationSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainLnOrientationSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples T vector under same-block M128 activation — promoted to the shared ToolOrientation section (M128 record stays for the RTCP syntax); the normal is carried on SurfaceNormal: #BeforeBuild: { \"Parsing\": { \"M128\": { \"Bare\": true }, \"LN\": { \"NX\": 0, \"NY\": 0, \"NZ\": 1, \"TX\": 0.5, \"TY\": 0, \"TZ\": 0.8660254 } } } #AfterBuild: { \"Parsing\": { \"M128\": { \"Bare\": true } }, \"SurfaceNormal\": { \"Vector\": { \"X\": 0, \"Y\": 0, \"Z\": 1 }, \"Term\": \"NX/NY/NZ\" }, \"ToolOrientation\": { \"Vector\": { \"X\": 0.5, \"Y\": 0, \"Z\": 0.8660254 }, \"Term\": \"TX/TY/TZ\" } } RTCP inactive — T ignored (diagnosed), N still carried, no ToolOrientation: #BeforeBuild: { \"Parsing\": { \"LN\": { \"NX\": 0, \"NY\": 0, \"NZ\": 1, \"TX\": 0.5, \"TY\": 0, \"TZ\": 0.8660254 } } } #AfterBuild: { \"SurfaceNormal\": { \"Vector\": { \"X\": 0, \"Y\": 0, \"Z\": 1 }, \"Term\": \"NX/NY/NZ\" } } T absent, RTCP active from the previous block's owner term — the normal stands in as the posture source (tool perpendicular to the contour): #Previous: { \"ToolHeightCompensation\": { \"Offset_mm\": 0, \"Term\": \"M128\", \"OffsetId\": 0 } } #BeforeBuild: { \"Parsing\": { \"LN\": { \"NX\": 0.5, \"NY\": 0, \"NZ\": 0.8660254 } } } #AfterBuild: { \"SurfaceNormal\": { \"Vector\": { \"X\": 0.5, \"Y\": 0, \"Z\": 0.8660254 }, \"Term\": \"NX/NY/NZ\" }, \"ToolOrientation\": { \"Vector\": { \"X\": 0.5, \"Y\": 0, \"Z\": 0.8660254 }, \"Term\": \"NX/NY/NZ\" } } Zero T vector — diagnosed, posture untouched (the Syntec COR-159 analogue); the N-less record leaves no SurfaceNormal either: #Previous: { \"ToolHeightCompensation\": { \"Offset_mm\": 0, \"Term\": \"M128\", \"OffsetId\": 0 } } #BeforeBuild: { \"Parsing\": { \"LN\": { \"TX\": 0, \"TY\": 0, \"TZ\": 0 } } } #AfterBuild: {} Constructors HeidenhainLnOrientationSyntax() Initializes a new instance with default settings. public HeidenhainLnOrientationSyntax() HeidenhainLnOrientationSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainLnOrientationSyntax(XElement src) Parameters src XElement Source XML element. Fields NVectorTerm Term recorded when the posture source is the surface normal. public const string NVectorTerm = \"NX/NY/NZ\" Field Value string TVectorTerm Term recorded when the posture source is the tool vector. public const string TVectorTerm = \"TX/TY/TZ\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainMFunctionSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainMFunctionSyntax.html",
    "title": "Class HeidenhainMFunctionSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainMFunctionSyntax Namespace Hi.NcParsers.LogicSyntaxs.Heidenhain Assembly HiMech.dll Heidenhain-specific M-function semantics for the near-universal corpus family: M126/M127 — shortest-path rotary traverse on/off. Writes the modal RotaryWrap { Shortest } section consumed by McAbcCyclicPathSyntax (absent = shortest, the shared default); the Heidenhain preset's Logic ModalCarry tracks the section. M128/M129 — owned by HeidenhainRtcpSyntax since P3 (full RTCP on the ToolHeightCompensation section); this syntax no longer touches them. M140 MB — tool-axis retract. Executes a machine-coordinate move along +Z (the corpus machines are table-tilting, so the tool axis stays machine +Z; a head-machine generalization is a recorded P6 backlog item): MB+n retracts by n mm, MB MAX retracts to the positive Z stroke limit (IStrokeLimitConfig; unresolvable limit warns M140--NoStrokeLimit and skips). The retract runs at the modal feed (the statement's F is recorded on the MotionEvent as RetractFeedrate, not folded into the modal feedrate). Must run before McAbcCyclicPathSyntax (RotaryWrap) and before LinearMotionSyntax/McXyzSyntax (M140 occupies the block's MotionEvent). public class HeidenhainMFunctionSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainMFunctionSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainMFunctionSyntax() Initializes a new instance with default settings. public HeidenhainMFunctionSyntax() HeidenhainMFunctionSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainMFunctionSyntax(XElement src) Parameters src XElement Source XML element. Fields RotaryWrapSection Modal section consumed by McAbcCyclicPathSyntax; absent = shortest (shared default). public const string RotaryWrapSection = \"RotaryWrap\" Field Value string ShortestKey Key of the boolean inside RotaryWrapSection. public const string ShortestKey = \"Shortest\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainMirrorTransformSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainMirrorTransformSyntax.html",
    "title": "Class HeidenhainMirrorTransformSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainMirrorTransformSyntax Namespace Hi.NcParsers.LogicSyntaxs.Heidenhain Assembly HiMech.dll Simulates the Heidenhain DIN/ISO G28 MIRROR IMAGE function (the CYCL DEF 8 twin): consumes the statement list HeidenhainMirrorImageSyntax recorded under Parsing.MirrorImage, keeps the modal mirror set in the root SectionKey section (each statement REPLACES the set — course 62192's four-quadrant idiom relies on G28 Y after G28 X Y leaving only Y mirrored; bare G28 resets), and writes the sign-flip matrix into ProgramToMcTransform as the TransformSource entry. Must run before every other transform writer (HeidenhainPlaneTiltSyntax downward) so the mirror entry is the chain's first — the mirror flips program coordinates about the current datum inside the active working plane, i.e. innermost: tilt, tool-height and coordinate-offset entries compose after it and are never themselves mirrored. Because every motion semantic resolves contours in program coordinates and maps each interpolated point through the composed chain (CreateProgramPosToMcFunc(LazyLinkedListNode<SyntaxPiece>, IMachineAxisConfig)), the arc-handedness flip (G02↔G03) and the radius-compensation side flip (G41↔G42) a real control performs under a single-axis mirror emerge from the pointwise mapping — no re-tagging of IsCcw or the compensation side happens, and none is needed. Two statement shapes stay recognized-but-not-simulated: a rotary axis letter (RotaryUnsupportedId — a rotary mirror is not representable in the XYZ transform chain; the letter is dropped from the set, the statement still replaces) and the Fanuc-shaped valued form (ValuedUnsupportedId — the manual's mirror idiom is bare letters, so G91 G28 X0 Y0 Z0 in a mislabeled .I file must not arm a full-XYZ mirror; the statement is consumed with zero effect). public class HeidenhainMirrorTransformSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainMirrorTransformSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Activation — a single-axis statement arms the mirror: the modal section appears and the chain gets the sign-flip entry: #BeforeBuild: { \"Parsing\": { \"MirrorImage\": [ { \"Axes\": [\"X\"] } ] } } #AfterBuild: { \"MirrorImage\": { \"Axes\": [\"X\"] }, \"ProgramToMcTransform\": [ { \"Source\": \"MirrorImage\", \"Kind\": \"Static\", \"Mat4d\": [-1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } Replace semantics — a new statement replaces the previous set (never a union): Y-only survives after an X-mirror block: #Previous: { \"MirrorImage\": { \"Axes\": [\"X\"] } } #BeforeBuild: { \"Parsing\": { \"MirrorImage\": [ { \"Axes\": [\"Y\"] } ] } } #AfterBuild: { \"MirrorImage\": { \"Axes\": [\"Y\"] }, \"ProgramToMcTransform\": [ { \"Source\": \"MirrorImage\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,-1,0,0, 0,0,1,0, 0,0,0,1] } ] } Modal carry — a statement-free block re-writes the active set and its chain entry (single-step lookback, the DatumShift pattern): #Previous: { \"MirrorImage\": { \"Axes\": [\"X\", \"Y\"] } } #BeforeBuild: {} #AfterBuild: { \"MirrorImage\": { \"Axes\": [\"X\", \"Y\"] }, \"ProgramToMcTransform\": [ { \"Source\": \"MirrorImage\", \"Kind\": \"Static\", \"Mat4d\": [-1,0,0,0, 0,-1,0,0, 0,0,1,0, 0,0,0,1] } ] } Bare reset — the empty set stays modal (blocking a stale carry) and no chain entry is written: #Previous: { \"MirrorImage\": { \"Axes\": [\"X\"] } } #BeforeBuild: { \"Parsing\": { \"MirrorImage\": [ { \"Axes\": [] } ] } } #AfterBuild: { \"MirrorImage\": { \"Axes\": [] } } Rotary letter — dropped from the set with the HeidenhainMirror–RotaryUnsupported warning (statement still replaces, so a lone rotary word clears an active linear mirror): #Previous: { \"MirrorImage\": { \"Axes\": [\"Y\"] } } #BeforeBuild: { \"Parsing\": { \"MirrorImage\": [ { \"Axes\": [\"C\"] } ] } } #AfterBuild: { \"MirrorImage\": { \"Axes\": [] } } Valued (Fanuc-shaped) statement — consumed with zero mirror effect (HeidenhainMirror–ValuedUnsupported); the active set carries through unchanged: #Previous: { \"MirrorImage\": { \"Axes\": [\"X\"] } } #BeforeBuild: { \"Parsing\": { \"MirrorImage\": [ { \"Axes\": [\"X\", \"Y\", \"Z\"], \"Valued\": true } ] } } #AfterBuild: { \"MirrorImage\": { \"Axes\": [\"X\"] }, \"ProgramToMcTransform\": [ { \"Source\": \"MirrorImage\", \"Kind\": \"Static\", \"Mat4d\": [-1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } Sequential statements on one block — applied in source order, each replacing (the last one wins): #BeforeBuild: { \"Parsing\": { \"MirrorImage\": [ { \"Axes\": [\"X\"] }, { \"Axes\": [\"Y\"] } ] } } #AfterBuild: { \"MirrorImage\": { \"Axes\": [\"Y\"] }, \"ProgramToMcTransform\": [ { \"Source\": \"MirrorImage\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,-1,0,0, 0,0,1,0, 0,0,0,1] } ] } Never-active program — no statement, no previous section: the block stays untouched (files without G28 dump identically to before this syntax existed): #BeforeBuild: { \"ProgramXyz\": { \"X\": 10, \"Y\": 0, \"Z\": 0 } } #AfterBuild: { \"ProgramXyz\": { \"X\": 10, \"Y\": 0, \"Z\": 0 } } Constructors HeidenhainMirrorTransformSyntax() Initializes a new instance with default settings. public HeidenhainMirrorTransformSyntax() HeidenhainMirrorTransformSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainMirrorTransformSyntax(XElement src) Parameters src XElement Source XML element. Fields RotaryUnsupportedId Diagnostic id: a rotary axis letter in a G28 statement (dropped from the mirror set — not representable in the XYZ chain). public const string RotaryUnsupportedId = \"HeidenhainMirror--RotaryUnsupported\" Field Value string SectionKey Root-section key of the modal mirror set: {“Axes”: [...]}, the letters currently mirrored (empty = mirror off). Written on every block once the program has touched G28, carried by this syntax's own single-step lookback (the DatumShift pattern). public const string SectionKey = \"MirrorImage\" Field Value string TransformSource ProgramToMcTransform source name of the mirror entry. Always the chain's first entry (this syntax runs ahead of every other transform writer). public const string TransformSource = \"MirrorImage\" Field Value string ValuedUnsupportedId Diagnostic id: the Fanuc-shaped valued statement (consumed with zero mirror effect). public const string ValuedUnsupportedId = \"HeidenhainMirror--ValuedUnsupported\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainMotionModeSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainMotionModeSyntax.html",
    "title": "Class HeidenhainMotionModeSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainMotionModeSyntax Namespace Hi.NcParsers.LogicSyntaxs.Heidenhain Assembly HiMech.dll Heidenhain-specific: maps the klartext L statement marker (written by HeidenhainLSyntax) onto the shared ISO motion-mode vocabulary. An L block carrying the one-shot FMAX flag becomes a rapid (G00) block; every other L block is a feed move (G01) driven by the modal feedrate. The injected G00/G01 flag is consumed downstream exactly like a DIN/ISO block — by LinearMotionSyntax on ordinary moves and by MachineCoordSelectSyntax on machine-coordinate (M91) moves — so no shared syntax needs Heidenhain-specific behavior. FMAX is one-shot on the real TNC: because every klartext motion is an L statement and this syntax stamps a mode per statement, the rapid mode never leaks into the next block — the following L without FMAX is stamped G01 again. FAUTO (feed from cycle) is consumed as a feed move. Must be placed at the top of the Logic bundle, before MachineCoordSelectSyntax and LinearMotionSyntax. public class HeidenhainMotionModeSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainMotionModeSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Feed move — the L marker is consumed and G01 is appended to Flags: #BeforeBuild: { \"Parsing\": { \"L\": true, \"X\": 10 } } #AfterBuild: { \"Parsing\": { \"X\": 10, \"Flags\": [\"G01\"] } } Rapid move — the one-shot FMAX flag is consumed and G00 is appended: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"FMAX\"], \"L\": true, \"X\": 10 } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"G00\"], \"X\": 10 } } Non-L block — untouched: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M03\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\"] } } DIN/ISO numeric L (helix turn count / repeat word captured by the integer tag syntax in the same mixed-dialect list) — only the boolean statement marker written by HeidenhainLSyntax is a klartext L statement; the numeric record is left for CircularMotionSyntax: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G02\"], \"L\": 3, \"I\": 5 } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"G02\"], \"L\": 3, \"I\": 5 } } Constructors HeidenhainMotionModeSyntax() Initializes a new instance with default settings. public HeidenhainMotionModeSyntax() HeidenhainMotionModeSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainMotionModeSyntax(XElement src) Parameters src XElement Source XML element. Fields FautoFlag Feed-from-cycle flag; consumed as a feed move. public const string FautoFlag = \"FAUTO\" Field Value string FmaxFlag One-shot rapid flag on klartext motion statements. public const string FmaxFlag = \"FMAX\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainPathSmoothingSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainPathSmoothingSyntax.html",
    "title": "Class HeidenhainPathSmoothingSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainPathSmoothingSyntax Namespace Hi.NcParsers.LogicSyntaxs.Heidenhain Assembly HiMech.dll Heidenhain-specific: consumes the structured CYCL DEF 32 TOLERANCE record (HeidenhainToleranceCyclSyntax) into the shared modal PathSmoothing section (tracked by the Logic ModalCarry): a positive tolerance arms smoothing ({IsEnabled:true, Term:“CYCL DEF 32”, Tolerance, HscMode?, Ta?}); a bare or zero-tolerance cycle cancels it. Untouched blocks are left to ModalCarry; the stream's first block seeds a conservative {IsEnabled:false} (Siemens sibling shape). Replaces the dead FanucPathSmoothingSyntax in the Heidenhain list (it read Parsing[“G05.1”], which no Heidenhain capture produces). public class HeidenhainPathSmoothingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainPathSmoothingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainPathSmoothingSyntax() Initializes a new instance with default settings. public HeidenhainPathSmoothingSyntax() HeidenhainPathSmoothingSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainPathSmoothingSyntax(XElement src) Parameters src XElement Source XML element. Fields Term Term recorded when CYCL DEF 32 owns the path-smoothing state. public const string Term = \"CYCL DEF 32\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainPivotTransformationSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainPivotTransformationSyntax.html",
    "title": "Class HeidenhainPivotTransformationSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainPivotTransformationSyntax Namespace Hi.NcParsers.LogicSyntaxs.Heidenhain Assembly HiMech.dll Heidenhain pivot gate over the shared engine (PivotTransformUtil): writes the PivotTransformSource entry on blocks where commanded XYZ needs the Pn→MC kinematic rigid transform — an active tilted plane (HeidenhainPlaneTiltSyntax's PLANE SPATIAL term, or a mixed-dialect G68/G68.2 term), an active RTCP modal (RtcpTerms on the ToolHeightCompensation section — the term check covers RTCP blocks whose rotary state is stable, which the Dynamic-entry branch alone would miss), or a Dynamic chain entry. The third sibling gate after PivotTransformationSyntax (ISO/Fanuc) and SiemensPivotTransformationSyntax; all write the identical JSON vocabulary through the shared engine and only one gate is registered per brand pipeline. Heidenhain has no plain-geometry-frame exclusion (klartext datum shifts use their own chain sources, never TiltTransform). Same chain-position contract: after all Pn-frame writers, so the PivotTransform entry lands last. public class HeidenhainPivotTransformationSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainPivotTransformationSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Real-kinematics cases below wire TestDeps.CodeKinematics with the default chain code [O][Z][A][w];[O][Y][X][B][S][t] — a table-A / head-B 5-axis machine (see PivotTransformationSyntax's corpus notes for the zero-offset chain caveats). Plain-mode skip — no tilt, no RTCP: untouched. #BeforeBuild: {} #AfterBuild: {} Indexed rotary without tilt/RTCP (the inactive G69 sentinel) — plain mode, the gate must not fold the pivot: #BeforeBuild: { \"TiltTransform\": { \"Term\": \"G69\" }, \"MachineCoordinateState\": { \"A\": 45 } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"G69\" }, \"MachineCoordinateState\": { \"A\": 45 } } Active M128 RTCP signalled by the ToolHeightCompensation term — the TestDeps.Kinematics stub makes the engine's pivot matrix collapse to identity; no Dynamic entry exists (stable rotary), so the entry stays Static — the branch the Dynamic-only detection would miss: #BeforeBuild: { \"ToolHeightCompensation\": { \"Offset_mm\": 50, \"Term\": \"M128\", \"OffsetId\": 1 } } #AfterBuild: { \"ToolHeightCompensation\": { \"Offset_mm\": 50, \"Term\": \"M128\", \"OffsetId\": 1 }, \"ProgramToMcTransform\": [ { \"Source\": \"PivotTransform\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } Active PLANE SPATIAL with an indexed table angle — real kinematics: the engine folds the table-A Rx(45°) rigid matrix, the same math the ISO sibling produces for G68.2: #BeforeBuild: { \"TiltTransform\": { \"Term\": \"PLANE SPATIAL\" }, \"MachineCoordinateState\": { \"A\": 45 } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"PLANE SPATIAL\" }, \"MachineCoordinateState\": { \"A\": 45 }, \"ProgramToMcTransform\": [ { \"Source\": \"PivotTransform\", \"Kind\": \"Static\", \"Mat4d\": [ 1, 0, 0, 0, 0, 0.7071067811865475, -0.7071067811865475, 0, 0, 0.7071067811865475, 0.7071067811865475, 0, 0, 0, 0, 1 ] } ] } Constructors HeidenhainPivotTransformationSyntax() Initializes a new instance with default settings. public HeidenhainPivotTransformationSyntax() HeidenhainPivotTransformationSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainPivotTransformationSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainPlaneTiltSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainPlaneTiltSyntax.html",
    "title": "Class HeidenhainPlaneTiltSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainPlaneTiltSyntax Namespace Hi.NcParsers.LogicSyntaxs.Heidenhain Assembly HiMech.dll Heidenhain PLANE consumer — the Heidenhain sibling of IsoG68p2TiltSyntax (Fanuc G68.2) and SiemensCycle800TiltSyntax both XmlDocs promise. PLANE SPATIAL — composes the tilted work plane Rx(SPA)·Ry(SPB)·Rz(SPC) (row-vector, degrees; the HardNc oracle's HeidenhainPlaneSpatialArg matrix verbatim) into ProgramToMcTransform as the shared TransformSource entry with Term = \"PLANE SPATIAL\". MOVE / TURN — the implicit rotary positioning (the CYCLE800 \"G53.1 half\"): with IMachineKinematics wired the plane orientation is solved to machine ABC (full-orientation IK first so a pure in-plane SPC under TABLE ROT still turns the table; tool-axis-normal fallback for machines with fewer rotary DOF; no identity short-circuit — the explicit zero-angle PLANE SPATIAL SPA+0 SPB+0 SPC+0 TURN is the klartext idiom for returning the rotaries to 0, oracle parity) and written into MachineCoordinateState plus a non-modal MotionEvent with Term = \"PLANE SPATIAL\". MOVE's DIST (tool retract radius during the swivel) and the TCP-preserving XYZ compensation are recorded but not simulated — the machine XYZ stays at the previous position like TURN, a transient-only divergence from the HardNc oracle (endpoints re-anchor at the next commanded point); MOVE's F is recorded on the event as MoveFeedrate. COORD ROT is honored only when the plane rotates purely about the tool axis (ToolAxisDirection, TNC manual rule; HardNc parity): the coordinate system rotates and the rotaries stay. Any other rotation — or TABLE ROT, or neither word — positions the rotary axes on MOVE/TURN. SEQ± is recorded in the section; when the IK solution's master rotary (first declared rotary axis) violates an explicit SEQ preference the preference is not applied and Coord-Tilt--007 warns (solution-family selection is not modeled; the HardNc ±2π window wrap would be undone by McAbcCyclicPathSyntax's shortest-cyclic tail pass, and the corpus never exercises SEQ with MOVE/TURN). PLANE RESET — the shared inactive sentinel (Term = \"G69\" + identity entry). The rotary axes are not re-positioned on reset (CYCLE800 cancel precedent; corpus programs follow with explicit rotary moves). PLANE VECTOR / PROJECTED / EULER / POINTS / RELATIV / AXIAL — recognized-but-not-simulated: consumed, HeidenhainPlane--Unsupported warns, and the previous tilt state carries unchanged (the HardNc oracle instead reuses a stale spatial arg here — SoftNc deliberately exceeds it). Owns the once-per-block TiltTransform modal carry for the Heidenhain list (CarryForwardFromPrevious(LazyLinkedListNode<SyntaxPiece>, JsonObject)). Must run before ToolHeightOffsetSyntax / HeidenhainToolOffsetSyntax (their translation follows the tilt entry's normal — the oracle's tool-normal-tiltable rule) and before McAbcSyntax / the coordinate-offset syntaxes (chain order: tilt entry ahead of CoordinateOffset, mirroring the Siemens frame slot; implicit MC rotary values must land before McAbc's per-axis lookback). public class HeidenhainPlaneTiltSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainPlaneTiltSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples PLANE RESET — the shared inactive sentinel: #BeforeBuild: { \"Parsing\": { \"PLANE\": { \"Mode\": \"RESET\", \"Positioning\": \"STAY\" } } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"G69\" }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } PLANE SPATIAL with STAY — tilt only, no rotary positioning, no kinematics needed. SPA+30 gives Rx(30°) (row-vector; the HardNc Rx(SPA)·Ry(SPB)·Rz(SPC) matrix): #BeforeBuild: { \"Parsing\": { \"PLANE\": { \"Mode\": \"SPATIAL\", \"SPA\": 30, \"SPB\": 0, \"SPC\": 0, \"Positioning\": \"STAY\" } } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"PLANE SPATIAL\", \"SPA\": 30, \"SPB\": 0, \"SPC\": 0, \"Positioning\": \"STAY\" }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [ 1, 0, 0, 0, 0, 0.8660254037844387, 0.49999999999999994, 0, 0, -0.49999999999999994, 0.8660254037844387, 0, 0, 0, 0, 1 ] } ] } The turbine STAY form — SEQ and TABLE ROT recorded; angles compose Rx(-77.516°)·Rz(-10.365°); machine coordinates untouched: #BeforeBuild: { \"Parsing\": { \"PLANE\": { \"Mode\": \"SPATIAL\", \"SPA\": -77.516, \"SPB\": 0, \"SPC\": -10.365, \"SEQ\": \"-\", \"Rot\": \"TABLE\", \"Positioning\": \"STAY\" } } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"PLANE SPATIAL\", \"SPA\": -77.516, \"SPB\": 0, \"SPC\": -10.365, \"SEQ\": \"-\", \"Rot\": \"TABLE\", \"Positioning\": \"STAY\" }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [ 0.9836815601642315, -0.17991828198619333, 0, 0, 0.03889239026499967, 0.21263946449492488, -0.9763564103946809, 0, 0.1756643679644177, 0.9604237970533884, 0.21616697222566972, 0, 0, 0, 0, 1 ] } ] } Recognized-but-not-simulated mode — consumed, warned, previous tilt (here: none → the G69 default stamp) carries unchanged: #BeforeBuild: { \"Parsing\": { \"PLANE\": { \"Mode\": \"VECTOR\", \"BX\": 1, \"BY\": 0, \"BZ\": 0, \"NX\": 0, \"NY\": 0, \"NZ\": 1, \"Positioning\": \"STAY\" } } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"G69\" } } Constructors HeidenhainPlaneTiltSyntax() Initializes a new instance with default settings. public HeidenhainPlaneTiltSyntax() HeidenhainPlaneTiltSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainPlaneTiltSyntax(XElement src) Parameters src XElement Source XML element. Fields MoveFeedrateKey MotionEvent key recording the MOVE repositioning feed (recorded only). public const string MoveFeedrateKey = \"MoveFeedrate\" Field Value string SpatialTerm TiltTransform term written for an active PLANE SPATIAL plane (also the implicit positioning MotionEvent term). public const string SpatialTerm = \"PLANE SPATIAL\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainProgramHeaderSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainProgramHeaderSyntax.html",
    "title": "Class HeidenhainProgramHeaderSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainProgramHeaderSyntax Namespace Hi.NcParsers.LogicSyntaxs.Heidenhain Assembly HiMech.dll Heidenhain-specific: consumes the Parsing.PGM record (BEGIN|END PGM name MM|INCH) — the unit word is pushed into Parsing.Flags for the UnitModeSyntax instance configured with InchCodes=[“INCH”], MetricCodes=[“MM”] (which must run after this syntax), and END PGM writes the shared one-shot ProgramEnd section (existence-checked by its consumers exactly like M30). Consuming PGM also removes the program-header unconsumed noise every klartext file used to emit. public class HeidenhainProgramHeaderSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainProgramHeaderSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples BEGIN header — unit word relocated to Flags, PGM consumed: #BeforeBuild: { \"Parsing\": { \"PGM\": { \"Command\": \"BEGIN\", \"Name\": \"TEST\", \"Unit\": \"MM\" } } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"MM\"] } } END footer — additionally writes the shared ProgramEnd section: #BeforeBuild: { \"Parsing\": { \"PGM\": { \"Command\": \"END\", \"Name\": \"TEST\", \"Unit\": \"MM\" } } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"MM\"] }, \"ProgramEnd\": { \"Term\": \"END PGM\" } } Constructors HeidenhainProgramHeaderSyntax() Initializes a new instance with default settings. public HeidenhainProgramHeaderSyntax() HeidenhainProgramHeaderSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainProgramHeaderSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainRadiusCompSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainRadiusCompSyntax.html",
    "title": "Class HeidenhainRadiusCompSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainRadiusCompSyntax Namespace Hi.NcParsers.LogicSyntaxs.Heidenhain Assembly HiMech.dll Heidenhain-specific: maps the klartext radius-compensation words captured by HeidenhainLSyntax (RL/RR/R0 boolean Parsing-root records) onto the shared vocabulary consumed by the radius-compensation pass: RL → Parsing.G41 {D: toolId}, RR → G42, R0 → G40 flag. The offset id is the current tool number (klartext has no D word; IToolOffsetConfig documents the offset id as the Heidenhain tool number), resolved by walking back to the most recent ToolChange section. A missing or non-numeric tool id degrades to mode-only injection (radius 0 — the compensation pass records the state but applies no geometric offset) with an RadiusComp–ToolUnresolved warning. Must run before the PostLogic radius-compensation pass (any Logic position works — PostLogic sees completed Logic output) and after HeidenhainToolChangeSyntax so a same-block TOOL CALL is visible. public class HeidenhainRadiusCompSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainRadiusCompSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples RL with a previous tool — G41 with the tool number as offset id: #Previous: { \"ToolChange\": { \"ToolId\": 2, \"IsChange\": true, \"Term\": \"TOOL CALL\" } } #BeforeBuild: { \"Parsing\": { \"RL\": true, \"X\": 10 } } #AfterBuild: { \"Parsing\": { \"X\": 10, \"G41\": { \"D\": 2 } } } R0 — compensation off maps to the G40 flag: #BeforeBuild: { \"Parsing\": { \"R0\": true, \"X\": 10 } } #AfterBuild: { \"Parsing\": { \"X\": 10, \"Flags\": [\"G40\"] } } Constructors HeidenhainRadiusCompSyntax() Initializes a new instance with default settings. public HeidenhainRadiusCompSyntax() HeidenhainRadiusCompSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainRadiusCompSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainRtcpSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainRtcpSyntax.html",
    "title": "Class HeidenhainRtcpSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainRtcpSyntax Namespace Hi.NcParsers.LogicSyntaxs.Heidenhain Assembly HiMech.dll Heidenhain RTCP (M128/M129, FUNCTION TCPM/FUNCTION RESET TCPM): the Heidenhain sibling of G43p4RtcpSyntax and SiemensTraoriSyntax. While RTCP is active the IToolHeightCompensationDef section carries the activating term (M128Term or TcpmTerm) and the ToolHeightCompensation chain entry becomes a tool-normal · offset translation at the block endpoint ABC (MakeToolHeightMat(IMachineKinematics, Vec3d, double)), tagged KindDynamic when the rotary state changes across the block — the signal that routes the block to ClLinear per-step IK. Tool length ownership stays with the TOOL CALL machinery (HeidenhainToolOffsetSyntax — table height + DL, which runs earlier in the bundle): activation adopts the compensation already resolved on this or the previous block and records the adopted owner in PriorTermKey; a TOOL CALL during the modal re-takes the section with the fresh offset; M129 / FUNCTION RESET TCPM hands the section back to the recorded owner (default Term — klartext tool-length compensation survives RTCP deactivation). The TOOL CALL Delta_mm (DL) rides along so the hand-back restores it. A deactivation with no active RTCP (the corpus' ubiquitous program-head M129) is consumed silently. Same-block contradiction (M128 with M129): the off state wins conservatively (the P1 rule, kept for continuity). The M128 feed limit (M128 F6000., or an FQn token the evaluator could not resolve) is recorded on the section as FeedLimitKey — recorded, not simulated. FUNCTION TCPM behavior arguments are recorded by the parsing syntax and warn Tcpm--ArgsNotSimulated on activation. Must run after ToolHeightOffsetSyntax / HeidenhainToolOffsetSyntax and the coordinate-offset syntaxes (mirroring the Fanuc G43.4 / Siemens TRAORI slot) and before HeidenhainPivotTransformationSyntax, whose gate recognizes the RtcpTerms and folds the kinematic pivot. Silently degrades to a plain UnitZ · offset translation when IMachineKinematics is absent. public class HeidenhainRtcpSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainRtcpSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Activation adopting the TOOL CALL compensation resolved earlier on the same block (feed limit recorded; owner recorded for hand-back): #BeforeBuild: { \"Parsing\": { \"M128\": { \"F\": 6000 } }, \"ToolHeightCompensation\": { \"Offset_mm\": 120.5, \"Term\": \"TOOL CALL\", \"OffsetId\": 2, \"Delta_mm\": 0.5 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,120.5,1] } ] } #AfterBuild: { \"ToolHeightCompensation\": { \"Offset_mm\": 120.5, \"Term\": \"M128\", \"OffsetId\": 2, \"PriorTerm\": \"TOOL CALL\", \"Delta_mm\": 0.5, \"FeedLimit\": 6000 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,120.5,1] } ] } Modal continuation — no word on the block; the snapshot is carried and the entry rebuilt: #Previous: { \"ToolHeightCompensation\": { \"Offset_mm\": 120.5, \"Term\": \"M128\", \"OffsetId\": 2, \"PriorTerm\": \"TOOL CALL\", \"Delta_mm\": 0.5, \"FeedLimit\": 6000 } } #BeforeBuild: {} #AfterBuild: { \"ToolHeightCompensation\": { \"Offset_mm\": 120.5, \"Term\": \"M128\", \"OffsetId\": 2, \"PriorTerm\": \"TOOL CALL\", \"Delta_mm\": 0.5, \"FeedLimit\": 6000 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,120.5,1] } ] } M129 hand-back — the section returns to the recorded owner and the plain translation entry is rebuilt; TOOL CALL modal re-resolution resumes on following blocks: #Previous: { \"ToolHeightCompensation\": { \"Offset_mm\": 120.5, \"Term\": \"M128\", \"OffsetId\": 2, \"PriorTerm\": \"TOOL CALL\", \"Delta_mm\": 0.5, \"FeedLimit\": 6000 } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M129\"] } } #AfterBuild: { \"ToolHeightCompensation\": { \"Offset_mm\": 120.5, \"Term\": \"TOOL CALL\", \"OffsetId\": 2, \"Delta_mm\": 0.5 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,120.5,1] } ] } Defensive M129 with no active RTCP (every GPE program head) — consumed silently, nothing written: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M129\"] } } #AfterBuild: {} Bare activation with no prior compensation and no kinematics — the section is taken with zero offset and the entry collapses to identity: #BeforeBuild: { \"Parsing\": { \"M128\": { \"Bare\": true } } } #AfterBuild: { \"ToolHeightCompensation\": { \"Offset_mm\": 0, \"Term\": \"M128\", \"OffsetId\": 0 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } The first block after a program end — #Previous: carries the ProgramEnd section (END PGM, M2 or M30) next to the still-active M128. This is the reset edge (ProgramEndSyntax): the TNC resets M128 / FUNCTION TCPM at program end while the TOOL CALL length compensation stays, so the block gets exactly the M129 hand-back: #Previous: { \"ProgramEnd\": { \"Term\": \"END PGM\" }, \"ToolHeightCompensation\": { \"Offset_mm\": 120.5, \"Term\": \"M128\", \"OffsetId\": 2, \"PriorTerm\": \"TOOL CALL\", \"Delta_mm\": 0.5, \"FeedLimit\": 6000 } } #BeforeBuild: {} #AfterBuild: { \"ToolHeightCompensation\": { \"Offset_mm\": 120.5, \"Term\": \"TOOL CALL\", \"OffsetId\": 2, \"Delta_mm\": 0.5 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,120.5,1] } ] } Constructors HeidenhainRtcpSyntax() Initializes a new instance with default settings. public HeidenhainRtcpSyntax() HeidenhainRtcpSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainRtcpSyntax(XElement src) Parameters src XElement Source XML element. Fields FeedLimitKey Section key recording the M128 feed limit (compensating-movement feed cap) — recorded, not simulated. public const string FeedLimitKey = \"FeedLimit\" Field Value string M128Term Ownership term while the classic M128 RTCP is active. public const string M128Term = \"M128\" Field Value string RtcpTerms The Heidenhain RTCP terms — the brand vocabulary the pivot gate (HeidenhainPivotTransformationSyntax) recognizes on the ToolHeightCompensation section. public static readonly string[] RtcpTerms Field Value string[] TcpmTerm Ownership term while FUNCTION TCPM RTCP is active. public const string TcpmTerm = \"FUNCTION TCPM\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress IsRtcpTerm(string) True when term is a Heidenhain RTCP owner term. public static bool IsRtcpTerm(string term) Parameters term string Returns bool MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainStockDeclarationSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainStockDeclarationSyntax.html",
    "title": "Class HeidenhainStockDeclarationSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainStockDeclarationSyntax Namespace Hi.NcParsers.LogicSyntaxs.Heidenhain Assembly HiMech.dll Heidenhain-specific: consumes the Parsing[“BLK FORM”] record (workpiece blank declaration, present in virtually every klartext file) into the brand-neutral StockDeclaration section — recognized and recorded, not simulated. The simulation stock always comes from the project's own workpiece setup, mirroring the HardNc oracle which recognizes-and-skips the same lines; the structured record keeps the declared blank readable for a future stock consumer without feeding geometry today. public class HeidenhainStockDeclarationSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainStockDeclarationSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Corner declaration (BLK FORM 0.1) — record relocated, Parsing consumed: #BeforeBuild: { \"Parsing\": { \"BLK FORM\": { \"Type\": \"0.1\", \"Axis\": \"Z\", \"X\": 0, \"Y\": 0, \"Z\": -40 } } } #AfterBuild: { \"StockDeclaration\": { \"Term\": \"BLK FORM\", \"Type\": \"0.1\", \"Axis\": \"Z\", \"X\": 0, \"Y\": 0, \"Z\": -40 } } Cylinder declaration: #BeforeBuild: { \"Parsing\": { \"BLK FORM\": { \"Type\": \"CYLINDER\", \"Axis\": \"Z\", \"R\": 50, \"L\": 105 } } } #AfterBuild: { \"StockDeclaration\": { \"Term\": \"BLK FORM\", \"Type\": \"CYLINDER\", \"Axis\": \"Z\", \"R\": 50, \"L\": 105 } } Constructors HeidenhainStockDeclarationSyntax() Initializes a new instance with default settings. public HeidenhainStockDeclarationSyntax() HeidenhainStockDeclarationSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainStockDeclarationSyntax(XElement src) Parameters src XElement Source XML element. Fields ParsingKey Parsing key produced by the BLK FORM parsing syntax. public const string ParsingKey = \"BLK FORM\" Field Value string SectionKey Key of the section written to the piece root. public const string SectionKey = \"StockDeclaration\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainToolChangeSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainToolChangeSyntax.html",
    "title": "Class HeidenhainToolChangeSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainToolChangeSyntax Namespace Hi.NcParsers.LogicSyntaxs.Heidenhain Assembly HiMech.dll Heidenhain-specific: consumes the Parsing[“TOOL CALL”] record (written by HeidenhainToolCallSyntax) into the shared SectionName section so ToolChangeSemantic fires the tooling act. A klartext TOOL CALL always performs the change — no separate M06 trigger exists — so IsChangeKey is always true with Term = “TOOL CALL”. The spindle-speed word (S) is relocated to the root of Parsing so the shared SpindleSpeedSyntax — which must run after this syntax in the Logic bundle — records it modally. Numeric tool ids are written as ints (the act chain is int-keyed); non-numeric ids stay strings and resolve (or warn) at the semantic layer. P0 limits recorded as diagnostics: non-Z tool axis (ToolChange--AxisUnsupported), non-zero DL/DR deltas (ToolChange--DeltaUnsupported; zero deltas are consumed silently), and a TOOL CALL without a tool id (ToolChange--MissingToolId, e.g. a variable tool number the parser could not capture). Known P2 limitation: a quoted tool NAME that happens to spell a Q token (TOOL CALL \"Q1\" Z) loses its quotes at capture, so the evaluator substitutes the Q parameter's value and the numeric branch below treats it as a tool number. Corpus-zero (real names are \"B40R\"-style); fixing it needs the capture to preserve the quoted-ness, which would change the P0-pinned record shape. public class HeidenhainToolChangeSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainToolChangeSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Numeric tool call — id becomes an int, S is relocated to the Parsing root for the shared spindle syntax: #BeforeBuild: { \"Parsing\": { \"TOOL CALL\": { \"Axis\": \"Z\", \"S\": \"4000\", \"T\": \"2\" } } } #AfterBuild: { \"Parsing\": { \"S\": 4000 }, \"ToolChange\": { \"ToolId\": 2, \"IsChange\": true, \"Term\": \"TOOL CALL\" } } Named tool with zero deltas — the name carries as a string ToolId; literal DL/DR ride in the section (DL feeds the length compensation; a non-zero DR would warn): #BeforeBuild: { \"Parsing\": { \"TOOL CALL\": { \"Axis\": \"Z\", \"S\": \"1200\", \"DL\": \"+0.0\", \"DR\": \"+0.0\", \"T\": \"B40R\" } } } #AfterBuild: { \"Parsing\": { \"S\": 1200 }, \"ToolChange\": { \"ToolId\": \"B40R\", \"IsChange\": true, \"Term\": \"TOOL CALL\", \"DL\": 0, \"DR\": 0 } } Constructors HeidenhainToolChangeSyntax() Initializes a new instance with default settings. public HeidenhainToolChangeSyntax() HeidenhainToolChangeSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainToolChangeSyntax(XElement src) Parameters src XElement Source XML element. Fields Term Value written to TermKey for klartext tool calls. public const string Term = \"TOOL CALL\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainToolOffsetSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.HeidenhainToolOffsetSyntax.html",
    "title": "Class HeidenhainToolOffsetSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainToolOffsetSyntax Namespace Hi.NcParsers.LogicSyntaxs.Heidenhain Assembly HiMech.dll Heidenhain-specific: klartext TOOL CALL always applies tool-length compensation (there is no cancel word — HardNc compensates unconditionally). On TOOL CALL blocks the effective height = GetToolHeightOffset_mm(int)(tool id) + the TOOL CALL's DL delta; the shared ToolHeightCompensation section is written (Term = “TOOL CALL”, OffsetId = tool id — the offset id is documented as the Heidenhain tool number) and the translation composes into the transform chain via the shared ToolHeightCompensation source (mutual exclusion with the ISO G43 sibling by same-source replace). Modal: on following blocks the section is re-resolved per block from the table (mirroring the Siemens D sibling — give-way when a same block ISO term took ownership; carry Term/OffsetId/Delta_mm otherwise). Must sit after ToolHeightOffsetSyntax (the ISO anchor — last writer wins on mixed-dialect blocks) and after HeidenhainToolChangeSyntax (reads its ToolChange section), before the pivot/tilt syntaxes. public class HeidenhainToolOffsetSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainToolOffsetSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples TOOL CALL block — height from the injected tool-offset table (tool 2 = 120 mm) plus DL 0.5; the G49 sentinel written by the ISO anchor is overwritten: #BeforeBuild: { \"ToolChange\": { \"ToolId\": 2, \"IsChange\": true, \"Term\": \"TOOL CALL\", \"DL\": 0.5 }, \"ToolHeightCompensation\": { \"Offset_mm\": 0, \"Term\": \"G49\", \"OffsetId\": 0 } } #AfterBuild: { \"ToolChange\": { \"ToolId\": 2, \"IsChange\": true, \"Term\": \"TOOL CALL\", \"DL\": 0.5 }, \"ToolHeightCompensation\": { \"Offset_mm\": 120.5, \"Term\": \"TOOL CALL\", \"OffsetId\": 2, \"Delta_mm\": 0.5 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,120.5,1] } ] } Constructors HeidenhainToolOffsetSyntax() Initializes a new instance with default settings. public HeidenhainToolOffsetSyntax() HeidenhainToolOffsetSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainToolOffsetSyntax(XElement src) Parameters src XElement Source XML element. Fields DeltaKey Section key carrying the TOOL CALL DL delta so modal re-resolution keeps it. public const string DeltaKey = \"Delta_mm\" Field Value string Term Ownership term recorded in the shared section. public const string Term = \"TOOL CALL\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Heidenhain.html",
    "title": "Namespace Hi.NcParsers.LogicSyntaxs.Heidenhain | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.LogicSyntaxs.Heidenhain Classes HeidenhainCannedCycleSyntax Bridges the klartext machining-cycle vocabulary onto the shared ISO canned-cycle machinery. Owns the self-carrying MachiningCycleDef store (single-step lookback + rewrite on every block — the P1 datum-shift pattern) and the call-once vs modal split: Definition (Parsing.MachiningCycle from HeidenhainMachiningCycleSyntax): mapped to ISO slots at definition time — 200 → G81/G82/G83 (peck when Q202 < |Q201|), 232 → G81 (start point Q225/Q226/Q227, end Q386, feed Q207), 251/252/253 → G81/G83 (surface Q203, clearance Q200, depth Q201, plunge feed Q206, step-down Q202). A definition never executes by itself. Unsupported numbers (19, …) are recognized-but-not-simulated: consumed whole with HeidenhainCycl--Unsupported, stored unarmable so a later call warns instead of moving. Required parameters that are missing or non-literal make the store unarmable with HeidenhainCycl--ParamsNotLiteral. Call-once (CYCL CALL [POS] record from HeidenhainCyclCallSyntax, or an M99 flag on a positioning block — the TNC block-wise call, unrelated to the Fanuc return M99): writes the mapped cycle as a direct Parsing.G8x sub-section on this block, which CannedCycleResolveSyntax resolves and the shared cycle syntaxes expand into a CompoundMotion. POS coordinates override the stored X/Y; the POS Z is a pre-position, recorded but never fed into the hole-bottom slot. Words carrying the klartext incremental stamp — POS words (CYCL CALL POS IX+20) and root words on the M99/M89 forms (L IX+20 R0 FMAX M99 — the manual's hole-group shape), see HeidenhainIncrementalAxisWordUtil — are resolved against the last programmed position here, on the spot: this syntax runs ahead of the shared IncrementalResolveSyntax and consumes the words, so the per-word override would otherwise be lost and the hole drilled at the raw distance. The ISO modal-lookback branch is deliberately bypassed: it has no positioning gate, so an armed CannedCycle would re-execute on flag-only blocks — wrong for klartext. Modal (M89): sets Modal; each subsequent block carrying root axis words (and no CArc statement) fires the same direct-section path with the block's X/Y consumed into the cycle. M99 fires once and clears the modality; a new CYCL DEF replaces the store. Seal: on every non-firing block whose previous block carries an active CannedCycle term, a G80 flag is injected (the P0 G00/G01 injection pattern) so CannedCycleResolveSyntax writes the cancel sentinel — the one-shot execution never leaks into ISO modal repetition. Known divergences (recorded, corpus-benign): the cycle's mapped feed enters the modal Feedrate section during expansion (ISO semantics; the Siemens MCALL precedent accepts the same leak); the final retract plane is the ISO G98 initial level, not Q204's second set-up clearance (Q204 is recorded in the definition store only) — and an incremental Z word chained off a cycle end (L IZ.., CYCL CALL POS IZ..) inherits that gap, since it adds to the simulated end plane. Must run after the tilt/RTCP family and immediately before CannedCycleResolveSyntax. HeidenhainCircleCenterSyntax Heidenhain-specific: turns the Parsing.CC record into the modal HeidenhainCircleCenter { X, Y, Z? } section (absolute program coordinates). Self-carrying every block (PlaneSelect pattern — detected ?? previous), so the arc syntax's single-step read always works without ModalCarry involvement; a CC with partial axes merges the missing components from the previous center. Must run before HeidenhainCircularMotionSyntax. A CC stating no coordinates (BareKey) takes the last programmed position, read at THIS block and frozen into the section — the documented klartext form whose purpose is that the tool moves away before the arc, so a later read at the arc block would take the arc's own start point instead. Being a definition, it replaces the modal center rather than inheriting the previous one's axes. HeidenhainCircularMotionSyntax Heidenhain circular motion — the Klartext half of the brand's two arc syntaxes. The shared CircularMotionSyntax (with IsIjkAbsolute set) runs right after it for the DIN/ISO dialect: the two gates are per-block exclusive (a klartext arc has CArc and no I/J/K/R; an ISO arc the reverse) and both honor the single Group 01 MotionEvent slot. Gated by the Parsing.C statement marker (klartext arcs carry no G02/G03 and no modal arc continuation): the endpoint comes from the block's resolved ProgramXyz, the center from the modal HeidenhainCircleCenterSyntax section, and the direction from DR- (CW → G02) / DR+ (CCW → G03). A closed arc on the active plane is a full circle. Two malformed shapes warn and degrade to the modal linear move to the endpoint (chord): a missing DR (Arc-DR–Missing), and a center sitting on the arc's own start point (Arc-CircleCenter–OnStartPoint) — a zero begin radius that emits no motion act at all while the endpoint still advances the modal position. A CC that states only ONE in-plane coordinate is not degraded: that arc has real geometry, and only the optimizer's splition refuses it (see below). The event is stamped with its CenterSource (ModalCircleCenter / StartPoint) because a C block never states its center — the NcOpt splition write-back reads it. HeidenhainCoordinateOffsetSyntax Heidenhain-specific: resolves coordinate offset from CYCL DEF 247 (Datum Preset) and CYCL DEF 7 (Datum Shift). CYCL DEF 247 Q339=N: selects datum preset table entry N — written to the shared CoordinateOffset section (kept alive modally by IsoCoordinateOffsetSyntax via HeidenhainDatumTable synthetic-id resolution). CYCL DEF 7 (#N table row or direct X/Y/Z) is additive on top of the active preset (TNC semantics; HardNc oracle composes -preset + shift): it is written to its own DatumShift section with a separate ProgramToMcTransform entry (DatumShiftTransformSource) so preset and shift compose in the transform chain instead of replacing each other. The shift is carried modally by this syntax itself: on blocks without a CYCL DEF, a numbered row re-resolves from the table and a direct shift carries its values forward. Cancelling is a zero shift (CYCL DEF 7.1 X+0 Y+0 Z+0). A klartext I-prefixed word (CYCL DEF 7.2 IY+5, kept under its prefixed key in the record by the parser) shifts BY the value on top of the shift active on the previous block — the manual's \"incremental values are always referenced to the datum which was last valid, this can be a datum which has already been shifted\" — never a distance from the tool position, which is why it bypasses the PositioningOverride / IncrementalResolveSyntax route entirely. For DIN/ISO compatibility (G54–G59), use IsoCoordinateOffsetSyntax in addition to this syntax in the Heidenhain syntax list. Uses replace-by-source so both syntaxes coexist without double-composing. HeidenhainCyclePrePositionSyntax Lifts the expanded cycle's initial plane to the recorded TNC pre-position Z. A CYCL CALL POS … Z±n (and an M99/M89 positioning block's own Z word) positions the spindle BEFORE the cycle runs; the shared ISO expansion instead anchors its initial plane — the first rapid and the G98 final retract — on the PREVIOUS block's Z. Left unlifted, a call that climbs to a safe Z before drilling would be simulated traversing at the stale old Z (phantom collisions through fixtures) and G98 would plunge the tool back to that stale Z after the hole. Mechanics: when the HeidenhainCyclCall record carries a numeric Z and a CompoundMotion was expanded, the first item (the initial-plane rapid — both shared cycle syntaxes emit it first) and, under G98, the final item and the block's final ProgramXyz are re-anchored to the pre-position Z. G99 finals (R-plane) are untouched. Runs after the shared cycle syntaxes and before HeidenhainCycleRetractSyntax (whose appended M140 retract builds on the lifted final point). HeidenhainCycleRetractSyntax Consumes the Parsing.M140 record that HeidenhainMFunctionSyntax deferred on a may-fire-cycle block — a CYCL CALL [POS] host (… M140 MB+n is a real house.H shape), an M99/M89 flag block, or any block under armed M89 modality. WriteCompoundMotion(JsonObject, string, JsonArray, Vec3d) destroys any pre-written MotionEvent, so the retract is appended after the cycle expansion instead: Cycle expanded — a rapid item to (final X, final Y, retract Z) is appended to the CompoundMotion items and the block's final ProgramXyz is lifted to the retract plane. The MB math is ResolveRetractTargetZ(JsonObject, Vec3d, List<INcDependency>, ISentenceCarrier, NcDiagnosticProgress) verbatim. The real TNC runs M140 at block start (retract, then position + cycle); appending it is a transient-only divergence — the endpoint chain re-anchors on the next command point (the P3 PLANE MOVE precedent) and the appended order is the safer trajectory. An F on the M140 is recorded on the item but the appended retract stays rapid (corpus M140-on-call blocks are all F-less). Cycle did not expand (call consumed without motion) — the plain HeidenhainMFunctionSyntax retract behavior runs here unchanged, so a fail-soft call never silently drops the retract. Must run after the shared cycle syntaxes (DrillingCycleSyntax/PeckDrillingCycleSyntax) and before McXyzSyntax. HeidenhainLnOrientationSyntax Heidenhain LN posture rules — the brand adapter between the Parsing.LN vector record (HeidenhainLnSyntax) and the shared OrientationVectorResolveSyntax. Applies the TNC640/TNC7 manual's rules verbatim: T vector present + M128/FUNCTION TCPM active → the tool axis is T (\"Tool keeps the set tool orientation\"). T absent + RTCP active → the tool axis is the surface normal N (\"the control maintains the tool perpendicular to the workpiece contour\"). RTCP inactive → the T vector is ignored, exactly like the control (\"the control ignores the direction vector T, even if it is defined in the LN block\") — diagnosed as Orientation-Vector--IgnoredNoTcpm, posture untouched. The chosen vector is written (verbatim within the unit-length tolerance; normalized with a diagnostic beyond it) to the brand-agnostic ToolOrientationKey section; the surface normal is always carried on SurfaceNormalKey — compensation along it (DR2 / 3D-ToolComp) is recognized, not simulated (SurfaceNormal--CompNotSimulated, first LN block of a run only). RTCP activity is judged dual-source — the same-block Parsing words (M128 / FUNCTION TCPM, before HeidenhainRtcpSyntax consumes them; the same-block on+off contradiction resolves off, the P1 rule) OR the most recent IToolHeightCompensationDef owner term — so an LN block that itself activates RTCP is not silently skipped. Must run after McAbcSyntax and before OrientationVectorResolveSyntax (the producer/consumer order) and before HeidenhainRtcpSyntax (which reads the resolved endpoint ABC for its Dynamic/Static marking). The vector is interpreted in the untilted program frame; combining LN with an active PLANE tilt is diagnosed (Orientation-Vector--TiltedFrameAssumed), not remapped. HeidenhainMFunctionSyntax Heidenhain-specific M-function semantics for the near-universal corpus family: M126/M127 — shortest-path rotary traverse on/off. Writes the modal RotaryWrap { Shortest } section consumed by McAbcCyclicPathSyntax (absent = shortest, the shared default); the Heidenhain preset's Logic ModalCarry tracks the section. M128/M129 — owned by HeidenhainRtcpSyntax since P3 (full RTCP on the ToolHeightCompensation section); this syntax no longer touches them. M140 MB — tool-axis retract. Executes a machine-coordinate move along +Z (the corpus machines are table-tilting, so the tool axis stays machine +Z; a head-machine generalization is a recorded P6 backlog item): MB+n retracts by n mm, MB MAX retracts to the positive Z stroke limit (IStrokeLimitConfig; unresolvable limit warns M140--NoStrokeLimit and skips). The retract runs at the modal feed (the statement's F is recorded on the MotionEvent as RetractFeedrate, not folded into the modal feedrate). Must run before McAbcCyclicPathSyntax (RotaryWrap) and before LinearMotionSyntax/McXyzSyntax (M140 occupies the block's MotionEvent). HeidenhainMirrorTransformSyntax Simulates the Heidenhain DIN/ISO G28 MIRROR IMAGE function (the CYCL DEF 8 twin): consumes the statement list HeidenhainMirrorImageSyntax recorded under Parsing.MirrorImage, keeps the modal mirror set in the root SectionKey section (each statement REPLACES the set — course 62192's four-quadrant idiom relies on G28 Y after G28 X Y leaving only Y mirrored; bare G28 resets), and writes the sign-flip matrix into ProgramToMcTransform as the TransformSource entry. Must run before every other transform writer (HeidenhainPlaneTiltSyntax downward) so the mirror entry is the chain's first — the mirror flips program coordinates about the current datum inside the active working plane, i.e. innermost: tilt, tool-height and coordinate-offset entries compose after it and are never themselves mirrored. Because every motion semantic resolves contours in program coordinates and maps each interpolated point through the composed chain (CreateProgramPosToMcFunc(LazyLinkedListNode<SyntaxPiece>, IMachineAxisConfig)), the arc-handedness flip (G02↔G03) and the radius-compensation side flip (G41↔G42) a real control performs under a single-axis mirror emerge from the pointwise mapping — no re-tagging of IsCcw or the compensation side happens, and none is needed. Two statement shapes stay recognized-but-not-simulated: a rotary axis letter (RotaryUnsupportedId — a rotary mirror is not representable in the XYZ transform chain; the letter is dropped from the set, the statement still replaces) and the Fanuc-shaped valued form (ValuedUnsupportedId — the manual's mirror idiom is bare letters, so G91 G28 X0 Y0 Z0 in a mislabeled .I file must not arm a full-XYZ mirror; the statement is consumed with zero effect). HeidenhainMotionModeSyntax Heidenhain-specific: maps the klartext L statement marker (written by HeidenhainLSyntax) onto the shared ISO motion-mode vocabulary. An L block carrying the one-shot FMAX flag becomes a rapid (G00) block; every other L block is a feed move (G01) driven by the modal feedrate. The injected G00/G01 flag is consumed downstream exactly like a DIN/ISO block — by LinearMotionSyntax on ordinary moves and by MachineCoordSelectSyntax on machine-coordinate (M91) moves — so no shared syntax needs Heidenhain-specific behavior. FMAX is one-shot on the real TNC: because every klartext motion is an L statement and this syntax stamps a mode per statement, the rapid mode never leaks into the next block — the following L without FMAX is stamped G01 again. FAUTO (feed from cycle) is consumed as a feed move. Must be placed at the top of the Logic bundle, before MachineCoordSelectSyntax and LinearMotionSyntax. HeidenhainPathSmoothingSyntax Heidenhain-specific: consumes the structured CYCL DEF 32 TOLERANCE record (HeidenhainToleranceCyclSyntax) into the shared modal PathSmoothing section (tracked by the Logic ModalCarry): a positive tolerance arms smoothing ({IsEnabled:true, Term:“CYCL DEF 32”, Tolerance, HscMode?, Ta?}); a bare or zero-tolerance cycle cancels it. Untouched blocks are left to ModalCarry; the stream's first block seeds a conservative {IsEnabled:false} (Siemens sibling shape). Replaces the dead FanucPathSmoothingSyntax in the Heidenhain list (it read Parsing[“G05.1”], which no Heidenhain capture produces). HeidenhainPivotTransformationSyntax Heidenhain pivot gate over the shared engine (PivotTransformUtil): writes the PivotTransformSource entry on blocks where commanded XYZ needs the Pn→MC kinematic rigid transform — an active tilted plane (HeidenhainPlaneTiltSyntax's PLANE SPATIAL term, or a mixed-dialect G68/G68.2 term), an active RTCP modal (RtcpTerms on the ToolHeightCompensation section — the term check covers RTCP blocks whose rotary state is stable, which the Dynamic-entry branch alone would miss), or a Dynamic chain entry. The third sibling gate after PivotTransformationSyntax (ISO/Fanuc) and SiemensPivotTransformationSyntax; all write the identical JSON vocabulary through the shared engine and only one gate is registered per brand pipeline. Heidenhain has no plain-geometry-frame exclusion (klartext datum shifts use their own chain sources, never TiltTransform). Same chain-position contract: after all Pn-frame writers, so the PivotTransform entry lands last. HeidenhainPlaneTiltSyntax Heidenhain PLANE consumer — the Heidenhain sibling of IsoG68p2TiltSyntax (Fanuc G68.2) and SiemensCycle800TiltSyntax both XmlDocs promise. PLANE SPATIAL — composes the tilted work plane Rx(SPA)·Ry(SPB)·Rz(SPC) (row-vector, degrees; the HardNc oracle's HeidenhainPlaneSpatialArg matrix verbatim) into ProgramToMcTransform as the shared TransformSource entry with Term = \"PLANE SPATIAL\". MOVE / TURN — the implicit rotary positioning (the CYCLE800 \"G53.1 half\"): with IMachineKinematics wired the plane orientation is solved to machine ABC (full-orientation IK first so a pure in-plane SPC under TABLE ROT still turns the table; tool-axis-normal fallback for machines with fewer rotary DOF; no identity short-circuit — the explicit zero-angle PLANE SPATIAL SPA+0 SPB+0 SPC+0 TURN is the klartext idiom for returning the rotaries to 0, oracle parity) and written into MachineCoordinateState plus a non-modal MotionEvent with Term = \"PLANE SPATIAL\". MOVE's DIST (tool retract radius during the swivel) and the TCP-preserving XYZ compensation are recorded but not simulated — the machine XYZ stays at the previous position like TURN, a transient-only divergence from the HardNc oracle (endpoints re-anchor at the next commanded point); MOVE's F is recorded on the event as MoveFeedrate. COORD ROT is honored only when the plane rotates purely about the tool axis (ToolAxisDirection, TNC manual rule; HardNc parity): the coordinate system rotates and the rotaries stay. Any other rotation — or TABLE ROT, or neither word — positions the rotary axes on MOVE/TURN. SEQ± is recorded in the section; when the IK solution's master rotary (first declared rotary axis) violates an explicit SEQ preference the preference is not applied and Coord-Tilt--007 warns (solution-family selection is not modeled; the HardNc ±2π window wrap would be undone by McAbcCyclicPathSyntax's shortest-cyclic tail pass, and the corpus never exercises SEQ with MOVE/TURN). PLANE RESET — the shared inactive sentinel (Term = \"G69\" + identity entry). The rotary axes are not re-positioned on reset (CYCLE800 cancel precedent; corpus programs follow with explicit rotary moves). PLANE VECTOR / PROJECTED / EULER / POINTS / RELATIV / AXIAL — recognized-but-not-simulated: consumed, HeidenhainPlane--Unsupported warns, and the previous tilt state carries unchanged (the HardNc oracle instead reuses a stale spatial arg here — SoftNc deliberately exceeds it). Owns the once-per-block TiltTransform modal carry for the Heidenhain list (CarryForwardFromPrevious(LazyLinkedListNode<SyntaxPiece>, JsonObject)). Must run before ToolHeightOffsetSyntax / HeidenhainToolOffsetSyntax (their translation follows the tilt entry's normal — the oracle's tool-normal-tiltable rule) and before McAbcSyntax / the coordinate-offset syntaxes (chain order: tilt entry ahead of CoordinateOffset, mirroring the Siemens frame slot; implicit MC rotary values must land before McAbc's per-axis lookback). HeidenhainProgramHeaderSyntax Heidenhain-specific: consumes the Parsing.PGM record (BEGIN|END PGM name MM|INCH) — the unit word is pushed into Parsing.Flags for the UnitModeSyntax instance configured with InchCodes=[“INCH”], MetricCodes=[“MM”] (which must run after this syntax), and END PGM writes the shared one-shot ProgramEnd section (existence-checked by its consumers exactly like M30). Consuming PGM also removes the program-header unconsumed noise every klartext file used to emit. HeidenhainRadiusCompSyntax Heidenhain-specific: maps the klartext radius-compensation words captured by HeidenhainLSyntax (RL/RR/R0 boolean Parsing-root records) onto the shared vocabulary consumed by the radius-compensation pass: RL → Parsing.G41 {D: toolId}, RR → G42, R0 → G40 flag. The offset id is the current tool number (klartext has no D word; IToolOffsetConfig documents the offset id as the Heidenhain tool number), resolved by walking back to the most recent ToolChange section. A missing or non-numeric tool id degrades to mode-only injection (radius 0 — the compensation pass records the state but applies no geometric offset) with an RadiusComp–ToolUnresolved warning. Must run before the PostLogic radius-compensation pass (any Logic position works — PostLogic sees completed Logic output) and after HeidenhainToolChangeSyntax so a same-block TOOL CALL is visible. HeidenhainRtcpSyntax Heidenhain RTCP (M128/M129, FUNCTION TCPM/FUNCTION RESET TCPM): the Heidenhain sibling of G43p4RtcpSyntax and SiemensTraoriSyntax. While RTCP is active the IToolHeightCompensationDef section carries the activating term (M128Term or TcpmTerm) and the ToolHeightCompensation chain entry becomes a tool-normal · offset translation at the block endpoint ABC (MakeToolHeightMat(IMachineKinematics, Vec3d, double)), tagged KindDynamic when the rotary state changes across the block — the signal that routes the block to ClLinear per-step IK. Tool length ownership stays with the TOOL CALL machinery (HeidenhainToolOffsetSyntax — table height + DL, which runs earlier in the bundle): activation adopts the compensation already resolved on this or the previous block and records the adopted owner in PriorTermKey; a TOOL CALL during the modal re-takes the section with the fresh offset; M129 / FUNCTION RESET TCPM hands the section back to the recorded owner (default Term — klartext tool-length compensation survives RTCP deactivation). The TOOL CALL Delta_mm (DL) rides along so the hand-back restores it. A deactivation with no active RTCP (the corpus' ubiquitous program-head M129) is consumed silently. Same-block contradiction (M128 with M129): the off state wins conservatively (the P1 rule, kept for continuity). The M128 feed limit (M128 F6000., or an FQn token the evaluator could not resolve) is recorded on the section as FeedLimitKey — recorded, not simulated. FUNCTION TCPM behavior arguments are recorded by the parsing syntax and warn Tcpm--ArgsNotSimulated on activation. Must run after ToolHeightOffsetSyntax / HeidenhainToolOffsetSyntax and the coordinate-offset syntaxes (mirroring the Fanuc G43.4 / Siemens TRAORI slot) and before HeidenhainPivotTransformationSyntax, whose gate recognizes the RtcpTerms and folds the kinematic pivot. Silently degrades to a plain UnitZ · offset translation when IMachineKinematics is absent. HeidenhainStockDeclarationSyntax Heidenhain-specific: consumes the Parsing[“BLK FORM”] record (workpiece blank declaration, present in virtually every klartext file) into the brand-neutral StockDeclaration section — recognized and recorded, not simulated. The simulation stock always comes from the project's own workpiece setup, mirroring the HardNc oracle which recognizes-and-skips the same lines; the structured record keeps the declared blank readable for a future stock consumer without feeding geometry today. HeidenhainToolChangeSyntax Heidenhain-specific: consumes the Parsing[“TOOL CALL”] record (written by HeidenhainToolCallSyntax) into the shared SectionName section so ToolChangeSemantic fires the tooling act. A klartext TOOL CALL always performs the change — no separate M06 trigger exists — so IsChangeKey is always true with Term = “TOOL CALL”. The spindle-speed word (S) is relocated to the root of Parsing so the shared SpindleSpeedSyntax — which must run after this syntax in the Logic bundle — records it modally. Numeric tool ids are written as ints (the act chain is int-keyed); non-numeric ids stay strings and resolve (or warn) at the semantic layer. P0 limits recorded as diagnostics: non-Z tool axis (ToolChange--AxisUnsupported), non-zero DL/DR deltas (ToolChange--DeltaUnsupported; zero deltas are consumed silently), and a TOOL CALL without a tool id (ToolChange--MissingToolId, e.g. a variable tool number the parser could not capture). Known P2 limitation: a quoted tool NAME that happens to spell a Q token (TOOL CALL \"Q1\" Z) loses its quotes at capture, so the evaluator substitutes the Q parameter's value and the numeric branch below treats it as a tool number. Corpus-zero (real names are \"B40R\"-style); fixing it needs the capture to preserve the quoted-ness, which would change the P0-pinned record shape. HeidenhainToolOffsetSyntax Heidenhain-specific: klartext TOOL CALL always applies tool-length compensation (there is no cancel word — HardNc compensates unconditionally). On TOOL CALL blocks the effective height = GetToolHeightOffset_mm(int)(tool id) + the TOOL CALL's DL delta; the shared ToolHeightCompensation section is written (Term = “TOOL CALL”, OffsetId = tool id — the offset id is documented as the Heidenhain tool number) and the translation composes into the transform chain via the shared ToolHeightCompensation source (mutual exclusion with the ISO G43 sibling by same-source replace). Modal: on following blocks the section is re-resolved per block from the table (mirroring the Siemens D sibling — give-way when a same block ISO term took ownership; carry Term/OffsetId/Delta_mm otherwise). Must sit after ToolHeightOffsetSyntax (the ISO anchor — last writer wins on mixed-dialect blocks) and after HeidenhainToolChangeSyntax (reads its ToolChange section), before the pivot/tilt syntaxes."
  },
  "api/Hi.NcParsers.LogicSyntaxs.HighSpeedPeckCycleSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.HighSpeedPeckCycleSyntax.html",
    "title": "Class HighSpeedPeckCycleSyntax | HiAPI-C# 2025",
    "summary": "Class HighSpeedPeckCycleSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll G73 high-speed peck drilling cycle (chip breaking). Supports modal repetition. Drills in increments of depth Q, partially retracting by PeckRetractionDistance_mm between strokes (instead of fully back to R like PeckDrillingCycleSyntax). Cycle sequence: Rapid to init position (target XY, previous Z) Rapid from init to R-point For each stroke: feed Q deeper, rapid retract by d If remainder exists: feed to bottom Z, rapid retract by d Rapid to final (G98 → init Z, G99 → R) Reads absolute coordinates from the cycle section, which is resolved by CannedCycleResolveSyntax (modal repetition, G91 conversion, missing-axis fallback) before this syntax runs. Must be placed after CannedCycleResolveSyntax and before IncrementalResolveSyntax in the syntax chain. public class HighSpeedPeckCycleSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HighSpeedPeckCycleSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples G73 G98 two-stroke chip-break — pre-populated CannedCycle (as CannedCycleResolveSyntax would have written), no #Previous: so initZ = 0, F=600 in the cycle section translated to 10 mm/s. Geometry: R=2, Z=-18, Q=10 → totalFeedLength = 20 → strokeCount = 2, no remainder. FallbackConfig default PeckRetractionDistance_mm = 5 sets the partial retract amount d. Per stroke, the chip-break rapid retracts to strokeZ + d (a small jump, in contrast to PeckDrillingCycleSyntax which rapids fully back to R). G98 final rapid is always emitted (no finalZ != rPoint guard here, unlike the G83 path). Seven items: init, R, feed-stroke1 (z=-8), rapid-to-strokeZ+d (z=-3), feed-stroke2 (z=-18), rapid-to-strokeZ+d (z=-13), final-init (z=0): #BeforeBuild: { \"Parsing\": { \"G73\": { \"X\": 50, \"Y\": 30, \"Z\": -18, \"R\": 2, \"Q\": 10, \"F\": 600 } }, \"CannedCycle\": { \"Term\": \"G73\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -18, \"R\": 2, \"Q\": 10 } } } #AfterBuild: { \"CannedCycle\": { \"Term\": \"G73\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -18, \"R\": 2, \"Q\": 10 } }, \"Feedrate\": { \"FeedrateValue\": 600, \"Term\": \"G94\", \"Unit\": \"mm/min\" }, \"CompoundMotion\": { \"Term\": \"G73\", \"Items\": [ { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 2 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": -8 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"Feedrate_mmds\": 10 } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": -3 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": -18 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"Feedrate_mmds\": 10 } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": -13 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } } ] }, \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 } } Constructors HighSpeedPeckCycleSyntax() Initializes a new instance with default settings. public HighSpeedPeckCycleSyntax() HighSpeedPeckCycleSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HighSpeedPeckCycleSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.IncrementalResolveSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.IncrementalResolveSyntax.html",
    "title": "Class IncrementalResolveSyntax | HiAPI-C# 2025",
    "summary": "Class IncrementalResolveSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Resolves G91 incremental axis values to absolute in-place within Parsing and its sub-sections. Reads Term written by PositioningSyntax. Per-word override: a block-root PositioningOverride section (written by SiemensAcIcSyntax for the Siemens per-word coordinate functions, and by the Heidenhain L / C / CC / CYCL CALL POS parsers for the klartext I-prefixed words — see HeidenhainIncrementalAxisWordUtil; the CYCL CALL POS words never reach this syntax, HeidenhainCannedCycleSyntax resolves them on the spot ahead of it) beats the modal term for the listed axes on this block only: an Incremental entry converts that word even under G90, an Absolute entry skips it even under G91 — as does, deliberately, every other non-Incremental value (the rotary-family Shortest / PositiveOnly / NegativeOnly entries are absolute targets; their swing resolution lives in McAbcCyclicPathSyntax, not here). A coded-position entry (CodedAbsolute / CodedIncremental — Siemens CAC()/CIC() on a linear indexing axis) carries an indexing position number instead of a coordinate: the number is resolved through IIndexingPositionConfig via TryResolveCodedTarget(IIndexingPositionConfig, string, string, double, double, ISentenceCarrier, NcDiagnosticProgress, out double, out string), the word is rewritten to the resolved absolute coordinate, and the entry to Absolute; a failed resolve reports an error and holds the last program position. Axes without an entry follow the modal term unchanged, so brands that never write the section (Fanuc/...) keep the exact legacy behavior. WorkingPathList specifies which JSON paths contain axis values that need incremental-to-absolute conversion. Default: [[\"Parsing\"], [\"Parsing\", \"G28\"]]; the Heidenhain bundle instead walks [\"Parsing\", \"CC\"] for the klartext circle-center record (CcAwareIncrementalResolveSyntax). All matching paths are converted against the same last program position — a nested record's words are distances from where the tool stands, exactly like the root's. Canned cycle paths (Parsing.G81, G82, G83, …) are intentionally excluded — their Z/R incremental semantics differ from normal axes (R is relative to init level, Z is relative to R-point). Resolution is handled by ResolveCycleCoordinates(JsonObject, Vec3d, double?, double?, double, double) inside each cycle syntax class, which runs before this syntax. Uses AxisNames to determine which tags are motion axes. Traces backward nodes for last known ProgramXyz to resolve incremental values. After this syntax, all axis values in the working paths are absolute — ProgramXyzSyntax can consume them without incremental logic. public class IncrementalResolveSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object IncrementalResolveSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples G90 (absolute) on the block — the syntax early-returns without touching Parsing.X/Y/Z, even though the values look like incremental deltas: #BeforeBuild: { \"Positioning\": { \"Term\": \"G90\", \"Mode\": \"Absolute\" }, \"Parsing\": { \"X\": 10, \"Y\": 20, \"Z\": 30 } } #AfterBuild: { \"Positioning\": { \"Term\": \"G90\", \"Mode\": \"Absolute\" }, \"Parsing\": { \"X\": 10, \"Y\": 20, \"Z\": 30 } } G91 (incremental) with a #Previous: block carrying MachineCoordinateState=(100,200,300). Under the identity ProgramToMcTransform chain, GetLastProgramXyz recovers program XYZ equal to MC, so each axis in Parsing is rewritten to lastAbs + incremental: #Previous: { \"MachineCoordinateState\": { \"X\": 100, \"Y\": 200, \"Z\": 300 } } #BeforeBuild: { \"Positioning\": { \"Term\": \"G91\", \"Mode\": \"Incremental\" }, \"Parsing\": { \"X\": 10, \"Y\": 20, \"Z\": 30 } } #AfterBuild: { \"Positioning\": { \"Term\": \"G91\", \"Mode\": \"Incremental\" }, \"Parsing\": { \"X\": 110, \"Y\": 220, \"Z\": 330 } } G91 + Parsing.G28 sub-section — exercises the second entry of the default WorkingPathList; the root Parsing has no X/Y/Z so the first path no-ops, but the [“Parsing”,“G28”] path picks up the G28 intermediate axes and resolves them against the same lastProgramXyz: #Previous: { \"MachineCoordinateState\": { \"X\": 100, \"Y\": 200, \"Z\": 300 } } #BeforeBuild: { \"Positioning\": { \"Term\": \"G91\", \"Mode\": \"Incremental\" }, \"Parsing\": { \"G28\": { \"X\": 5, \"Y\": 10, \"Z\": 15 } } } #AfterBuild: { \"Positioning\": { \"Term\": \"G91\", \"Mode\": \"Incremental\" }, \"Parsing\": { \"G28\": { \"X\": 105, \"Y\": 210, \"Z\": 315 } } } G90 (absolute) with a per-word PositioningOverride — the Siemens X=IC(10) shape after SiemensAcIcSyntax unwrapped it. Only the overridden X converts against the last program position; Y follows the modal G90 and stays: #Previous: { \"MachineCoordinateState\": { \"X\": 100, \"Y\": 200, \"Z\": 300 } } #BeforeBuild: { \"Positioning\": { \"Term\": \"G90\", \"Mode\": \"Absolute\" }, \"PositioningOverride\": { \"X\": \"Incremental\" }, \"Parsing\": { \"X\": 10, \"Y\": 20 } } #AfterBuild: { \"Positioning\": { \"Term\": \"G90\", \"Mode\": \"Absolute\" }, \"PositioningOverride\": { \"X\": \"Incremental\" }, \"Parsing\": { \"X\": 110, \"Y\": 20 } } G91 (incremental) with an Absolute override on X — X is skipped (already absolute, e.g. from X=AC(25)), Y still converts under the modal G91: #Previous: { \"MachineCoordinateState\": { \"X\": 100, \"Y\": 200, \"Z\": 300 } } #BeforeBuild: { \"Positioning\": { \"Term\": \"G91\", \"Mode\": \"Incremental\" }, \"PositioningOverride\": { \"X\": \"Absolute\" }, \"Parsing\": { \"X\": 25, \"Y\": 20 } } #AfterBuild: { \"Positioning\": { \"Term\": \"G91\", \"Mode\": \"Incremental\" }, \"PositioningOverride\": { \"X\": \"Absolute\" }, \"Parsing\": { \"X\": 25, \"Y\": 220 } } Coded-position absolute on a linear indexing axis (the Siemens X=CAC(2) workholder shape after the unwrap + evaluation stages). The case injects a SiemensMachineDataTable declaring X linear and assigned to indexing table 1 = [-200, -100, 0, 100]: position number 2 resolves to -100 mm and the entry is rewritten to Absolute: #BeforeBuild: { \"Positioning\": { \"Term\": \"G90\", \"Mode\": \"Absolute\" }, \"PositioningOverride\": { \"X\": \"CodedAbsolute\" }, \"Parsing\": { \"X\": 2 } } #AfterBuild: { \"Positioning\": { \"Term\": \"G90\", \"Mode\": \"Absolute\" }, \"PositioningOverride\": { \"X\": \"Absolute\" }, \"Parsing\": { \"X\": -100 } } The Heidenhain instance (CcAwareIncrementalResolveSyntax) on a klartext CC IX+0 IY+11 block after the CC parser: the nested record resolves against the last programmed position (the tool stands at (10, 20)), so the center lands at (10, 31); the Parsing root carries no axis word on a CC block and is untouched: #Previous: { \"MachineCoordinateState\": { \"X\": 10, \"Y\": 20, \"Z\": 0 } } #BeforeBuild: { \"Positioning\": { \"Term\": \"G90\", \"Mode\": \"Absolute\" }, \"PositioningOverride\": { \"X\": \"Incremental\", \"Y\": \"Incremental\" }, \"Parsing\": { \"CC\": { \"X\": 0, \"Y\": 11 } } } #AfterBuild: { \"Positioning\": { \"Term\": \"G90\", \"Mode\": \"Absolute\" }, \"PositioningOverride\": { \"X\": \"Incremental\", \"Y\": \"Incremental\" }, \"Parsing\": { \"CC\": { \"X\": 10, \"Y\": 31 } } } Constructors IncrementalResolveSyntax(List<List<string>>) Initializes a new instance with the given working path list. public IncrementalResolveSyntax(List<List<string>> workingPathList) Parameters workingPathList List<List<string>> JSON paths to scan for incremental axis values; see WorkingPathList. IncrementalResolveSyntax(XElement) Initializes a new instance by deserializing the working path list from the given XML element. Falls back to Default.WorkingPathList when the element has no Path children. public IncrementalResolveSyntax(XElement src) Parameters src XElement Source XML element. Properties Default Default instance with working paths covering the Parsing root and the Parsing.G28 intermediate XYZ subsection. public static IncrementalResolveSyntax Default { get; } Property Value IncrementalResolveSyntax Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string WorkingPathList JSON paths where this syntax searches for axis values (X/Y/Z) to convert from incremental to absolute when G91 is active. Each path is a list of segments navigating nested JSON objects. All matching paths are converted. public List<List<string>> WorkingPathList { get; } Property Value List<List<string>> Examples [[\"Parsing\"]] → Parsing root (normal XYZ) [[\"Parsing\", \"G28\"]] → Parsing.G28 (G28 intermediate XYZ) XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.IsoCoordinateOffsetSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.IsoCoordinateOffsetSyntax.html",
    "title": "Class IsoCoordinateOffsetSyntax | HiAPI-C# 2025",
    "summary": "Class IsoCoordinateOffsetSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll ISO/Fanuc/Mazak/Okuma/Syntec: resolves the G54–G59.9 work coordinate offset and the Fanuc-family additional work coordinate systems (G54.1 Pn, also spelled G54 Pn). Reads G54/G55/.../G59.9 from Flags and the captured Parsing.G54.1 = {P: n} object (written by G54p1Syntax for both spellings), which resolves to the coordinate id \"G54.1P{n}\" that the brand parameter tables map to #7001+ (IsoCoordinateAddressMap). Looks the offset Vec3d up via the IIsoCoordinateConfig dependencies (brand parameter table or IsoCoordinateTable) and composes it into ProgramToMcTransform. Modal — the active coordinate persists via backward lookback. Default coordinate ID is set by StaticInitializer. A block that selects a work coordinate system nobody has configured is reported on that block (never on the modal re-query of the following blocks): Coord-WorkOffset--AdditionalZero when an additional system (G54.1 Pn) resolves to no entry or to (0, 0, 0) — the brand tables seed every P row with zero, hardware-faithfully, so a zero there is the \"never entered\" state, whereas a zero row of the standard series (G54–G59 and the G59.1–G59.9 extension alike) is a legitimate authoring convention and stays silent; Coord-WorkOffset--NoTableEntry when no provider resolves the id at all (e.g. a G59.x on a runner carrying no brand-neutral table beside its brand table); and Coord-WorkOffset--IndexUnresolved when the P word is not a positive integer (vacant variable, non-integer), in which case the active system is kept. A bare G54.1 without P is not this syntax's business: the parameterized capture consumes nothing without a parameter, the dotted number lands in Parsing.Flags where it is not a G54-series member, so the active system is kept and the unconsumed check reports the flag. public class IsoCoordinateOffsetSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object IsoCoordinateOffsetSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples The Mat4d arrays below are written as 16 plain doubles in column-major order; the first 12 are the identity 3×3 rotation, the last 4 are the translation column (tx, ty, tz, 1). So a pure translation by (tx, ty, tz) is [1,0,0,0, 0,1,0,0, 0,0,1,0, tx,ty,tz,1]. G54 flag on the block but no IIsoCoordinateConfig on the dep list — the resolved offset falls back to Vec3d.Zero and the composed translation is the identity matrix: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G54\"] } } #AfterBuild: { \"CoordinateOffset\": { \"CoordinateId\": \"G54\", \"Offset_X\": 0, \"Offset_Y\": 0, \"Offset_Z\": 0 }, \"ProgramToMcTransform\": [ { \"Source\": \"CoordinateOffset\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } G55 flag with an IsoCoordinateTable providing G55 → (100, 50, -200) — the offset is written to the CoordinateOffset section and the same translation is composed into the transform chain: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G55\"] } } #AfterBuild: { \"CoordinateOffset\": { \"CoordinateId\": \"G55\", \"Offset_X\": 100, \"Offset_Y\": 50, \"Offset_Z\": -200 }, \"ProgramToMcTransform\": [ { \"Source\": \"CoordinateOffset\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 100,50,-200,1] } ] } No coordinate flag on the current block (e.g. an unrelated M03) but #Previous: carried G54 — modal lookback inherits G54, the dep is re-queried (so Offset_X/Y/Z are taken from the table, not from the previous block), and the transform chain is rebuilt. The unrelated M03 flag survives in Parsing.Flags because CleanupParsing only fires on the new-coord-flag branch: #Previous: { \"CoordinateOffset\": { \"CoordinateId\": \"G54\", \"Offset_X\": 10, \"Offset_Y\": 20, \"Offset_Z\": -100 } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M03\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\"] }, \"CoordinateOffset\": { \"CoordinateId\": \"G54\", \"Offset_X\": 10, \"Offset_Y\": 20, \"Offset_Z\": -100 }, \"ProgramToMcTransform\": [ { \"Source\": \"CoordinateOffset\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 10,20,-100,1] } ] } An additional work coordinate system — the parsing capture of G54.1 P4 or G54 P4 — with an IsoCoordinateTable providing G54.1P4 → (100, 50, -200): the captured object is consumed, the coordinate id is the un-padded \"G54.1P4\" key the providers share, and the translation is composed like any G5x: #BeforeBuild: { \"Parsing\": { \"G54.1\": { \"P\": 4 } } } #AfterBuild: { \"CoordinateOffset\": { \"CoordinateId\": \"G54.1P4\", \"Offset_X\": 100, \"Offset_Y\": 50, \"Offset_Z\": -200 }, \"ProgramToMcTransform\": [ { \"Source\": \"CoordinateOffset\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 100,50,-200,1] } ] } A block carrying both a G5x flag and an additional-system capture (illegal on a Fanuc — both are modal group 14 — but a parser must pick): the additional system wins, and the flag is consumed with it so that no stale G55 is left for the next syntaxes; the same table as above serves the lookup: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G55\"], \"G54.1\": { \"P\": 4 } } } #AfterBuild: { \"CoordinateOffset\": { \"CoordinateId\": \"G54.1P4\", \"Offset_X\": 100, \"Offset_Y\": 50, \"Offset_Z\": -200 }, \"ProgramToMcTransform\": [ { \"Source\": \"CoordinateOffset\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 100,50,-200,1] } ] } Constructors IsoCoordinateOffsetSyntax() Initializes a new instance with default settings. public IsoCoordinateOffsetSyntax() IsoCoordinateOffsetSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public IsoCoordinateOffsetSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.IsoG68RotationSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.IsoG68RotationSyntax.html",
    "title": "Class IsoG68RotationSyntax | HiAPI-C# 2025",
    "summary": "Class IsoG68RotationSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll ISO/Fanuc: resolves G68 (2D coordinate rotation) and G69 (cancel). Computes a rotation Mat4d around the active plane normal and composes it into ProgramToMcTransform. No IMachineKinematics dependency needed — G68 is pure geometric rotation. Managed commands: G68, G69 (idempotent with IsoG68p2TiltSyntax). public class IsoG68RotationSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object IsoG68RotationSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples All cases below avoid the cos/sin rotation math by using either G69 cancel (identity), the first-block default (no transform composed), or modal carry of an identity Mat4d. Mat4d arrays are 16 plain doubles in column-major order — see IsoCoordinateOffsetSyntax for the template. A future round can add a non-trivial G68 case by dumping the actual output and pasting the 16 doubles back into the marker. First block of the stream (no #Previous:, no G68/G69 on the block) — CarryForwardFromPrevious stamps a default TiltTransform.Term = \"G69\" so downstream lookback always sees a concrete state; no transform chain entry is composed: #BeforeBuild: { } #AfterBuild: { \"TiltTransform\": { \"Term\": \"G69\" } } G69 flag on the block — TryHandleG69 consumes it, writes the G69 section, and composes the identity Mat4d into the chain so any previously composed tilt rotation is overridden: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G69\"] } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"G69\" }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } Modal carry: no G68/G69 on the current block, but #Previous: carries an active G68 with identity tilt Mat4d in its chain. The current block inherits TiltTransform.Term = \"G68\" and re-composes the same Mat4d into its own chain; unrelated M03 flag survives because this syntax does not touch Parsing during the carry path: #Previous: { \"TiltTransform\": { \"Term\": \"G68\" }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M03\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\"] }, \"TiltTransform\": { \"Term\": \"G68\" }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } Non-trivial G68 rotation: 90° around the Z axis (no I/J/K → plane normal of the default G17 plane) at the origin (no X/Y/Z → all 0). The Mat4d column-major layout is rotation 90° about Z (no translation since pivot is the origin); cos(π/2) is not exactly 0 in IEEE-754 so the diagonal carries the 6.123233995736766E-17 drift produced by Math.Cos(Math.PI / 2) — preserved verbatim per the no-shorthand marker convention: #BeforeBuild: { \"Parsing\": { \"G68\": { \"R\": 90 } } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"G68\" }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [6.123233995736766E-17, 1, 0, 0, -1, 6.123233995736766E-17, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1] } ] } Remarks Input: Parsing.G68 → {X,Y,Z,I,J,K,R} from ParameterizedFlagSyntax. If I/J/K not specified, rotation axis is determined by active plane: G17→Z, G18→Y, G19→X. Constructors IsoG68RotationSyntax() Initializes a new instance with default settings. public IsoG68RotationSyntax() IsoG68RotationSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public IsoG68RotationSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.IsoG68p2TiltSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.IsoG68p2TiltSyntax.html",
    "title": "Class IsoG68p2TiltSyntax | HiAPI-C# 2025",
    "summary": "Class IsoG68p2TiltSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll ISO/Fanuc: resolves G68.2 (tilted work plane) and G69 (cancel). Computes a tilt Mat4d from I/J/K euler angles (Fanuc ZXZ convention) and composes it into ProgramToMcTransform. Managed commands: G68.2, G69 (idempotent with IsoG68RotationSyntax). Siemens equivalent: CYCLE800 (separate syntax). Heidenhain equivalent: PLANE SPATIAL (separate syntax). public class IsoG68p2TiltSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object IsoG68p2TiltSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Real-kinematics cases below wire TestDeps.CodeKinematics with the default chain code [O][Z][A][w];[O][Y][X][B][S][t] — a table-A / head-B 5-axis machine. A pivots around -X through origin (table side); B pivots around +Y through origin (head side). Both pivot axes pass through (0,0,0) because CodeXyzabcChain uses zero-offset component attachments — origin pivots are physically realistic for a table-table trunnion layout but not for a head pivot on a real table-head machine; here the zero-offset chain is a pedagogical simplification. Only the IK-refinement cases (2 and 3) use kinematics; cases 0 (G69 cancel) and 1 (pure IJK euler) are kinematics-free. Verification cue: the IK refinement path computes orientationDelta = ijkAbcOrient.Inverse * ijkRotation to preserve the exact IJK orientation while aligning with the kinematic ABC solution. For this chain at IJK=(0,30°,0), the solver's polished convergence lands the table-A angle within ~1e-8 rad of 30°, and that residual lives in the Mat4d off-diagonals visible in case 3 (≈1e-8-scale entries). G69 cancel via TryHandleG69(JsonObject, JsonObject) — the kinematics-free short-circuit path that writes the identity tilt. Standalone G69 — the flag is consumed, TiltTransform is written with Term: \"G69\", and an identity Mat4d entry is added to ProgramToMcTransform so any previously composed tilt rotation is reset: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G69\"] } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"G69\" }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } G68.2 with IJK = (0, 30, 0) and no kinematics dep — exercises the pure ZXZ Fanuc euler math (Rz(K=0) * Rx(J=30°) * Rz(I=0) * Translate(0) = Rx(30°)) without any IK refinement. The TiltTransform section retains the G68.2 ctor params for debug; the chain entry's Mat4d is the rotation matrix: #BeforeBuild: { \"Parsing\": { \"G68.2\": { \"X\": 0, \"Y\": 0, \"Z\": 0, \"I\": 0, \"J\": 30, \"K\": 0 } } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"G68.2\", \"X\": 0, \"Y\": 0, \"Z\": 0, \"I\": 0, \"J\": 30, \"K\": 0 }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [ 1, 0, 0, 0, 0, 0.8660254037844387, 0.49999999999999994, 0, 0, -0.49999999999999994, 0.8660254037844387, 0, 0, 0, 0, 1 ] } ] } Same G68.2 IJK with a real XyzabcSolver (table-A / head-B 5-axis layout) — hasPostAbc is false but the kinematics solves OrientationToMcAbc(tiltByIjk) successfully, so the refinement path ijkAbcOrientation * orientationDelta * Translate(origin) runs. The resulting Mat4d preserves the IJK orientation but aligns it with the kinematic ABC solution: #BeforeBuild: { \"Parsing\": { \"G68.2\": { \"X\": 0, \"Y\": 0, \"Z\": 0, \"I\": 0, \"J\": 30, \"K\": 0 } } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"G68.2\", \"X\": 0, \"Y\": 0, \"Z\": 0, \"I\": 0, \"J\": 30, \"K\": 0 }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [ 1, 0, 0, 0, 0, 0.8660254037844388, 0.49999999999999994, 0, 0, -0.49999999999999994, 0.8660254037844388, 0, 0, 0, 0, 1 ] } ] } G68.2 IJK with explicit post-processor rotary hints A=0, B=30 — hasPostAbc is true, kinematics first solves tiltByIjk → ijkMcAbc, then overrides A/B with the explicit values to form postMcAbc; the final Mat4d combines postAbcOrient * orientationDeltaIjkToPost * Translate(origin). The TiltTransform section gains the consumed A and B entries: #BeforeBuild: { \"Parsing\": { \"G68.2\": { \"X\": 0, \"Y\": 0, \"Z\": 0, \"I\": 0, \"J\": 30, \"K\": 0 }, \"A\": 0, \"B\": 30 } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"G68.2\", \"X\": 0, \"Y\": 0, \"Z\": 0, \"I\": 0, \"J\": 30, \"K\": 0, \"A\": 0, \"B\": 30 }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [ 0.8660254037844387, 9.927341754201178E-09, -0.4999999999999999, 0, 0, 0.9999999999999999, 1.985468350840236E-08, 0, 0.49999999999999994, -1.719466030237639E-08, 0.8660254037844386, 0, 0, 0, 0, 1 ] } ] } The first block after a program end — #Previous: carries the ProgramEnd section next to the still-active G68.2. This is the reset edge (ProgramEndSyntax): the controller's reset cancels the tilted work plane, so CarryForwardFromPrevious(LazyLinkedListNode<SyntaxPiece>, JsonObject) does not carry the tilt and writes the explicit G69 cancel state instead (the same shape as case 0), leaving the unrelated G00 flag alone: #Previous: { \"ProgramEnd\": { \"Term\": \"M30\" }, \"TiltTransform\": { \"Term\": \"G68.2\", \"X\": 0, \"Y\": 0, \"Z\": 0, \"I\": 0, \"J\": 30, \"K\": 0 } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G00\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"G00\"] }, \"TiltTransform\": { \"Term\": \"G69\" }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } Remarks G68.2 optionally uses IMachineKinematics dependency for IK refinement. The ZXZ euler convention is Fanuc-specific: Rz(K) * Rx(J) * Rz(I) * Translate(origin). Optional A/B/C parameters are post-processor rotary axis hints. When present and IMachineKinematics is available, the tilt is computed as: kinematicRotation(postAbc) * orientationDelta * Translate(origin) where orientationDelta = kinematicRotation(ijkAbc).Inverse * ijkRotation preserves the exact IJK orientation while aligning with the post-processor's solution. When kinematics is configured but the inverse-kinematics solve fails (orientation outside rotary-axis travel, or unrepresentable by the chain), the tilt falls back to the un-refined IJK euler result and a validation warning is emitted — Coord-Tilt--001 on the plain IJK path, Coord-Tilt--002 on the explicit A/B/C path. A missing kinematics dependency is not a warning: IK is optional refinement for G68.2 and the euler tilt is a complete result on its own. Constructors IsoG68p2TiltSyntax() Initializes a new instance with default settings. public IsoG68p2TiltSyntax() IsoG68p2TiltSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public IsoG68p2TiltSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.IsoLocalCoordinateOffsetSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.IsoLocalCoordinateOffsetSyntax.html",
    "title": "Class IsoLocalCoordinateOffsetSyntax | HiAPI-C# 2025",
    "summary": "Class IsoLocalCoordinateOffsetSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll ISO G52: Local coordinate system offset (additive to G54-series). G52 X10 Y20 Z5 → sets local offset. G52 X0 Y0 Z0 → cancels (resets to zero). M30 (program end) → also cancels. Reads Parsing.G52 (from G52Syntax), writes IsoLocalCoordinateOffset section, and adds an \"IsoLocalCoordinateOffset\" entry to the transformation chain. Modal — persists via backward lookback until changed or cancelled. public class IsoLocalCoordinateOffsetSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object IsoLocalCoordinateOffsetSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Mat4d arrays are 16 plain doubles in column-major order; pure translation by (tx,ty,tz) is [1,0,0,0, 0,1,0,0, 0,0,1,0, tx,ty,tz,1] — see IsoCoordinateOffsetSyntax for the column-major template. First block of the stream (no #Previous:) — the syntax stamps a zero-offset section and an identity translation in the chain so downstream lookback always sees a concrete state: #BeforeBuild: { } #AfterBuild: { \"IsoLocalCoordinateOffset\": { \"Offset_X\": 0, \"Offset_Y\": 0, \"Offset_Z\": 0 }, \"ProgramToMcTransform\": [ { \"Source\": \"IsoLocalCoordinateOffset\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } G52 X10 Y20 Z5 on a non-first block alongside an unrelated M03 flag — the G52 sub-section is consumed (removed from Parsing) and the translation is composed into the chain; the unrelated flag stays because this syntax does not call CleanupParsing: #Previous: { \"IsoLocalCoordinateOffset\": { \"Offset_X\": 0, \"Offset_Y\": 0, \"Offset_Z\": 0 } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M03\"], \"G52\": { \"X\": 10, \"Y\": 20, \"Z\": 5 } } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\"] }, \"IsoLocalCoordinateOffset\": { \"Offset_X\": 10, \"Offset_Y\": 20, \"Offset_Z\": 5 }, \"ProgramToMcTransform\": [ { \"Source\": \"IsoLocalCoordinateOffset\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 10,20,5,1] } ] } No G52 on the current block but #Previous: had a non-zero offset — modal lookback inherits it (with the translation re-composed into this block's chain): #Previous: { \"IsoLocalCoordinateOffset\": { \"Offset_X\": 10, \"Offset_Y\": 20, \"Offset_Z\": 5 } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M03\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\"] }, \"IsoLocalCoordinateOffset\": { \"Offset_X\": 10, \"Offset_Y\": 20, \"Offset_Z\": 5 }, \"ProgramToMcTransform\": [ { \"Source\": \"IsoLocalCoordinateOffset\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 10,20,5,1] } ] } Constructors IsoLocalCoordinateOffsetSyntax() Initializes a new instance with default settings. public IsoLocalCoordinateOffsetSyntax() IsoLocalCoordinateOffsetSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public IsoLocalCoordinateOffsetSyntax(XElement src) Parameters src XElement Source XML element. Fields TransformSource Identifier used as the transform source key when composing the local coordinate offset translation into the transform chain. public const string TransformSource = \"IsoLocalCoordinateOffset\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.LinearMotionSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.LinearMotionSyntax.html",
    "title": "Class LinearMotionSyntax | HiAPI-C# 2025",
    "summary": "Class LinearMotionSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Writes McLinear motion for linear commands (ISO G00/G01, Heidenhain L/LN). Detects motion mode from Flags, writes a one-shot MotionEvent section (form + isRapid) plus a modal MotionState section (Term) when MachineCoordinateState exists on the block. McLinearMotionSemantic discriminates between XYZ-only and XYZABC motion by checking whether rotary axis values are present in MachineCoordinateState. Must be placed after McAbcSyntax in the syntax chain. public class LinearMotionSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object LinearMotionSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples G00 explicit + MachineCoordinateState on the block — both the modal MotionState and the one-shot MotionEvent are written; IsRapid is set only on rapid (G00); the parsing flag is consumed and Parsing is cleaned up: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G00\"] }, \"MachineCoordinateState\": { \"X\": 10, \"Y\": 20, \"Z\": 30 } } #AfterBuild: { \"MachineCoordinateState\": { \"X\": 10, \"Y\": 20, \"Z\": 30 }, \"MotionState\": { \"Term\": \"G00\" }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } } G01 explicit + MC — same shape but IsRapid is omitted on the event section (only written when true): #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G01\"] }, \"MachineCoordinateState\": { \"X\": 10, \"Y\": 20, \"Z\": 30 } } #AfterBuild: { \"MachineCoordinateState\": { \"X\": 10, \"Y\": 20, \"Z\": 30 }, \"MotionState\": { \"Term\": \"G01\" }, \"MotionEvent\": { \"Form\": \"McLinear\" } } No motion flag on the current block but MachineCoordinateState is present (e.g. a downstream syntax already wrote the endpoint) — the previous block's MotionState.Term is the only way to know G00 vs G01, so the modal carry path fires: #Previous: { \"MotionState\": { \"Term\": \"G01\" } } #BeforeBuild: { \"MachineCoordinateState\": { \"X\": 10, \"Y\": 20, \"Z\": 30 } } #AfterBuild: { \"MachineCoordinateState\": { \"X\": 10, \"Y\": 20, \"Z\": 30 }, \"MotionState\": { \"Term\": \"G01\" }, \"MotionEvent\": { \"Form\": \"McLinear\" } } Constructors LinearMotionSyntax() Initializes a new instance with default settings. public LinearMotionSyntax() LinearMotionSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public LinearMotionSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.MCodeExpansionSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.MCodeExpansionSyntax.html",
    "title": "Class MCodeExpansionSyntax | HiAPI-C# 2025",
    "summary": "Class MCodeExpansionSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Expands machine-declared M-codes (IMCodeDeclarationConfig on the controller parameter table) into the canonical ISO flags the regular consumers already understand: tool change → M06, spindle direction → M03/M04/M05, coolant → M07/M08/M09. Must run ahead of SpindleSpeedSyntax, CoolantSyntax, and ToolChangeSyntax — expanding early is what lets one composite OEM code (e.g. M13 = spindle CW + flood coolant) feed several downstream consumers without any of them fighting over who removes the original flag. Same rewrite-into-shared-vocabulary pattern as HeidenhainRadiusCompSyntax (RL/RR/R0 → G41/G42/G40). Two deliberate boundaries keep the rewrite faithful. Declarations whose sole content is a spindle direction (IsSpindleDirectionOnly) are NOT expanded — SpindleSpeedSyntax resolves them in place via TryResolveDirection(string, out SpindleDirection), which keeps legacy <SpindleMCode> configs bit-identical and avoids the expansion product being re-translated by that same custom-first map (e.g. a mirrored M03↔M04 remap would otherwise flip direction). Expansion codes are inserted at the declared flag's own position, and a code whose raw twin also appears un-declared elsewhere in the block is not emitted — the block's textual order keeps deciding last-wins conflicts exactly as it did before. Declared-but-unmodeled behavior stays loud: a declaration carrying an UnmodeledNote emits one DeclaredMCode--UnmodeledEffects informational diagnostic per occurrence — a declaration replaces the raw Parsing--Unconsumed warning with an explanation, never with silence. A declaration with no effects and no note consumes its code silently by explicit intent. Undeclared codes are untouched and keep falling through to UnconsumedCheckSyntax. public class MCodeExpansionSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object MCodeExpansionSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Composite OEM code (test declares M13 → spindle CW + flood coolant) — the declared flag is replaced in place by its canonical ISO equivalents; other words ride along untouched: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M13\"], \"S\": 2000 } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\", \"M08\"], \"S\": 2000 } } Custom tool-change trigger (test declares M106 → tool change, the Siemens $MC_TOOL_CHANGE_M_CODE shape) — expands to M06 for ToolChangeSyntax to consume: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M106\"], \"T\": 5 } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M06\"], \"T\": 5 } } Note-only declaration (test declares M23 with an unmodeled note and no effects) — consumed with an explanatory diagnostic, leaving the block clean: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M23\"] } } #AfterBuild: {} Undeclared code — untouched, still falls through to the unconsumed check: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M55\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M55\"] } } Spindle-direction-only declaration (test declares M203 → CW, nothing else) — deliberately NOT expanded; SpindleSpeedSyntax resolves it in place, keeping legacy configs bit-identical: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M203\"], \"S\": 1670 } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M203\"], \"S\": 1670 } } In-place expansion keeps textual last-wins order — the composite M13 expands at its own position, so a later raw M05 still overrides the spindle half downstream: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M13\", \"M05\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\", \"M08\", \"M05\"] } } A canonical target that is itself declared (test declares M08 → note-only) must not swallow the composite's effect: the raw M08 is consumed for its own declaration while M13's flood half still emits M08: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M13\", \"M08\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\", \"M08\"] } } Constructors MCodeExpansionSyntax() Initializes a new instance with default settings. public MCodeExpansionSyntax() MCodeExpansionSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public MCodeExpansionSyntax(XElement src) Parameters src XElement Source XML element. Fields UnknownCoolantDiagId Diagnostic id for a declaration whose CoolantMode names no known mode. public const string UnknownCoolantDiagId = \"DeclaredMCode--UnknownCoolantMode\" Field Value string UnmodeledDiagId Diagnostic id for the informational message emitted when a consumed declaration carries an UnmodeledNote. public const string UnmodeledDiagId = \"DeclaredMCode--UnmodeledEffects\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.MachineCoordSelectSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.MachineCoordSelectSyntax.html",
    "title": "Class MachineCoordSelectSyntax | HiAPI-C# 2025",
    "summary": "Class MachineCoordSelectSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Handles machine coordinate selection — non-modal, one-shot. The axis values (X/Y/Z) in the block are interpreted as machine coordinates, bypassing all work offsets, local coordinates, tool height compensation, and coordinate rotations. If G91 (incremental) is active, the code is ignored per ISO standard. A per-word incremental stamp on the block (block-root PositioningOverride entry Incremental — Siemens SUPA Y=IC(-10), klartext L IY-10 M91) is a distance in the machine frame: the word is added to the previous machine position of that axis. Defaults to ISO G53. Brands with additional one-shot machine-coordinate codes widen SupportedCodes — the Siemens preset adds G153 and SUPA (both suppress every active frame for one block; in this pipeline all of those reduce to \"bypass the composed ProgramToMcTransform\", which the ProgramXyz back-derivation below already models). The matched code is stamped verbatim into Term for bidirectional source recovery. Rotary words on the same block (e.g. SUPA G0 B0, G53 A0 C0) are consumed by McAbcSyntax ahead of this syntax — machine and program rotary coincide while no rotary offsets are modeled — and the block is still a machine-coordinate positioning: the linear axes hold their machine position when no X/Y/Z word is given, and the motion is always McLinear. A machine-coordinate block never takes the RTCP tool-center-point linkage: on a real controller G53 applies no compensation, so a rotary swing commanded through it turns the axis in place instead of dragging X/Y/Z to pin the tool tip (the tip's post-swing program coordinate is what the back-derivation reports). Must be placed before IncrementalResolveSyntax and ProgramXyzSyntax in the syntax chain. When a supported code is active, this syntax consumes X/Y/Z from Parsing and writes MachineCoordinateState directly, preventing ProgramXyzSyntax from processing them as program coordinates — and, ahead of the resolve, reading a per-word incremental word raw instead of re-based into the program frame. public class MachineCoordSelectSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object MachineCoordSelectSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples G53 with full XYZ on a first block (no #Previous:) — FindPreviousMc falls back to Vec3d.Zero, transform defaults to identity, so ProgramXyz equals MachineCoordinateState. A non-modal MotionEvent is stamped with Term: “G53” for bidirectional source recovery (per the precedence rule on Term); IsRapid inherits from the modal MotionState.Term (G00 → true, G01/G02/G03 → false, none → true as the conservative “safe rapid” default common in practice): #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G53\"], \"X\": 10, \"Y\": 20, \"Z\": 30 } } #AfterBuild: { \"MachineCoordinateState\": { \"X\": 10, \"Y\": 20, \"Z\": 30 }, \"ProgramXyz\": { \"X\": 10, \"Y\": 20, \"Z\": 30 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true, \"Term\": \"G53\" } } G53 with only Z specified — FindPreviousMc picks up X/Y from the previous block's MachineCoordinateState; Z is overwritten; MotionEvent stamped as above: #Previous: { \"MachineCoordinateState\": { \"X\": 100, \"Y\": 50, \"Z\": -200 } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G53\"], \"Z\": 0 } } #AfterBuild: { \"MachineCoordinateState\": { \"X\": 100, \"Y\": 50, \"Z\": 0 }, \"ProgramXyz\": { \"X\": 100, \"Y\": 50, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true, \"Term\": \"G53\" } } G91 active on the same block — G53 incompatible with G91 incremental positioning per ISO standard. Syntax emits validation error Coord-MachCoord–006, consumes the G53 flag and any X/Y/Z, and writes no machine state. Positioning section preserved: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G53\"], \"X\": 10 }, \"Positioning\": { \"Term\": \"G91\" } } #AfterBuild: { \"Positioning\": { \"Term\": \"G91\" } } Standalone G53 with no X/Y/Z — G53 by itself has no destination to interpret as machine coordinates, so the syntax emits validation error Coord-MachCoord–007 and consumes the flag without writing machine state: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G53\"] } } #AfterBuild: {} Siemens SUPA retract (SUT configured with SupportedCodes = [“G53”, “G153”, “SUPA”]) — corpus shape N5 SUPA G0 Z1150 D0: the matched code is stamped verbatim as Term, missing X/Y fill from the previous machine position, the motion-mode flag is claimed into the modal MotionState (LinearMotionSyntax skips this block, so nobody else would), and the D word stays in Parsing for its own consumer: #Previous: { \"MachineCoordinateState\": { \"X\": 500, \"Y\": 1000, \"Z\": -30 } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"SUPA\", \"G00\"], \"Z\": 1150, \"D\": 0 } } #AfterBuild: { \"Parsing\": { \"D\": 0 }, \"MachineCoordinateState\": { \"X\": 500, \"Y\": 1000, \"Z\": 1150 }, \"ProgramXyz\": { \"X\": 500, \"Y\": 1000, \"Z\": 1150 }, \"MotionState\": { \"Term\": \"G00\" }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true, \"Term\": \"SUPA\" } } Per-word incremental word on the machine-coordinate block (klartext L IY-10 M91, Siemens SUPA Y=IC(-10)) — a distance in the MACHINE frame: added to the previous machine position, never re-based through the program frame. This is why the syntax sits ahead of IncrementalResolveSyntax in every brand list; the override section stays on the block (one-shot, nobody consumes it): #Previous: { \"MachineCoordinateState\": { \"X\": 100, \"Y\": 50, \"Z\": -200 } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G53\"], \"Y\": -10 }, \"PositioningOverride\": { \"Y\": \"Incremental\" } } #AfterBuild: { \"PositioningOverride\": { \"Y\": \"Incremental\" }, \"MachineCoordinateState\": { \"X\": 100, \"Y\": 40, \"Z\": -200 }, \"ProgramXyz\": { \"X\": 100, \"Y\": 40, \"Z\": -200 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true, \"Term\": \"G53\" } } Rotary-only machine-coordinate block under RTCP (G0 G53 A0. while G43.4 is active) — McAbcSyntax has already consumed the rotary word into MachineCoordinateState, and G43p4RtcpSyntax has tagged the chain Dynamic because the tool orientation changes across the block. The linear axes hold the previous machine position (G53 applies no compensation, so the swing turns the axis in place instead of pinning the tool tip) and the motion is stamped McLinear; ProgramXyz is the tip's program coordinate after the swing — the 10 mm tool-height entry is inverted, MC Z 0 → program Z −10: #Previous: { \"MachineCoordinateState\": { \"X\": -1, \"Y\": -1, \"Z\": 0, \"A\": 90 } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G53\", \"G00\"] }, \"MachineCoordinateState\": { \"A\": 0 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Dynamic\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,10,1] } ] } #AfterBuild: { \"MachineCoordinateState\": { \"A\": 0, \"X\": -1, \"Y\": -1, \"Z\": 0 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Dynamic\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,10,1] } ], \"ProgramXyz\": { \"X\": -1, \"Y\": -1, \"Z\": -10 }, \"MotionState\": { \"Term\": \"G00\" }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true, \"Term\": \"G53\" } } Constructors MachineCoordSelectSyntax() Initializes a new instance with default settings. public MachineCoordSelectSyntax() MachineCoordSelectSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public MachineCoordSelectSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string SupportedCodes One-shot machine-coordinate codes this syntax consumes; defaults to ISO G53. The Siemens preset widens the list to G53 + G153 + SUPA. The first list entry present in Parsing.Flags is stamped as Term; every listed code present on the block is consumed so none re-triggers the unconsumed-parsing warning. public List<string> SupportedCodes { get; set; } Property Value List<string> XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.McAbcCyclicPathSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.McAbcCyclicPathSyntax.html",
    "title": "Class McAbcCyclicPathSyntax | HiAPI-C# 2025",
    "summary": "Class McAbcCyclicPathSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Resolve modular rotary axes to the shortest cyclic path relative to the previous node. Uses IsModularRotary(string) to determine which axes within MachineCoordinateState need cyclic resolution. Falls back to hardcoded A/B/C if no IMachineAxisConfig is available. Must be placed after ProgramXyzSyntax in NcSyntaxList. Two stages, mirroring McXyzSyntax: Root MachineCoordinateState — anchored at the previous block's modal rotary state. CompoundMotion.ItemsKey[*] — sequential walk through items, anchoring item 0 at the previous block's modal state and item i > 0 at item i-1's post-cycle value (per-axis chain). Items without a rotary MachineCoordinateState are skipped. The items pass enables rotary motion (e.g. G28 ABC intermediate / home stages) to surface as motion IAct segments rather than a single root-MC stamp. Per-word directional override: a block-root PositioningOverride entry (stamped by SiemensAcIcSyntax) valued PositiveOnly (Siemens ACP()) or NegativeOnly (ACN()) swaps that axis's window for this block only: [anchor, anchor+360°) / (anchor-360°, anchor] instead of the default ±180° — the approach direction is forced even when it is the longer way around. A target congruent with the anchor (within an ULP-scale epsilon) keeps the anchor value verbatim — no move, never a spurious full turn, and no deg→rad→deg drift. Shortest (DC()) is the default window and needs no special path here. The override is read from the current block only (it is one-shot, never carried — deliberately unlike the modal RotaryWrap gate's one-step previous fallback) and applies to the root MC stage only, not to CompoundMotion items (G28/G74/G75 expansions capture their words in sub-objects the stamping syntax never sees, so an override can only ever describe a root word). Directional/shortest entries keyed by an axis outside the modular set are reported as Coord-McAbc--003 — the promise cannot be honored there and silence would mis-read the program's intent; an entry with no anchor to resolve against (first rotary value in the stream) is reported as Coord-McAbc--004 and adopted unwrapped, matching the default path. Per-word incremental override: an Incremental entry (Siemens IC(), klartext IC+270) is a signed traverse by definition — McAbcSyntax already wrote anchor + delta — so this pass keeps that value verbatim for the axis instead of folding it into the ±180° window (a +270° chain dimension must not become a -90° swing). Incremental entries on non-modular axes need no warning: the literal value is what the axis would do anyway. public class McAbcCyclicPathSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object McAbcCyclicPathSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Cases below run with no IMachineAxisConfig on the dep list, so the syntax uses the A/B/C fallback (a configuration warning is emitted but does not affect the JSON). The syntax is the tail-pass rotary-wrap centraliser — upstream rotary writers (McAbcSyntax, G28, G53.1, ...) store raw degrees and let this pass resolve to the shortest cyclic path. Current B is within ±180° of the previous B — no wrap needed; the value is rewritten in place but equals the input: #Previous: { \"MachineCoordinateState\": { \"B\": 0 } } #BeforeBuild: { \"MachineCoordinateState\": { \"B\": 10 } } #AfterBuild: { \"MachineCoordinateState\": { \"B\": 10 } } Current B is 270° but previous B is 0° — the shortest path is the other way around, so the value is rewritten as -90° (mathematically equivalent, geometrically the same orientation, but signalling the shorter rotation to a downstream motion consumer). 270/0 round-trips through ToRad→Cycle→ToDeg with no rounding noise (1.5π → -0.5π → -90 exactly); other angle pairs (e.g. 350° → -10°) emit a trailing ULP-scale drift instead: #Previous: { \"MachineCoordinateState\": { \"B\": 0 } } #BeforeBuild: { \"MachineCoordinateState\": { \"B\": 270 } } #AfterBuild: { \"MachineCoordinateState\": { \"B\": -90 } } First block of the stream (no #Previous:) — no anchor to resolve against, so the syntax early-returns and the raw value is preserved verbatim: #BeforeBuild: { \"MachineCoordinateState\": { \"B\": 350 } } #AfterBuild: { \"MachineCoordinateState\": { \"B\": 350 } } CompoundMotion.Items walk — two items chain: item 0 cycles against the previous block's modal B = 0° (270° → -90°), and item 1 cycles against item 0's post-cycle -90° (170° → -190°, since the shorter path from -90° to 170° wraps backward through -180°). If item 1 had used the previous-block anchor instead of the chained anchor, 170° would have stayed at 170° (already in the ±180° window around 0°), so the test discriminates between chain and no-chain: #Previous: { \"MachineCoordinateState\": { \"B\": 0 } } #BeforeBuild: { \"CompoundMotion\": { \"Items\": [ { \"MachineCoordinateState\": { \"B\": 270 } }, { \"MachineCoordinateState\": { \"B\": 170 } } ] } } #AfterBuild: { \"CompoundMotion\": { \"Items\": [ { \"MachineCoordinateState\": { \"B\": -90 } }, { \"MachineCoordinateState\": { \"B\": -190 } } ] } } ACP (PositiveOnly) forces the positive swing even though the shortest path from 0° to 270° is -90° (compare the default case above — same numbers, opposite outcome). The override section stays on the block (nothing consumes it away): #Previous: { \"MachineCoordinateState\": { \"B\": 0 } } #BeforeBuild: { \"MachineCoordinateState\": { \"B\": 270 }, \"PositioningOverride\": { \"B\": \"PositiveOnly\" } } #AfterBuild: { \"MachineCoordinateState\": { \"B\": 270 }, \"PositioningOverride\": { \"B\": \"PositiveOnly\" } } ACN (NegativeOnly) mirror — target 90° from anchor 0° swings -270° instead of the shortest +90°: #Previous: { \"MachineCoordinateState\": { \"B\": 0 } } #BeforeBuild: { \"MachineCoordinateState\": { \"B\": 90 }, \"PositioningOverride\": { \"B\": \"NegativeOnly\" } } #AfterBuild: { \"MachineCoordinateState\": { \"B\": -270 }, \"PositioningOverride\": { \"B\": \"NegativeOnly\" } } Congruent target under a directional override — the raw anchor sits at 370° (e.g. after an earlier ACP long-way swing) and the ACN target 10° is the same physical position: no move, the anchor value is kept verbatim (the epsilon snap; without it, radian ULP noise would decide between \"no move\" and a spurious full -360° turn): #Previous: { \"MachineCoordinateState\": { \"B\": 370 } } #BeforeBuild: { \"MachineCoordinateState\": { \"B\": 10 }, \"PositioningOverride\": { \"B\": \"NegativeOnly\" } } #AfterBuild: { \"MachineCoordinateState\": { \"B\": 370 }, \"PositioningOverride\": { \"B\": \"NegativeOnly\" } } Incremental word (B=IC(270) / klartext L IB+270): the rotary writer accumulated anchor 0° + 270° = 270°, and the pass keeps the traverse literal — the same 270° that the default window above rewrote to -90° stays +270°: #Previous: { \"MachineCoordinateState\": { \"B\": 0 } } #BeforeBuild: { \"MachineCoordinateState\": { \"B\": 270 }, \"PositioningOverride\": { \"B\": \"Incremental\" } } #AfterBuild: { \"MachineCoordinateState\": { \"B\": 270 }, \"PositioningOverride\": { \"B\": \"Incremental\" } } Constructors McAbcCyclicPathSyntax() Initializes a new instance with default settings. public McAbcCyclicPathSyntax() McAbcCyclicPathSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public McAbcCyclicPathSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.McAbcSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.McAbcSyntax.html",
    "title": "Class McAbcSyntax | HiAPI-C# 2025",
    "summary": "Class McAbcSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Writes rotary axis values (A/B/C) into MachineCoordinateState from Parsing and modal lookback. Only active when IMachineAxisConfig declares rotary axes. Works for both 3+2-axis (no IMachineKinematics) and simultaneous 5-axis configurations. This syntax is intentionally ABC-only. When the block is rotary-only (no ProgramXyz, e.g. G00 A30.) the section is created with ABC but without X/Y/Z. McAbcXyzFallbackSyntax — placed after McXyzSyntax — copies X/Y/Z from the previous block's MachineCoordinateState to finish the section. Splitting the XYZ fill out lets this syntax run before McXyzSyntax (and before G43p4RtcpSyntax) without accidentally filling X/Y/Z from prev and thereby short-circuiting DeriveMcXyz(JsonObject, Mat4d). Missing rotary axes are filled from previous MachineCoordinateState lookback, unless the current section already has the value (e.g., from HomeMcInitializer). Values are stored in degrees (matching McAbcCyclicPathSyntax). Per-word override: a block-root PositioningOverride section (written by SiemensAcIcSyntax for the Siemens AC()/IC() coordinate functions, and by the Heidenhain L / C parsers for the klartext IA+/IB+/IC+ words) marks a rotary word Incremental: the parsed value is then added to the previous modal value of that axis (previous MachineCoordinateState lookback, falling back to a value already present in the current section, then 0) instead of being written as an absolute angle. The accumulated raw degrees stay monotonic across iterations: the McAbcCyclicPathSyntax tail-pass keeps an Incremental-stamped axis literal (a chain dimension is a signed traverse, never re-shortened), so even a +270° step survives as net rotation. An Absolute entry (from AC()) matches the default write and needs no special path — and so, deliberately, do the rotary-family entries Shortest (DC()) / PositiveOnly (ACP()) / NegativeOnly (ACN()): this syntax writes the raw absolute target and the shortest/directional swing is resolved by the McAbcCyclicPathSyntax tail-pass, which owns the wrap math. Brands that never write the section keep the exact legacy behavior. Coded-position overrides (Siemens CAC()/CIC()/CDC()/CACP()/CACN()) carry an indexing position number instead of an angle: the number is resolved through IIndexingPositionConfig via TryResolveCodedTarget(IIndexingPositionConfig, string, string, double, double, ISentenceCarrier, NcDiagnosticProgress, out double, out string) and the override entry is rewritten to the plain vocabulary (Absolute / Shortest / PositiveOnly / NegativeOnly — a cyclic CIC keeps its programmed direction through the directional values) before the tail-pass runs, so the tail-pass never sees a coded value. A failed resolve (invalid number, missing table) reports an error and holds the axis at its previous value. Must be placed before McXyzSyntax so syntaxes that need the current-block ABC to compute transforms (e.g. G43p4RtcpSyntax) can see it; and before McAbcCyclicPathSyntax and LinearMotionSyntax. public class McAbcSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object McAbcSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Cases 1 and 2 inject a TestDeps.AxisConfig declaring B and C as Rotary. Values are stored as raw degrees; shortest-cyclic resolution is a downstream pass via McAbcCyclicPathSyntax. No IMachineAxisConfig dep on the list — early-return no-op (the syntax only fires when rotary axes are declared): #BeforeBuild: { \"Parsing\": { \"B\": 45, \"C\": 90 } } #AfterBuild: { \"Parsing\": { \"B\": 45, \"C\": 90 } } AxisConfig declares B+C rotary; Parsing.B/C are consumed into a freshly created MachineCoordinateState section (X/Y/Z are deliberately left out so McXyzSyntax can still derive XYZ later — see class summary): #BeforeBuild: { \"Parsing\": { \"B\": 45, \"C\": 90 } } #AfterBuild: { \"MachineCoordinateState\": { \"B\": 45, \"C\": 90 } } Only Parsing.B on the current block; #Previous: carries a full MC including C=0. The missing C is filled from the per-axis backward lookback (FindPreviousMcAxis(LazyLinkedListNode<SyntaxPiece>, string)): #Previous: { \"MachineCoordinateState\": { \"B\": 0, \"C\": 0 } } #BeforeBuild: { \"Parsing\": { \"B\": 30 } } #AfterBuild: { \"MachineCoordinateState\": { \"B\": 30, \"C\": 0 } } Per-word incremental override (the Siemens C=IC(...) shape after the unwrap + evaluation stages) — the parsed 21.5 is added onto the previous modal C instead of overwriting it; B has no override entry and fills from lookback as usual: #Previous: { \"MachineCoordinateState\": { \"B\": 10, \"C\": 40 } } #BeforeBuild: { \"PositioningOverride\": { \"C\": \"Incremental\" }, \"Parsing\": { \"C\": 21.5 } } #AfterBuild: { \"PositioningOverride\": { \"C\": \"Incremental\" }, \"MachineCoordinateState\": { \"B\": 10, \"C\": 61.5 } } Coded-position absolute (the Siemens C=CAC(3) shape after the unwrap + evaluation stages). The case injects a SiemensMachineDataTable declaring C rotary and assigned to indexing table 1 = [0, 90, 180, 270]: position number 3 resolves to 180° and the override entry is rewritten to Absolute for the tail-pass: #BeforeBuild: { \"PositioningOverride\": { \"C\": \"CodedAbsolute\" }, \"Parsing\": { \"C\": 3 } } #AfterBuild: { \"PositioningOverride\": { \"C\": \"Absolute\" }, \"MachineCoordinateState\": { \"C\": 180 } } Coded-position incremental with the same table — from 270° (position 4), advancing 2 positions wraps the 4-position cycle to position 2 (90°), and the positive count becomes a PositiveOnly approach so the swing keeps the programmed direction: #Previous: { \"MachineCoordinateState\": { \"C\": 270 } } #BeforeBuild: { \"PositioningOverride\": { \"C\": \"CodedIncremental\" }, \"Parsing\": { \"C\": 2 } } #AfterBuild: { \"PositioningOverride\": { \"C\": \"PositiveOnly\" }, \"MachineCoordinateState\": { \"C\": 90 } } Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.McAbcXyzFallbackSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.McAbcXyzFallbackSyntax.html",
    "title": "Class McAbcXyzFallbackSyntax | HiAPI-C# 2025",
    "summary": "Class McAbcXyzFallbackSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Fills missing X/Y/Z on an ABC-only MachineCoordinateState section. Behaviour depends on whether the block is under RTCP with rotary motion, as indicated by HasDynamicEntry(JsonObject): Non-dynamic (no RTCP or RTCP with ABC stable) — the programmed tool tip stays put in MC while rotary axes (if any) are unchanged, so we simply copy X/Y/Z from the previous block's MachineCoordinateState. This matches NC modal XYZ carry-forward for rotary-only blocks such as G00 A30. (non-RTCP pivoting). Dynamic (RTCP active + ABC changing) — the programmed tool tip must stay fixed in program coordinates while MC XYZ shifts to compensate the new rotary state. Looks up the last ProgramXyz and re-derives MC = inheritedProgramXyz × composedTransform, where the composed transform is the block's endpoint chain (now including PivotTransformSource as a full rotation+translation Mat4d, so the chain already encodes the kinematic IK). The carried ProgramXyz is also stamped onto the current block so downstream consumers see a consistent ProgramXyz + MC pair. Pair with McAbcSyntax, which runs early to write ABC but deliberately leaves X/Y/Z empty so McXyzSyntax can still derive MC XYZ from ProgramXyz via the transform chain when the block carries linear motion. If McXyzSyntax has nothing to derive (no ProgramXyz), this syntax completes the MC section as described above. Does nothing when the section already carries all three of X/Y/Z (normal linear-motion blocks), or when there is no section at all (pure parse-only block that introduces no MC). Must be placed after McXyzSyntax and before McAbcCyclicPathSyntax / LinearMotionSyntax. public class McAbcXyzFallbackSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object McAbcXyzFallbackSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples All cases below stay on the non-dynamic branch (no PivotTransformSource entry in the chain) so the RTCP re-derivation path is skipped. Block has no MachineCoordinateState section at all (pure parse-only) — the syntax early-returns and the block is unchanged: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G00\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"G00\"] } } MC already complete (all three of X/Y/Z present) — the second guard fires and the section is preserved verbatim (no overwrite even if a #Previous: MC differed): #BeforeBuild: { \"MachineCoordinateState\": { \"X\": 10, \"Y\": 20, \"Z\": 30 } } #AfterBuild: { \"MachineCoordinateState\": { \"X\": 10, \"Y\": 20, \"Z\": 30 } } Rotary-only MC on a rotary-only block (e.g. a 5-axis B+C trunnion machine running G00 B45. C90.) — missing X/Y/Z are copied from the #Previous: block's MC; the rotary keys keep their existing positions (insertion order) and X/Y/Z are appended. The previous block's MC carries the modal rotary state alongside X/Y/Z, but the fallback only reads X/Y/Z from it: #Previous: { \"MachineCoordinateState\": { \"X\": 100, \"Y\": 200, \"Z\": 300, \"B\": 0, \"C\": 0 } } #BeforeBuild: { \"MachineCoordinateState\": { \"B\": 45, \"C\": 90 } } #AfterBuild: { \"MachineCoordinateState\": { \"B\": 45, \"C\": 90, \"X\": 100, \"Y\": 200, \"Z\": 300 } } Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.McXyzSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.McXyzSyntax.html",
    "title": "Class McXyzSyntax | HiAPI-C# 2025",
    "summary": "Class McXyzSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Derives MachineCoordinateState from ProgramXyz by applying the composed ProgramToMcTransform. Processes two stages: Root ProgramXyz → root MachineCoordinate CompoundMotion.ItemsKey[*] — derives MachineCoordinate from ProgramXyz for items that have ProgramXyz but no MachineCoordinate Must be placed after syntaxes that write ProgramXyz (e.g., ReferenceReturnSyntax) and before syntaxes that read MachineCoordinate (e.g., LinearMotionSyntax). public class McXyzSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object McXyzSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Root ProgramXyz only, no ProgramToMcTransform chain — composed transform is identity, so MC equals ProgramXyz: #BeforeBuild: { \"ProgramXyz\": { \"X\": 10, \"Y\": 20, \"Z\": 30 } } #AfterBuild: { \"ProgramXyz\": { \"X\": 10, \"Y\": 20, \"Z\": 30 }, \"MachineCoordinateState\": { \"X\": 10, \"Y\": 20, \"Z\": 30 } } Root MachineCoordinateState already present — guarded by the non-null check, so an upstream syntax's explicit MC is preserved verbatim (the derivation from ProgramXyz is skipped): #BeforeBuild: { \"ProgramXyz\": { \"X\": 10, \"Y\": 20, \"Z\": 30 }, \"MachineCoordinateState\": { \"X\": 100, \"Y\": 200, \"Z\": 300 } } #AfterBuild: { \"ProgramXyz\": { \"X\": 10, \"Y\": 20, \"Z\": 30 }, \"MachineCoordinateState\": { \"X\": 100, \"Y\": 200, \"Z\": 300 } } CompoundMotion.Items[*] with ProgramXyz but no MachineCoordinateState — each item receives its own derived MC; items that already had MC (or had no ProgramXyz) are left alone: #BeforeBuild: { \"CompoundMotion\": { \"Items\": [ { \"ProgramXyz\": { \"X\": 1, \"Y\": 2, \"Z\": 3 } }, { \"MachineCoordinateState\": { \"X\": 9, \"Y\": 9, \"Z\": 9 } } ] } } #AfterBuild: { \"CompoundMotion\": { \"Items\": [ { \"ProgramXyz\": { \"X\": 1, \"Y\": 2, \"Z\": 3 }, \"MachineCoordinateState\": { \"X\": 1, \"Y\": 2, \"Z\": 3 } }, { \"MachineCoordinateState\": { \"X\": 9, \"Y\": 9, \"Z\": 9 } } ] } } Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.OrientationVectorResolveSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.OrientationVectorResolveSyntax.html",
    "title": "Class OrientationVectorResolveSyntax | HiAPI-C# 2025",
    "summary": "Class OrientationVectorResolveSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Shared vector-orientation resolve — the brand-independent half of tool-axis-vector 5-axis programming (Heidenhain LN TX/TY/TZ; the Fanuc/Syntec/Mazak G43.5 I/J/K and Siemens A3=/B3=/C3= slots when their adapters land). Consumes the ToolOrientationKey section a brand adapter wrote — { “Vector”: {X,Y,Z}, “Term”: “<brand word>” }, unit vector in program coordinates — and resolves it into rotary-axis degrees on MachineCoordinateState via OrientationToMcAbc(Vec3d, out Vec3d) (axial-only: rotation about the tool axis is free). Everything downstream is the existing RTCP pipeline untouched: the brand RTCP syntax sees the endpoint ABC, marks the tool-height entry KindDynamic on a rotary change, and LinearMotionSyntax routes the block to ClLinear per-step IK. Branch continuity is seeded explicitly: before solving, the chain is set to the previous block's rotary state (McAbcToMat(Vec3d) on the per-axis MC lookback) so the solver follows the current solution branch deterministically — the implicit chain state cannot be trusted under lazy or out-of-order rebuilds — and the solved angles are unwrapped to the nearest ±360° window of that anchor. Must run after McAbcSyntax (explicit rotary words and lookback land first; a vector on the same block overrides them) and before the brand RTCP syntax and McXyzSyntax (the section is created rotary-only, so the XYZ derivation still runs — the McAbcSyntax rotary-only discipline). Registered per brand list by the brand that has a vector adapter. Degradation is diagnosed, never silent: no IMachineKinematics → Orientation-Vector--NoKinematics; no rotary axes → Orientation-Vector--NoRotaryAxes; solver failure → Orientation-Vector--IkFailed. In every case the XYZ motion proceeds and the posture holds at its previous value (deliberately unlike the CLSF path, which drops the motion on IK failure — divergence recorded on the plan card). The section itself stays on the block as the semantic record. public class OrientationVectorResolveSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object OrientationVectorResolveSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples No-kinematics degradation — the error diagnostic is emitted, no MC write happens, and the section survives as the semantic record (the conformance check verifies only the JSON shape): #BeforeBuild: { \"ToolOrientation\": { \"Vector\": { \"X\": 0.5, \"Y\": 0, \"Z\": 0.8660254 }, \"Term\": \"TX/TY/TZ\" } } #AfterBuild: { \"ToolOrientation\": { \"Vector\": { \"X\": 0.5, \"Y\": 0, \"Z\": 0.8660254 }, \"Term\": \"TX/TY/TZ\" } } Constructors OrientationVectorResolveSyntax() Initializes a new instance with default settings. public OrientationVectorResolveSyntax() OrientationVectorResolveSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public OrientationVectorResolveSyntax(XElement src) Parameters src XElement Source XML element. Fields SurfaceNormalKey Block-root section carrying the surface-normal vector — the 3D tool-compensation direction, parse-and-carry (compensation along the normal is recognized, not simulated). Same Vector/Term shape as ToolOrientationKey. public const string SurfaceNormalKey = \"SurfaceNormal\" Field Value string TermKey Term key naming the brand word the vector came from. public const string TermKey = \"Term\" Field Value string ToolOrientationKey Block-root section carrying the commanded tool-axis direction: { “Vector”: {X,Y,Z}, “Term”: “<brand word>” }. Written by a brand adapter (unit vector, program coordinates), consumed here, and left on the block as the semantic record. public const string ToolOrientationKey = \"ToolOrientation\" Field Value string VectorKey Vector sub-object key shared by both sections. public const string VectorKey = \"Vector\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. ReadVector(JsonObject) Reads the Vector sub-object of section as a Vec3d; null when absent or non-numeric. public static Vec3d ReadVector(JsonObject section) Parameters section JsonObject Returns Vec3d Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.PeckDrillingCycleSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.PeckDrillingCycleSyntax.html",
    "title": "Class PeckDrillingCycleSyntax | HiAPI-C# 2025",
    "summary": "Class PeckDrillingCycleSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll G83 peck drilling cycle. Supports modal repetition. Drills in increments of depth Q, fully retracting to R between strokes. Cycle sequence (per stroke): Rapid to init position (target XY, previous Z) Rapid from init to R-point For each stroke: rapid to clearance above previous depth, feed Q deeper, rapid back to R If remainder exists: feed to bottom Z, rapid to R Rapid from R/bottom to final (G98 → init Z, G99 → R) Retraction distance is read from ICannedCycleConfig (Fanuc #4002 / Syntec Pr4002, or FallbackConfig fallback). Reads absolute coordinates from the cycle section, which is resolved by CannedCycleResolveSyntax (modal repetition, G91 conversion, missing-axis fallback) before this syntax runs. Must be placed after CannedCycleResolveSyntax and before IncrementalResolveSyntax in the syntax chain. public class PeckDrillingCycleSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object PeckDrillingCycleSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Both cases below pre-populate CannedCycle as CannedCycleResolveSyntax would have written it. There is no #Previous:, so GetLastProgramXyz returns Vec3d.Zero → initZ = 0. A FallbackConfig dep with the default PeckRetractionDistance_mm = 5 is injected via BuildAndDump(..., deps:). Cycle parameters are chosen so totalFeedLength = R − bottomZ = 10 and Q = 10 → exactly one stroke, no remainder; the items list stays minimal. G83 G98 — rapid to init (z=0), rapid to R=2, feed to bottom Z=-8 at F=600 mm/min → 10 mm/s, rapid back to R=2, then a final rapid to init Z=0 (G98). Five items: #BeforeBuild: { \"Parsing\": { \"G83\": { \"X\": 50, \"Y\": 30, \"Z\": -8, \"R\": 2, \"Q\": 10, \"F\": 600 } }, \"CannedCycle\": { \"Term\": \"G83\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -8, \"R\": 2, \"Q\": 10 } } } #AfterBuild: { \"CannedCycle\": { \"Term\": \"G83\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -8, \"R\": 2, \"Q\": 10 } }, \"Feedrate\": { \"FeedrateValue\": 600, \"Term\": \"G94\", \"Unit\": \"mm/min\" }, \"CompoundMotion\": { \"Term\": \"G83\", \"Items\": [ { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 2 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": -8 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"Feedrate_mmds\": 10 } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 2 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } } ] }, \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 } } G83 G99 — same cycle but the return mode is R-point. Since the retract-to-R rapid already lands at z = R, the finalZ != rPoint guard skips the extra final-rapid item. Four items, and the block's ProgramXyz lookback anchor lands at R-point: #BeforeBuild: { \"Parsing\": { \"G83\": { \"X\": 50, \"Y\": 30, \"Z\": -8, \"R\": 2, \"Q\": 10, \"F\": 600 } }, \"CannedCycle\": { \"Term\": \"G83\", \"ReturnMode\": \"G99\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -8, \"R\": 2, \"Q\": 10 } } } #AfterBuild: { \"CannedCycle\": { \"Term\": \"G83\", \"ReturnMode\": \"G99\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -8, \"R\": 2, \"Q\": 10 } }, \"Feedrate\": { \"FeedrateValue\": 600, \"Term\": \"G94\", \"Unit\": \"mm/min\" }, \"CompoundMotion\": { \"Term\": \"G83\", \"Items\": [ { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 2 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": -8 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"Feedrate_mmds\": 10 } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 2 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } } ] }, \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 2 } } Remarks G73 (high-speed peck) retracts only a small distance instead of fully back to R — see HighSpeedPeckCycleSyntax. Constructors PeckDrillingCycleSyntax() Initializes a new instance with default settings. public PeckDrillingCycleSyntax() PeckDrillingCycleSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public PeckDrillingCycleSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.PivotTransformUtil.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.PivotTransformUtil.html",
    "title": "Class PivotTransformUtil | HiAPI-C# 2025",
    "summary": "Class PivotTransformUtil Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Shared engine for the brand pivot-gate syntaxes (PivotTransformationSyntax — ISO/Fanuc family, SiemensPivotTransformationSyntax — Siemens). Each brand syntax owns only its gate (which modal terms mean “commanded XYZ needs the Pn→MC kinematic rigid transform”); the endpoint-ABC resolution and the PivotTransform chain entry composition live here so every brand writes the identical JSON vocabulary. public static class PivotTransformUtil Inheritance object PivotTransformUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods ComposePivotEntry(LazyLinkedListNode<SyntaxPiece>, JsonObject, List<INcDependency>) Composes the PivotTransformSource entry for the block's endpoint ABC — the shared body every brand gate runs after it decides the block needs the kinematic pivot. Silently no-ops when IMachineKinematics is absent (3-axis configurations without rotary kinematics). The entry's kind mirrors HasDynamicEntry(JsonObject): when no Dynamic entry exists (RTCP with stable rotary, or a tilted plane without RTCP), the kinematic pivot is contour-valid and stays Static. public static void ComposePivotEntry(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, JsonObject json, List<INcDependency> ncDependencyList) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> json JsonObject ncDependencyList List<INcDependency> ResolveEndpointAbc(LazyLinkedListNode<SyntaxPiece>, IMachineAxisConfig) Reads the current block's MC ABC, falling back per-axis to modal lookback (via FindPreviousMcXyzabc(LazyLinkedListNode<SyntaxPiece>, IMachineAxisConfig)) for rotary axes the machine declares but the current section does not carry — blocks like G49, comments, or pure non-motion state changes do not rewrite ABC, yet the kinematic rotary state is still active and must appear in the chain. Non-rotary axes default to 0. Also used by SiemensTraoriSyntax, whose tool-height entry needs the same endpoint semantics. public static Vec3d ResolveEndpointAbc(LazyLinkedListNode<SyntaxPiece> node, IMachineAxisConfig axisConfig) Parameters node LazyLinkedListNode<SyntaxPiece> axisConfig IMachineAxisConfig Returns Vec3d"
  },
  "api/Hi.NcParsers.LogicSyntaxs.PivotTransformationSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.PivotTransformationSyntax.html",
    "title": "Class PivotTransformationSyntax | HiAPI-C# 2025",
    "summary": "Class PivotTransformationSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll ISO/Fanuc-family pivot gate: writes the PivotTransformSource entry into ProgramToMcTransform on blocks where the controller is interpreting commanded XYZ in a frame that needs the Pn→MC kinematic rigid transform — namely active RTCP (G43.4) or active tilted plane (G68/G68.2). On plain-mode blocks (no RTCP, no tilted plane), the controller treats commanded XYZ as machine-frame directly, so the indexed rotary angle is a positioning value only and must not fold into the linear axes; this syntax skips those blocks and leaves the chain at identity (or whatever non-kinematic offsets earlier syntaxes contributed). Brand variants with their own modal vocabulary gate the same shared engine (PivotTransformUtil): Siemens TRAORI/CYCLE800 → SiemensPivotTransformationSyntax; Heidenhain M128/PLANE SPATIAL would follow the same pattern. Mirrors real Fanuc semantics: plain G43 offsets along the active tilted-plane normal (or machine Z when no tilt is active), and plain XYZ moves map directly to machine axis registers regardless of indexed table/head rotary position. Only G43.4 follows the live tool vector and only G68.2 redefines the work-plane orientation — both of which this guard detects via the existing chain markers. Chain position: must run after all Pn-frame writers (IsoG68p2TiltSyntax, ToolHeightOffsetSyntax, G43p4RtcpSyntax, IsoCoordinateOffsetSyntax, brand-specific coord offset syntaxes) so the guard sees the finalised mode markers and the PivotTransform entry — when emitted — naturally lands as the last chain element. Must run before McXyzSyntax / ProgramXyzSyntax so they see the completed chain. Silently no-ops when IMachineKinematics is absent (3-axis configurations without rotary kinematics). public class PivotTransformationSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object PivotTransformationSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Real-kinematics cases below wire TestDeps.CodeKinematics with the default chain code [O][Z][A][w];[O][Y][X][B][S][t] — a table-A / head-B 5-axis machine. A is on the table side (rotates the workpiece around -X); B is on the head side (rotates the spindle around +Y). Both rotary pivot axes pass through the origin (0,0,0) of the chain root frame because CodeXyzabcChain uses zero-offset Branch.Attach between components — a real table-head machine usually has the spindle-B pivot offset from origin, but for the corpus the zero-offset chain keeps the matrices hand-verifiable. Realistic MachineCoordinateState carries A and/or B only; there is no C axis in this chain (5-axis machines have at most two rotary axes). Verification cue specific to this syntax: the zero-offset chain puts the machine-zero attacher at the origin, so the entry's translation anchor T(McToPn(0).Point) vanishes and the matrix reduces to K(abc)⁻¹ alone. Table-A rotation moves the workpiece's coordinate frame around the X axis through origin, so the four-basis probe of MakePivotTransformMat(IMachineKinematics, Vec3d) returns a pure rotation around X — case 3 below pulls out exactly Rx(45°) (no translation column) for table-A=45°. Head-B rotation maps every probe point through the same head-chain rotation, but because everything on the head side downstream of B is at origin before B applies, the rotation reduces to the identity on the probe set: K(abc) == K(0) == I and the entry collapses to identity. That is the symmetry the plain-mode bug fix relies on — head-side rotary was harmlessly writing identity matrices, while table-side rotary was silently rotating linear axes into MC. Plain-mode skip — kinematics dep is present but the block has no active tilted plane and no RTCP, so ShouldFoldKinematicPivot returns false and the syntax leaves the block untouched. This is the \"no work to do\" guard that prevents over-application of the kinematic transform on indexed-rotary plain XYZ moves: #BeforeBuild: {} #AfterBuild: {} Plain-mode skip with indexed rotary — same guard, but the block already carries a MachineCoordinateState.A = 45 indexed table angle (as a prior McAbcSyntax would have written). In a real Fanuc controller, commanded XYZ on this block goes straight to the machine axis registers regardless of A; the kinematic rotation must not be folded into the chain. Real XyzabcSolver dep is wired in so the guard is what stops the write (not the dep-guard at the top of Build): #BeforeBuild: { \"MachineCoordinateState\": { \"A\": 45 } } #AfterBuild: { \"MachineCoordinateState\": { \"A\": 45 } } Active RTCP signalled by a pre-existing Dynamic chain entry (as G43p4RtcpSyntax would have written when RTCP is active and ABC changes across the block). HasDynamicEntry(JsonObject) returns true, so the guard passes and the PivotTransform entry is written and tagged KindDynamic. The TestDeps.Kinematics stub makes MakePivotTransformMat(IMachineKinematics, Vec3d) collapse to identity: #BeforeBuild: { \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Dynamic\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } #AfterBuild: { \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Dynamic\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] }, { \"Source\": \"PivotTransform\", \"Kind\": \"Dynamic\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } Active G68.2 tilted plane — the current block carries the modal TiltTransform snapshot plus an existing Static TiltTransform chain entry (as IsoG68p2TiltSyntax would have written) and MachineCoordinateState.A = 45. The guard reads TiltTransform.Term = \"G68.2\" and passes; with real XyzabcSolver kinematics (table-A / head-B 5-axis), MakePivotTransformMat at abc = (π/4, 0, 0) produces the table-A Rx(45°) rigid matrix. No Dynamic entries in the chain so the new entry stays Static: #BeforeBuild: { \"TiltTransform\": { \"Term\": \"G68.2\", \"X\": 0, \"Y\": 0, \"Z\": 0, \"I\": 0, \"J\": 30, \"K\": 0 }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [ 1, 0, 0, 0, 0, 0.8660254037844387, 0.49999999999999994, 0, 0, -0.49999999999999994, 0.8660254037844387, 0, 0, 0, 0, 1 ] } ], \"MachineCoordinateState\": { \"A\": 45 } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"G68.2\", \"X\": 0, \"Y\": 0, \"Z\": 0, \"I\": 0, \"J\": 30, \"K\": 0 }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [ 1, 0, 0, 0, 0, 0.8660254037844387, 0.49999999999999994, 0, 0, -0.49999999999999994, 0.8660254037844387, 0, 0, 0, 0, 1 ] }, { \"Source\": \"PivotTransform\", \"Kind\": \"Static\", \"Mat4d\": [ 1, 0, 0, 0, 0, 0.7071067811865475, -0.7071067811865475, 0, 0, 0.7071067811865475, 0.7071067811865475, 0, 0, 0, 0, 1 ] } ], \"MachineCoordinateState\": { \"A\": 45 } } Constructors PivotTransformationSyntax() Initializes a new instance with default settings. public PivotTransformationSyntax() PivotTransformationSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public PivotTransformationSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.PlaneSelectSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.PlaneSelectSyntax.html",
    "title": "Class PlaneSelectSyntax | HiAPI-C# 2025",
    "summary": "Class PlaneSelectSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Consumes G17/G18/G19 plane selection from Flags and writes IPlaneSelectDef section using conventional axis-pair names (XY/ZX/YZ). Modal — persists via backward lookback. Default is XY (G17). Downstream consumers (CircularMotionSyntax, IsoG68RotationSyntax) call GetPlaneNormalDir(JsonObject) to read the resolved plane. public class PlaneSelectSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object PlaneSelectSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G17\"] } } #AfterBuild: { \"PlaneSelect\": { \"Term\": \"G17\", \"Plane\": \"XY\" } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G18\", \"M03\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\"] }, \"PlaneSelect\": { \"Term\": \"G18\", \"Plane\": \"ZX\" } } #Previous: { \"PlaneSelect\": { \"Term\": \"G19\", \"Plane\": \"YZ\" } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M03\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\"] }, \"PlaneSelect\": { \"Term\": \"G19\", \"Plane\": \"YZ\" } } Properties Default Default instance with standard settings. public static PlaneSelectSyntax Default { get; } Property Value PlaneSelectSyntax Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress GetPlaneNormalDir(JsonObject) Reads the PlaneSelect section and returns the perpendicular (normal) axis index: XY→2(Z), ZX→1(Y), YZ→0(X). public static int GetPlaneNormalDir(JsonObject json) Parameters json JsonObject Returns int MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.PolarGCodeCheckSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.PolarGCodeCheckSyntax.html",
    "title": "Class PolarGCodeCheckSyntax | HiAPI-C# 2025",
    "summary": "Class PolarGCodeCheckSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Warns on G-codes that Fanuc disallows during Polar Coordinate Interpolation (G12.1), per the manual whitelist mirrored from HardNc IsGCodePolarModeCompatible (IncompatibleDiagId). Placed FIRST in the Logic bundle so the scan sees Parsing Flags before the mode/plane/offset syntaxes consume their codes — at the old in-place check position, G17/G18/G19, G20/G21, G49, G53.1 and G68/G69 cancels had already been eaten and passed silently. Polar-active detection needs no valve of its own: the PREVIOUS block's PolarInterpolationState is already final (the whole Logic bundle ran for it) unless this block exits with G13.1; a block entering with G12.1 is checked too. Residual blind spot (documented): codes captured as Parsing sub-objects by ParameterizedFlagSyntax in the Parsing bundle (G28, G43/G44, G43.4, G05.1, G52, G54.1, G68/G68.2, canned cycles) never reach Flags and stay outside the scan. They cannot corrupt the polar trajectory — the plane normal is fixed by the polar pair — so the gap is diagnostic-only, same as HardNc's own per-code parse-time check. public class PolarGCodeCheckSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object PolarGCodeCheckSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors PolarGCodeCheckSyntax() Initializes a new instance with default settings. public PolarGCodeCheckSyntax() PolarGCodeCheckSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public PolarGCodeCheckSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.PolarInterpolationSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.PolarInterpolationSyntax.html",
    "title": "Class PolarInterpolationSyntax | HiAPI-C# 2025",
    "summary": "Class PolarInterpolationSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Maintains the modal Polar Coordinate Interpolation valve section (PolarInterpolationState) for Fanuc G12.1/G13.1. On a G12.1 block: consumes the flag, reads the block's own X/C words as the anchor (InitRxcz; the X word is a diameter and is halved), converts the previous program position (program X/Z + machine C angle) onto the polar hypothetical plane via GetProgramPolarRxczByOrdinaryProgramXcz(Vec3d), and writes both the state section and the entry ProgramPolarRxcz position. Mirrors HardNc HardNcLine case 12_100. On a G13.1 block: consumes the flag and stops carrying the state — the block itself is already Cartesian, matching HardNc case 13_100. On other blocks: re-materializes the previous block's state section (single-step lookback carry, the PositioningSyntax pattern), and warns FanucPolar--IncompatibleGCode for G-codes outside the Fanuc polar-mode whitelist (mirrors HardNc IsGCodePolarModeCompatible). Must be placed before McAbcSyntax so the downstream ProgramRxczSyntax can consume the hypothetical C word before it is interpreted as a rotary machine axis. public class PolarInterpolationSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object PolarInterpolationSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Bare G12.1 entry — anchor words absent so InitRxcz is zero; the entry position is the previous stored program position (program X/Z with the previous machine C angle) mapped onto the hypothetical plane: #Previous: { \"ProgramXyz\": { \"X\": 58, \"Y\": 0, \"Z\": 25 }, \"MachineCoordinateState\": { \"X\": 58, \"Y\": 0, \"Z\": 25, \"C\": 0 } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G12.1\"] } } #AfterBuild: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"ProgramPolarRxcz\": { \"X\": 58, \"Y\": 0, \"Z\": 25 } } G12.1 X10 C0 — the block's own words anchor InitRxcz (X diameter 10 → radius 5) and the entry position is stored relative to that anchor: #Previous: { \"ProgramXyz\": { \"X\": 58, \"Y\": 0, \"Z\": 25 }, \"MachineCoordinateState\": { \"X\": 58, \"Y\": 0, \"Z\": 25, \"C\": 0 } } #BeforeBuild: { \"Parsing\": { \"X\": 10, \"C\": 0, \"Flags\": [\"G12.1\"] } } #AfterBuild: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 5, \"Y\": 0, \"Z\": 0 } }, \"ProgramPolarRxcz\": { \"X\": 53, \"Y\": 0, \"Z\": 25 } } Carry — no G12.1/G13.1 edge on the block, previous block is in polar mode, so the state section is re-materialized; other parsing content is untouched (G01 is polar-compatible, no diagnostic): #Previous: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G01\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"G01\"] }, \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } } } G13.1 — the flag is consumed and the state is not carried; the block is already Cartesian: #Previous: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G13.1\"] } } #AfterBuild: {} G12.1 repeated while polar mode is already active — HardNc keeps the old anchor (the modal flag does not change), so the state is carried unchanged and the block's axis words are left for ProgramRxczSyntax to treat as plain polar motion: #Previous: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } } } #BeforeBuild: { \"Parsing\": { \"X\": 20, \"Flags\": [\"G12.1\"] } } #AfterBuild: { \"Parsing\": { \"X\": 20 }, \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } } } Constructors PolarInterpolationSyntax() Initializes a new instance with default settings. public PolarInterpolationSyntax() PolarInterpolationSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public PolarInterpolationSyntax(XElement src) Parameters src XElement Source XML element. Fields IncompatibleDiagId Diagnostic id for G-codes that Fanuc disallows during polar coordinate interpolation (per the Fanuc manual whitelist). Emitted by PolarGCodeCheckSyntax, which runs at the FRONT of the Logic bundle so mode/plane/offset codes (G17-G19, G20/G21, G49, ...) are still visible in Parsing.Flags when the scan runs; see its doc for the residual parameterized-code blind spot. public const string IncompatibleDiagId = \"FanucPolar--IncompatibleGCode\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string Pair The polar axis pair this machine runs G12.1 with — DirXC (default), DirYA or DirZB. Machine configuration (Fanuc selects the pair by parameters, not by NC words), carried per project through this syntax's XML. Written into the state section's Dir for every downstream reader. public string Pair { get; set; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.PositioningSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.PositioningSyntax.html",
    "title": "Class PositioningSyntax | HiAPI-C# 2025",
    "summary": "Class PositioningSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Detects G90/G91 positioning mode from Flags (or by modal lookback) and writes a Positioning section (Term, Mode) to the block JSON. Fanuc/ISO: reads G90/G91 from Flags (global modal). Heidenhain: klartext has no modal word — the modal state stays at the G90 default and the I-prefixed words (IX+20) ride on the same per-word override as Siemens, stamped by the L / C / CC / CYCL CALL POS parsers (see HeidenhainIncrementalAxisWordUtil); the DIN/ISO dialect on that brand uses G90/G91 like Fanuc. Siemens: the AC()/IC() per-word override rides on top of this modal state — SiemensAcIcSyntax writes a PositioningOverride section the downstream consumers (IncrementalResolveSyntax, McAbcSyntax) honor per axis. Does NOT convert incremental values — that is handled by IncrementalResolveSyntax which can be placed later in the syntax chain, after canned cycle syntaxes have consumed their parameters with cycle-specific G91 semantics. public class PositioningSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object PositioningSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples G90 explicit — flag consumed, Positioning written with Mode=“Absolute”: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G90\"] } } #AfterBuild: { \"Positioning\": { \"Term\": \"G90\", \"Mode\": \"Absolute\" } } G91 explicit — flag consumed, Mode=“Incremental”: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G91\"] } } #AfterBuild: { \"Positioning\": { \"Term\": \"G91\", \"Mode\": \"Incremental\" } } No positioning flag on the block but #Previous: carried G91 — modal lookback inherits G91; the unrelated M03 flag is left alone: #Previous: { \"Positioning\": { \"Term\": \"G91\", \"Mode\": \"Incremental\" } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M03\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\"] }, \"Positioning\": { \"Term\": \"G91\", \"Mode\": \"Incremental\" } } Blank line — the piece has no Parsing at all, yet still receives the carried Positioning section. Real controllers give blank lines no meaning, so the modal chain must survive them; without this carry the next block's single-step lookback would silently reset a G91 program to the G90 default: #Previous: { \"Positioning\": { \"Term\": \"G91\", \"Mode\": \"Incremental\" } } #BeforeBuild: {} #AfterBuild: { \"Positioning\": { \"Term\": \"G91\", \"Mode\": \"Incremental\" } } Properties Default Default instance with standard settings. public static PositioningSyntax Default { get; } Property Value PositioningSyntax Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.ProgramEndCleanSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.ProgramEndCleanSyntax.html",
    "title": "Class ProgramEndCleanSyntax | HiAPI-C# 2025",
    "summary": "Class ProgramEndCleanSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Clears the per-block Vars.Volatile dictionary on blocks that triggered program end (M02 / M30, identified by the ProgramEnd section written by ProgramEndSyntax). Real Fanuc clears non-retained common variables (#100-#499) on program end + reset; this syntax models that behaviour at the simulator level. The clear happens on the same block that carried M02/M30 — the next block's VolatileVariableReadingSyntax carry then sees an empty dictionary on the predecessor and starts fresh. Pipeline placement: must run after both ProgramEndSyntax (which writes the ProgramEnd section this syntax checks) and VolatileVariableReadingSyntax (so the carry has already happened on this block; this syntax overwrites the result). Retained common variables (#500-#999, owned by RetainedCommonVariableTable) are untouched — they survive program end on real hardware (NV-RAM). Local variables (#1-#33, scope: macro call frame) are also untouched here; their lifecycle belongs to G65/G66/M99 push/pop, not program end. Also clears any active FanucModalMacro on the same edge: a G66 modal that was still active when M02/M30 hit is implicitly cancelled, matching real Fanuc reset behaviour. The section is overwritten with a G67-shaped cancel marker so the carry mechanism in FanucModalMacroSyntax sees the boundary and does not propagate the modal past the program-end edge. public class ProgramEndCleanSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object ProgramEndCleanSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples M30 with a populated Vars.Volatile — the dictionary is wiped to an empty JsonObject in place (assignment, not removal, so downstream snapshots can distinguish “cleared on program end” from “block never had volatile data”): #BeforeBuild: { \"ProgramEnd\": { \"Term\": \"M30\" }, \"Vars\": { \"Volatile\": { \"#100\": 1.5, \"#101\": 2.5 } } } #AfterBuild: { \"ProgramEnd\": { \"Term\": \"M30\" }, \"Vars\": { \"Volatile\": {} } } M02 with an active G66 FanucModalMacro and no pre-existing Vars — the modal is overwritten with a G67-shaped cancel marker (P/L dropped), and a fresh Vars.Volatile dictionary is created: #BeforeBuild: { \"ProgramEnd\": { \"Term\": \"M02\" }, \"FanucModalMacro\": { \"Term\": \"G66\", \"P\": 1234, \"L\": 1 } } #AfterBuild: { \"ProgramEnd\": { \"Term\": \"M02\" }, \"FanucModalMacro\": { \"Term\": \"G67\" }, \"Vars\": { \"Volatile\": {} } } No ProgramEnd on the block (regular machining line) — the guard rejects the block; Vars.Volatile is left intact for downstream blocks to inherit via carry: #BeforeBuild: { \"Vars\": { \"Volatile\": { \"#100\": 1.5 } } } #AfterBuild: { \"Vars\": { \"Volatile\": { \"#100\": 1.5 } } } Constructors ProgramEndCleanSyntax() Default constructor. public ProgramEndCleanSyntax() ProgramEndCleanSyntax(XElement) Loads from XML produced by MakeXmlSource(string, string, bool); no state. public ProgramEndCleanSyntax(XElement src) Parameters src XElement Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.ProgramEndSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.ProgramEndSyntax.html",
    "title": "Class ProgramEndSyntax | HiAPI-C# 2025",
    "summary": "Class ProgramEndSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Consumes M02/M30 (program end) from Flags and writes IProgramEndDef section. Downstream syntaxes that need to reset modal state on program end (e.g. IsoLocalCoordinateOffsetSyntax for G52 reset) should read the ProgramEnd section rather than scanning for M30 in Flags directly. The program-end edge. On a real controller M02/M30 ends the program and enters the reset state: the modal G codes return to their power-on defaults — tool length compensation is cancelled (G49, which also ends tool-center-point control: Fanuc TCP is cancelled by G49 or reset), the tilted work plane and coordinate rotation are cancelled (G69), cutter radius compensation is cancelled (G40), the canned cycle is cancelled (G80). A simulator that plays a file with several programs chained by M02 must keep playing, so the reset is modelled as an edge between the program-end block and its successor: the program-end block itself keeps the modal state it executed under (its own motion — G0 Z100. M30 — still sees the compensation), and the successor starts from the reset defaults. Each modal owner tests the edge with IsResetEdge(LazyLinkedListNode<SyntaxPiece>) in its single-step node.Previous lookback and writes its cancel state on the successor instead of carrying: ToolHeightOffsetSyntax (G43/G44 → G49), G43p4RtcpSyntax (G43.4 → G49), SiemensTraoriSyntax (TRAORI → TRAFOOF, the D compensation itself stays — Siemens retains the active tool on reset), HeidenhainRtcpSyntax (M128 / TCPM → off, TOOL CALL compensation stays), TiltTransformUtil (every tilt / rotation / frame term → G69), RadiusCompensationSyntax (G41/G42 → G40, the modal D is kept) and CannedCycleResolveSyntax (→ G80). Deliberately not reset: G00/G01, G90/G91, G17–G19, G94/G95, the work offset (G54–G59) and the path-smoothing mode — their reset defaults are controller-parameter dependent and they do not enter the program→machine transform chain; G20/G21 is retained by the controller itself. G52 keeps its existing behaviour of clearing on the program-end block (HardNc parity). A block right after the edge that has no words at all (a comment line) is still the edge — every owner handles it before any \"no Parsing\" early return, or the modal carry would clone the active section across it. Must be placed before syntaxes that depend on the ProgramEnd section. public class ProgramEndSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object ProgramEndSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M30\"] } } #AfterBuild: { \"ProgramEnd\": { \"Term\": \"M30\" } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M02\"] } } #AfterBuild: { \"ProgramEnd\": { \"Term\": \"M02\" } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M03\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\"] } } Constructors ProgramEndSyntax() Initializes a new instance with default settings. public ProgramEndSyntax() ProgramEndSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public ProgramEndSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress IsResetEdge(LazyLinkedListNode<SyntaxPiece>) True when node is the first block after a program end — its predecessor carries the ProgramEnd section (M02 / M30, or a brand equivalent such as klartext END PGM). Modal owners call this in their node.Previous lookback and, when true, write their reset (cancel) state on node instead of carrying the predecessor's modal forward — see the class summary for the set. The section is one-shot (never carried), so the edge is exactly one block wide. public static bool IsResetEdge(LazyLinkedListNode<SyntaxPiece> node) Parameters node LazyLinkedListNode<SyntaxPiece> Returns bool MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.ProgramRxczSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.ProgramRxczSyntax.html",
    "title": "Class ProgramRxczSyntax | HiAPI-C# 2025",
    "summary": "Class ProgramRxczSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Polar-mode sibling of ProgramXyzSyntax: while the PolarInterpolationState valve section is present, consumes the block's X/C/Z words as polar hypothetical-plane coordinates (X = diameter, halved; C = hypothetical axis in mm) and writes: ProgramPolarRxcz — the anchor-relative polar position (G90/G91 resolved against the previous block's position, mirroring HardNc NcGroup03.GetNcFromSyntax); ProgramXyz — the derived ordinary program position (radius, previous program Y, Z), so the downstream McXyzSyntax derives machine XYZ through the normal transform chain — ProgramXyzSyntax itself naturally no-ops because the axis words are already consumed; the machine C angle (degrees) into MachineCoordinateState — placed before McAbcSyntax, which then preserves the value instead of treating C as a directly-commanded rotary word; on motion-programmed blocks, MotionState and a MotionEvent with McPolarLinear (G00/G01) or McPolarArc (G02/G03 with R or I/J/K resolved on the hypothetical plane). The G12.1 entry block is skipped (its position was anchored by PolarInterpolationSyntax). Angle-branch resolution mirrors HardNc: GetOrdinaryProgramXcz_rad(Vec3d, double, Vec3d) chained from the previous machine C angle. public class ProgramRxczSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object ProgramRxczSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples G90 linear move along the radius axis — the X word is a diameter (X20 → radius 10), the missing C word carries over from the previous polar position, the machine C angle is written in degrees: #Previous: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"ProgramPolarRxcz\": { \"X\": 58, \"Y\": 0, \"Z\": 25 }, \"MachineCoordinateState\": { \"X\": 58, \"Y\": 0, \"Z\": 25, \"C\": 0 } } #BeforeBuild: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"Positioning\": { \"Term\": \"G90\", \"Mode\": \"Absolute\" }, \"Parsing\": { \"X\": 20, \"Z\": 2, \"Flags\": [\"G01\"] } } #AfterBuild: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"Positioning\": { \"Term\": \"G90\", \"Mode\": \"Absolute\" }, \"ProgramPolarRxcz\": { \"X\": 10, \"Y\": 0, \"Z\": 2 }, \"ProgramXyz\": { \"X\": 10, \"Y\": 0, \"Z\": 2 }, \"MachineCoordinateState\": { \"C\": 0 }, \"MotionState\": { \"Term\": \"G01\" }, \"MotionEvent\": { \"Form\": \"McPolarLinear\" } } Hypothetical-axis move to the 90° branch — the C word is a Cartesian millimeter coordinate on the hypothetical plane; the machine C angle follows by atan2 with chained branch resolution: #Previous: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"ProgramPolarRxcz\": { \"X\": 10, \"Y\": 0, \"Z\": 2 }, \"MachineCoordinateState\": { \"X\": 10, \"Y\": 0, \"Z\": 2, \"C\": 0 } } #BeforeBuild: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"Positioning\": { \"Term\": \"G90\", \"Mode\": \"Absolute\" }, \"Parsing\": { \"X\": 0, \"C\": 10, \"Flags\": [\"G01\"] } } #AfterBuild: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"Positioning\": { \"Term\": \"G90\", \"Mode\": \"Absolute\" }, \"ProgramPolarRxcz\": { \"X\": 0, \"Y\": 10, \"Z\": 2 }, \"ProgramXyz\": { \"X\": 10, \"Y\": 0, \"Z\": 2 }, \"MachineCoordinateState\": { \"C\": 90 }, \"MotionState\": { \"Term\": \"G01\" }, \"MotionEvent\": { \"Form\": \"McPolarLinear\" } } G02 arc on the hypothetical plane with an I word — I/J are start→center increments in plane millimeters (not halved, unlike the X endpoint word); the center is stored in anchor-origin (central) coordinates: #Previous: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"ProgramPolarRxcz\": { \"X\": 10, \"Y\": 0, \"Z\": 0 }, \"MachineCoordinateState\": { \"X\": 10, \"Y\": 0, \"Z\": 0, \"C\": 0 } } #BeforeBuild: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"Positioning\": { \"Term\": \"G90\", \"Mode\": \"Absolute\" }, \"Parsing\": { \"X\": 0, \"C\": -10, \"I\": -10, \"Flags\": [\"G02\"] } } #AfterBuild: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"Positioning\": { \"Term\": \"G90\", \"Mode\": \"Absolute\" }, \"ProgramPolarRxcz\": { \"X\": 0, \"Y\": -10, \"Z\": 0 }, \"ProgramXyz\": { \"X\": 10, \"Y\": 0, \"Z\": 0 }, \"MachineCoordinateState\": { \"C\": -90 }, \"MotionState\": { \"Term\": \"G02\" }, \"MotionEvent\": { \"Form\": \"McPolarArc\", \"ArcCenter\": { \"X\": 0, \"Y\": 0, \"Z\": 0 }, \"IsCcw\": false, \"AdditionalCircleNum\": 0 } } G91 incremental — the X increment is still a diameter value (halved), components without words stay put: #Previous: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"ProgramPolarRxcz\": { \"X\": 10, \"Y\": 0, \"Z\": 2 }, \"MachineCoordinateState\": { \"X\": 10, \"Y\": 0, \"Z\": 2, \"C\": 0 } } #BeforeBuild: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"Positioning\": { \"Term\": \"G91\", \"Mode\": \"Incremental\" }, \"Parsing\": { \"X\": 10, \"Z\": -1, \"Flags\": [\"G01\"] } } #AfterBuild: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"Positioning\": { \"Term\": \"G91\", \"Mode\": \"Incremental\" }, \"ProgramPolarRxcz\": { \"X\": 15, \"Y\": 0, \"Z\": 1 }, \"ProgramXyz\": { \"X\": 15, \"Y\": 0, \"Z\": 1 }, \"MachineCoordinateState\": { \"C\": 0 }, \"MotionState\": { \"Term\": \"G01\" }, \"MotionEvent\": { \"Form\": \"McPolarLinear\" } } Non-motion block inside polar mode (e.g. a bare M08) — the polar position is still carried and the derived sections written, but no motion sections appear and the unrelated flag is untouched: #Previous: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"ProgramPolarRxcz\": { \"X\": 10, \"Y\": 0, \"Z\": 2 }, \"MachineCoordinateState\": { \"X\": 10, \"Y\": 0, \"Z\": 2, \"C\": 0 } } #BeforeBuild: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"Positioning\": { \"Term\": \"G90\", \"Mode\": \"Absolute\" }, \"Parsing\": { \"Flags\": [\"M08\"] } } #AfterBuild: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"Positioning\": { \"Term\": \"G90\", \"Mode\": \"Absolute\" }, \"Parsing\": { \"Flags\": [\"M08\"] }, \"ProgramPolarRxcz\": { \"X\": 10, \"Y\": 0, \"Z\": 2 }, \"ProgramXyz\": { \"X\": 10, \"Y\": 0, \"Z\": 2 }, \"MachineCoordinateState\": { \"C\": 0 } } Constructors ProgramRxczSyntax() Initializes a new instance with default settings. public ProgramRxczSyntax() ProgramRxczSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public ProgramRxczSyntax(XElement src) Parameters src XElement Source XML element. Fields ArcCenterNotFoundDiagId Diagnostic id for a modal G02/G03 polar block whose arc center cannot be resolved (no R / I/J/K). Mirrors HardNc GetActSpiralMcXyzContour–CircleCenterNotFound. public const string ArcCenterNotFoundDiagId = \"FanucPolar--ArcCenterNotFound\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.ProgramStopSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.ProgramStopSyntax.html",
    "title": "Class ProgramStopSyntax | HiAPI-C# 2025",
    "summary": "Class ProgramStopSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Consumes the program-stop words in SupportedCodes (default M00 unconditional / M01 optional) from Flags and writes a IProgramStopDef section on the block that carried the flag. Non-modal: the section is written only on the exact block where the stop code appears. SupportedCodes is ordered by priority: when several listed words share a block the first listed one wins and stamps Term with its literal; every listed word is removed from the block either way. A brand preset widens the list for its own vocabulary (the Heidenhain STOP word — the SupportedCodes precedent). Siblings with ProgramEndSyntax (M02/M30) which handles end-of-program, not in-program stops. The parsing layer only records NC intent. Whether M01 actually pauses the run is a runtime/semantic decision gated by the operator's \"Optional Stop\" switch (analogous to IBlockSkipConfig for block skip). public class ProgramStopSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object ProgramStopSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M00\"] } } #AfterBuild: { \"ProgramStop\": { \"Term\": \"M00\" } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M01\", \"M03\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\"] }, \"ProgramStop\": { \"Term\": \"M01\" } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M01\", \"M00\"] } } #AfterBuild: { \"ProgramStop\": { \"Term\": \"M00\" } } Constructors ProgramStopSyntax() Initializes a new instance with default settings. public ProgramStopSyntax() ProgramStopSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public ProgramStopSyntax(XElement src) Parameters src XElement Source XML element. Only a MISSING SupportedCodes element (legacy bare XML) falls back to the default list; a present-but-empty element stays empty — the configured off-switch (the MachineCoordSelectSyntax precedent). Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string SupportedCodes Stop words consumed from Flags, ordered by priority (first listed word present on a block wins the Term stamp). Default [M00, M01]. public List<string> SupportedCodes { get; set; } Property Value List<string> XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.ProgramXyzSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.ProgramXyzSyntax.html",
    "title": "Class ProgramXyzSyntax | HiAPI-C# 2025",
    "summary": "Class ProgramXyzSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Resolves ProgramXyz (leaf coordinate) from syntax XYZ tags. Writes ProgramXyz sub-object to SyntaxPiece.JsonObject. Must be placed after BundleSyntax since it uses cross-node lookback for last position. McXyzSyntax (placed after this in the chain) reads ProgramXyz and writes MachineCoordinateState. public class ProgramXyzSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object ProgramXyzSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples SUT uses Default so the default WorkingPathList points at the Parsing root. All cases stay on the identity-transform path so GetLastProgramXyz simply returns the previous block's MC. Full X/Y/Z in Parsing — values are read directly (no lookback), Parsing.X/Y/Z are consumed, ProgramXyz section is written; CleanupParsing removes the now-empty Parsing: #BeforeBuild: { \"Parsing\": { \"X\": 10, \"Y\": 20, \"Z\": 30 } } #AfterBuild: { \"ProgramXyz\": { \"X\": 10, \"Y\": 20, \"Z\": 30 } } Only Z in Parsing with a #Previous: block carrying MachineCoordinateState=(50,60,70) — under the identity transform GetLastProgramXyz equals previous MC, so X/Y are inherited from prev and Z is taken from the parsed literal: #Previous: { \"MachineCoordinateState\": { \"X\": 50, \"Y\": 60, \"Z\": 70 } } #BeforeBuild: { \"Parsing\": { \"Z\": 0 } } #AfterBuild: { \"ProgramXyz\": { \"X\": 50, \"Y\": 60, \"Z\": 0 } } Parsing present but with no X/Y/Z (e.g. an unrelated M03 flag) — ResolveProgramXyz returns null and the syntax early-returns; the block is unchanged: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M03\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\"] } } Remarks The term “Program” is absolute positioning coordinate that can be end-user editing. The coordinate is usually the final node from the chain of coordinate transformation. Constructors ProgramXyzSyntax(List<List<string>>) Initializes a new instance with the given working path list. public ProgramXyzSyntax(List<List<string>> workingPathList) Parameters workingPathList List<List<string>> JSON paths to scan for axis values; see WorkingPathList. ProgramXyzSyntax(XElement) Initializes a new instance by deserializing the working path list from the given XML element. Falls back to Default.WorkingPathList when the element has no Path children. public ProgramXyzSyntax(XElement src) Parameters src XElement Source XML element. Properties Default Default instance with the working path resolving to the Parsing root. public static ProgramXyzSyntax Default { get; } Property Value ProgramXyzSyntax Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string WorkingPathList JSON paths where this syntax searches for axis values (X/Y/Z). Each path is a list of segments navigating nested JSON objects. First match is used. Empty list means root level. public List<List<string>> WorkingPathList { get; } Property Value List<List<string>> Examples [[\"L\"]] → fullJsonSrc[\"L\"] [[]] → fullJsonSrc (root) [[\"L\"], []] → try fullJsonSrc[\"L\"], fallback to root XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.ProgramXyzUtil.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.ProgramXyzUtil.html",
    "title": "Class ProgramXyzUtil | HiAPI-C# 2025",
    "summary": "Class ProgramXyzUtil Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Shared utilities for ProgramXyz and MachineCoordinateState lookback and resolution. Used by ProgramXyzSyntax, ReferenceReturnSyntax, and semantic resolvers that need position lookback. Two strategies for \"what's the program coordinate at a block's endpoint?\" — both invert an MC value through an ProgramToMcTransform chain, but they pick the chain from different nodes: By current-state transform (ComputeProgramXyzByCurrentTransform(LazyLinkedListNode<SyntaxPiece>, Vec3d)) — modal anchor is MachineCoordinateState. Re-expresses an MC value (typically a predecessor's modal MC) into the current block's program frame using the current block's chain. Suitable for chain-change blocks where the spindle physically stays put while the chain (G54 swap, G68.2 activation, G43.4 toggle, tool-height change, ...) re-anchors the program frame; mirrors legacy HardNcLine.RebuildProgramXyzByMc. By corresponding-state transform (ComputeProgramXyzByCorrespondingTransform(LazyLinkedListNode<SyntaxPiece>)) — modal anchor is ProgramXyz. Recovers the program coordinate that nodeCarryingMc was originally commanded at, by inverting that same node's own transform on its own MC. Suitable for RTCP rotary-dynamic inheritance, where the modal invariant is \"tool tip in workpiece frame stays put while rotary axes turn\" — the recovered Vec3d carries forward as the next rotary block's modal ProgramXyz unchanged, regardless of how its PivotTransform differs. Both strategies yield the same Vec3d when prev and current share the same chain modal state; they only diverge across chain boundaries (RTCP toggle, coord-system swap, tilt activation) and at rotary motion (PivotTransform difference). Pick the wrong one and the result lands in a stale frame: Non-RTCP using \"corresponding\" — leaves the pre-chain-change values, so a block emitted right after G43.4 H03 would inherit ProgramXyz still in the G49 frame and the next motion's MC.Z drifts by the introduced tool-height offset. (This was the 2026-04-25 SoftNc / HardNc divergence found on a five-axis sample program.) RTCP using \"current\" — double-counts the rotary PivotTransform difference, so the inherited workpiece anchor rotates by the C delta on every rotary block. Direct callers of the two strategy helpers are rare — typically you call the dispatcher ResolveBlockProgramXyz(LazyLinkedListNode<SyntaxPiece>, Vec3d) (block's own MC vs predecessor lookback, picks strategy from HasDynamicEntry(JsonObject)) or GetLastProgramXyz(LazyLinkedListNode<SyntaxPiece>) (pure predecessor lookback). public static class ProgramXyzUtil Inheritance object ProgramXyzUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods ComputeProgramXyzByCorrespondingTransform(LazyLinkedListNode<SyntaxPiece>) Strategy: by corresponding-state transform. Recovers the ProgramXyz that nodeCarryingMc was originally commanded at, by inverting that same node's ProgramToMcTransform on its own MachineCoordinateState. Modal invariant: ProgramXyz carries forward (RTCP rotary modal) — the workpiece-frame anchor survives downstream rotary motion regardless of how the next block's PivotTransform differs, so the next rotary-dynamic block can adopt this Vec3d unchanged as its modal ProgramXyz. Returns null when nodeCarryingMc has no usable MC. Called from the RTCP branch of GetLastProgramXyz(LazyLinkedListNode<SyntaxPiece>) and from ResolveBlockProgramXyz(LazyLinkedListNode<SyntaxPiece>, Vec3d) when the dispatched node has its own MC. public static Vec3d ComputeProgramXyzByCorrespondingTransform(LazyLinkedListNode<SyntaxPiece> nodeCarryingMc) Parameters nodeCarryingMc LazyLinkedListNode<SyntaxPiece> Returns Vec3d ComputeProgramXyzByCurrentTransform(LazyLinkedListNode<SyntaxPiece>, Vec3d) Strategy: by current-state transform. Re-expresses mc into currentNode's program frame by inverting currentNode's own ProgramToMcTransform chain. Modal invariant: MachineCoordinateState carries forward — between the source of mc and currentNode, the spindle physically stays put while the chain (G54 swap, G68.2 activation, G43.4 toggle, tool-height change, ...) re-anchors the program frame. Result is the program coordinate that, when transformed by currentNode's chain, yields mc back. Mirrors legacy HardNcLine.RebuildProgramXyzByMc; called from the non-RTCP branch of GetLastProgramXyz(LazyLinkedListNode<SyntaxPiece>). public static Vec3d ComputeProgramXyzByCurrentTransform(LazyLinkedListNode<SyntaxPiece> currentNode, Vec3d mc) Parameters currentNode LazyLinkedListNode<SyntaxPiece> mc Vec3d Returns Vec3d DidAbcChange(LazyLinkedListNode<SyntaxPiece>, IMachineAxisConfig) True when any rotary axis differs between the current block's MachineCoordinateState and the previous modal value (per-axis, 1e-9 rad tolerance; a NaN↔value transition counts as a change). Used by the RTCP syntaxes (G43p4RtcpSyntax, SiemensTraoriSyntax) to decide the KindDynamic tagging of the tool-height chain entry — when the tool orientation varies along the contour, the entry is an endpoint-only snapshot. public static bool DidAbcChange(LazyLinkedListNode<SyntaxPiece> node, IMachineAxisConfig axisConfig) Parameters node LazyLinkedListNode<SyntaxPiece> axisConfig IMachineAxisConfig Returns bool FindPreviousMc(LazyLinkedListNode<SyntaxPiece>) Finds the most recent MachineCoordinateState from previous SyntaxPiece nodes. Returns null if no previous position found. public static Vec3d FindPreviousMc(LazyLinkedListNode<SyntaxPiece> node) Parameters node LazyLinkedListNode<SyntaxPiece> Returns Vec3d FindPreviousMcXyzabc(LazyLinkedListNode<SyntaxPiece>, IMachineAxisConfig) Finds the most recent MachineCoordinateState XYZABC from previous nodes as DVec3d. Point = XYZ (mm), Normal = ABC (radians, converted from degrees in JSON). XYZ is taken from the first previous block whose MC has any of X/Y/Z set (typical motion-emitting block). ABC is then backfilled per axis for axes the machine actually has: if the XYZ-carrying block lacks a particular rotary value, we continue walking back to find the last block that wrote that axis (modal rotary state). This matches NC semantics — unchanged rotary axes carry forward silently — and prevents NaN rotary deltas from stopping ClLinearMcMotionSemantic's duration computation in RTCP contours where the XYZ block right before the current one didn't record ABC. In the standard pipeline the per-axis walks are BOUNDED: MergeKeys completes every block's section with the carried modal values, and HomeMcInitializer seeds every DECLARED axis on the first piece — so the nearest XYZ carrier already answers all declared axes and the backfill loop is a fallback only: for Logic-stage reads inside a RadiusCompensationSyntax look-forward window (dragged builds see not-yet-completed predecessors) and for pipelines without the carry. Both legs matter: without the home seed, a declared axis the program never writes would walk the whole history on every block. Do not remove the walks, and never let a new backward walk read frozen pieces per node without such a bound: each visited frozen piece re-parses its whole JSON snapshot, which made per-step cost grow with playback progress before the merge existed. axisConfig scopes the rotary-backfill to the machine's declared rotary axes (via GetRotaryAxes(IMachineAxisConfig)): non-rotary axes stay NaN and skip backward walking entirely. When axisConfig is null (callers without the dependency — e.g. legacy tests), all three A/B/C are attempted, matching the pre-axisConfig behaviour. Returns null if no previous MC with XYZ is found at all. Axes that have never been set stay NaN. public static DVec3d FindPreviousMcXyzabc(LazyLinkedListNode<SyntaxPiece> node, IMachineAxisConfig axisConfig = null) Parameters node LazyLinkedListNode<SyntaxPiece> axisConfig IMachineAxisConfig Returns DVec3d FindPreviousStoredProgramXyz(LazyLinkedListNode<SyntaxPiece>) Finds the most recent stored ProgramXyz from previous SyntaxPiece nodes — a raw-value lookback that returns whatever was written on disk, without MC-inversion or frame-change reconstruction. Contrast with GetLastProgramXyz(LazyLinkedListNode<SyntaxPiece>), which reconstructs the inherited program position as prev.MC × inverse(transform) and is sensitive to RTCP / chain-change boundaries. This helper is the simple parallel of FindPreviousMc(LazyLinkedListNode<SyntaxPiece>) — use it when a caller specifically needs \"what ProgramXyz did the last block write\" (e.g. the McAbcXyzFallbackSyntax spurious-origin guard). Not for per-block change checks: skipped blocks store nothing, so an anchor that only advances on writes makes every block of a motionless span re-walk the whole span — O(M²) full re-parses once the pieces are frozen (ProgramXyzBackfillSyntax used to, and now resolves its anchor one step from ComputeProgramXyzByCorrespondingTransform(LazyLinkedListNode<SyntaxPiece>) instead). Returns null if no predecessor has ProgramXyz. public static Vec3d FindPreviousStoredProgramXyz(LazyLinkedListNode<SyntaxPiece> node) Parameters node LazyLinkedListNode<SyntaxPiece> Returns Vec3d GetLastProgramXyz(LazyLinkedListNode<SyntaxPiece>) Gets the modal ProgramXyz inherited by node from the most recent predecessor with an MachineCoordinateState. Dispatches between the two strategies documented on the class summary based on whether node's ProgramToMcTransform chain carries any KindDynamic entry (queried via HasDynamicEntry(JsonObject)): Has a Dynamic entry (RTCP rotary modal) → ComputeProgramXyzByCorrespondingTransform(LazyLinkedListNode<SyntaxPiece>) on the predecessor (recover prev's commanded ProgramXyz; carries forward unchanged because workpiece-frame tool tip is the modal anchor). All entries Static (chain-change / non-RTCP) → ComputeProgramXyzByCurrentTransform(LazyLinkedListNode<SyntaxPiece>, Vec3d) with node's own transform on the predecessor's MC (re-express prev MC in current program frame; MC is the modal anchor while the chain re-frames around it). When prev and current share the same chain modal state both strategies agree, so the discriminator only matters at chain boundaries / rotary motion. Returns Zero only when no predecessor has a usable MC (i.e. the start of the program with no motion emitted). public static Vec3d GetLastProgramXyz(LazyLinkedListNode<SyntaxPiece> node) Parameters node LazyLinkedListNode<SyntaxPiece> Returns Vec3d ReadMcXyzabc(JsonObject) Reads XYZABC from a MachineCoordinateState section as DVec3d. Point = XYZ (mm), Normal = ABC (radians, converted from degrees in JSON). Missing axes are NaN. Returns null if the section doesn't exist or has no XYZ. public static DVec3d ReadMcXyzabc(JsonObject ncBlock) Parameters ncBlock JsonObject Returns DVec3d ResolveBlockProgramXyz(LazyLinkedListNode<SyntaxPiece>, Vec3d) Resolves the ProgramXyz at node's endpoint — i.e. what ProgramXyzBackfillSyntax would write on node. Dispatcher; the actual inversion math runs inside one of the two strategy helpers documented on the class summary: node has its own MachineCoordinateState XYZ → ComputeProgramXyzByCorrespondingTransform(LazyLinkedListNode<SyntaxPiece>) on node itself (its own MC and own transform; the \"current\" / \"corresponding\" distinction collapses since both come from the same node). node has no own MC and prevStored is non-null → GetLastProgramXyz(LazyLinkedListNode<SyntaxPiece>) walks back to the most recent predecessor with MC and dispatches strategy from node's HasDynamicEntry(JsonObject) result. Both empty → return null; callers must not fabricate a spurious origin on the very first block. Shared by ProgramXyzBackfillSyntax (computing the snapshot value to write on node) and McAbcXyzFallbackSyntax (computing Previous's would-be snapshot to inherit on the current rotary-dynamic block — the Logic-stage caller cannot read prev's stored ProgramXyz because PostSyntaxs run after the whole Logic chain finishes). prevStored for the second use is taken from FindPreviousStoredProgramXyz(LazyLinkedListNode<SyntaxPiece>) on node's predecessor — the predecessor-of-predecessor's stored ProgramXyz — only as a guard against the spurious-origin case. public static Vec3d ResolveBlockProgramXyz(LazyLinkedListNode<SyntaxPiece> node, Vec3d prevStored) Parameters node LazyLinkedListNode<SyntaxPiece> prevStored Vec3d Returns Vec3d ResolveProgramXyz(JsonNode, LazyLinkedListNode<SyntaxPiece>, ISentenceCarrier, NcDiagnosticProgress) Resolves X/Y/Z from a JSON section into absolute program coordinates. Fills missing axes from last program position via lookback. public static Vec3d ResolveProgramXyz(JsonNode xyzSource, LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, ISentenceCarrier sentenceCarrier, NcDiagnosticProgress diag) Parameters xyzSource JsonNode JSON node containing X/Y/Z keys (e.g., Parsing root, Parsing.G28, Parsing.L). syntaxPieceNode LazyLinkedListNode<SyntaxPiece> Current node for lookback. sentenceCarrier ISentenceCarrier Carrier used to attach diagnostics to the offending text span. diag NcDiagnosticProgress Diagnostic sink that receives parse errors for malformed X/Y/Z values. Returns Vec3d Absolute program coordinates, or null if no X/Y/Z found in xyzSource."
  },
  "api/Hi.NcParsers.LogicSyntaxs.ReferenceReturnSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.ReferenceReturnSyntax.html",
    "title": "Class ReferenceReturnSyntax | HiAPI-C# 2025",
    "summary": "Class ReferenceReturnSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Writes ICompoundMotionDef section for G28 reference point return. Reads intermediate XYZ from Parsing.G28 (written by G28Syntax) and converts to machine coordinates via ResolveProgramXyz(JsonNode, LazyLinkedListNode<SyntaxPiece>, ISentenceCarrier, NcDiagnosticProgress). Must be placed after LinearMotionSyntax in the syntax chain. Removes the IMotionEventDef section written by LinearMotionSyntax (G28 handles its own motion). Overwrites root MachineCoordinateState and ProgramXyz with reference position for subsequent block lookback. public class ReferenceReturnSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object ReferenceReturnSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples All cases hardcode a TestDeps.HomeMc with X/Y home at 0 and Z home at 100 (typical mill where Z-home is above the table) and leave the ProgramToMcTransform chain at identity so the final ProgramXyz equals MachineCoordinateState. The G28 pattern emits a 2-item CompoundMotion: item 0 is the intermediate point in ProgramXyz, item 1 is the final position in MachineCoordinateState. Axes not present in the G28 block keep the previous-block MC value rather than going home. G91 G28 X0 Y0 Z0 with a #Previous: block carrying MachineCoordinateState=(50,60,70) — all three axes go home, so the final MC is the configured home (0,0,100): #Previous: { \"MachineCoordinateState\": { \"X\": 50, \"Y\": 60, \"Z\": 70 } } #BeforeBuild: { \"Parsing\": { \"G28\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } } } #AfterBuild: { \"CompoundMotion\": { \"Term\": \"G28\", \"Items\": [ { \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true }, \"ProgramXyz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, { \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true }, \"MachineCoordinateState\": { \"X\": 0, \"Y\": 0, \"Z\": 100 } } ] }, \"ProgramXyz\": { \"X\": 0, \"Y\": 0, \"Z\": 100 } } G91 G28 Z0 — only Z goes to its home; X/Y inherit from the previous block's MC. Item 0's intermediate ProgramXyz takes X/Y from the inherited program XYZ (= previous MC under identity transform) and Z from the literal 0 in the G28 block: #Previous: { \"MachineCoordinateState\": { \"X\": 50, \"Y\": 60, \"Z\": 70 } } #BeforeBuild: { \"Parsing\": { \"G28\": { \"Z\": 0 } } } #AfterBuild: { \"CompoundMotion\": { \"Term\": \"G28\", \"Items\": [ { \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true }, \"ProgramXyz\": { \"X\": 50, \"Y\": 60, \"Z\": 0 } }, { \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true }, \"MachineCoordinateState\": { \"X\": 50, \"Y\": 60, \"Z\": 100 } } ] }, \"ProgramXyz\": { \"X\": 50, \"Y\": 60, \"Z\": 100 } } No IHomeMcConfig dep on the dependency list — the syntax early-returns and the G28 sub-section stays in Parsing for an upstream consumer or downstream syntax to handle: #BeforeBuild: { \"Parsing\": { \"G28\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } } } #AfterBuild: { \"Parsing\": { \"G28\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } } } Rotary cases below add TestDeps.AxisConfig declaring B as rotary and extend HomeMc with the conventional B home at 0°. Each rotary block uses literal B = 45° so item 0's intermediate (45°), item 1's home (0°), and #Previous: modal B (30°) are pairwise distinct — a test that swaps any two values for any other is caught by the assertion. The wrap pass (McAbcCyclicPathSyntax) is a different syntax, so these per-SUT conformance assertions show only the raw literal / canonical-home values written by this syntax, before any cyclic normalization runs. G91 G28 B45. — pure rotary G28. Emits a 2-item CompoundMotion whose items carry only ABC keys in MC; no XYZ ProgramXyz and no XYZ MC because the block doesn't reference X/Y/Z (and the conformance harness doesn't run McXyzSyntax downstream — in the full pipeline that syntax fills root MachineCoordinateState's XYZ from root ProgramXyz, but with no XYZ in the block there's nothing to fill anyway). Root MC.B holds the canonical home for modal carry-forward; root ProgramXyz is not written: #BeforeBuild: { \"Parsing\": { \"G28\": { \"B\": 45 } } } #AfterBuild: { \"MachineCoordinateState\": { \"B\": 0 }, \"CompoundMotion\": { \"Term\": \"G28\", \"Items\": [ { \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true }, \"MachineCoordinateState\": { \"B\": 45 } }, { \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true }, \"MachineCoordinateState\": { \"B\": 0 } } ] } } G28 X0. B45. mixed XYZ + rotary. Both axis kinds occupy the same two items: item 0 carries the XYZ intermediate ProgramXyz alongside the rotary literal in MC; item 1 carries the final XYZ MC alongside the rotary home in MC. Root MachineCoordinateState here holds only the rotary modal value (B = 0, the home); the XYZ portion of root MC would be filled by the downstream McXyzSyntax in the full pipeline (out of scope for this per-SUT conformance). Root MachineCoordinateState appears first because the rotary-home write happens before CompoundMotion / ProgramXyz are inserted. #Previous: carries B = 30 so the prev rotary modal is distinct from both the literal (45) and the home (0): #Previous: { \"MachineCoordinateState\": { \"X\": 50, \"Y\": 60, \"Z\": 70, \"B\": 30 } } #BeforeBuild: { \"Parsing\": { \"G28\": { \"X\": 0, \"B\": 45 } } } #AfterBuild: { \"MachineCoordinateState\": { \"B\": 0 }, \"CompoundMotion\": { \"Term\": \"G28\", \"Items\": [ { \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true }, \"ProgramXyz\": { \"X\": 0, \"Y\": 60, \"Z\": 70 }, \"MachineCoordinateState\": { \"B\": 45 } }, { \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true }, \"MachineCoordinateState\": { \"X\": 0, \"Y\": 60, \"Z\": 70, \"B\": 0 } } ] }, \"ProgramXyz\": { \"X\": 0, \"Y\": 60, \"Z\": 70 } } Bare G28 — no axis specifiers — exercises the configurable BareG28 policy. Default Alarm emits Coord-RefReturn--003 and consumes the G28 without motion (the diagnostic surfaces through the NcDiagnosticProgress sink, not the block JSON, so the canonical #AfterBuild is just an empty object): #BeforeBuild: { \"Parsing\": { \"G28\": {} } } #AfterBuild: {} Bare G28 with BareG28 set to AllAxesHome: the syntax synthesises a literal at the inherited program position for every configured linear axis and the previous modal angle for every configured rotary axis (here X/Y/Z taken from the #Previous: MC under the identity ProgramToMcTransform, B taken from the prev modal). Item 0's intermediate therefore equals current (no motion in stage 1) and item 1 sends each axis to its home: #Previous: { \"MachineCoordinateState\": { \"X\": 10, \"Y\": 20, \"Z\": 30, \"B\": 45 } } #BeforeBuild: { \"Parsing\": { \"G28\": {} } } #AfterBuild: { \"MachineCoordinateState\": { \"B\": 0 }, \"CompoundMotion\": { \"Term\": \"G28\", \"Items\": [ { \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true }, \"ProgramXyz\": { \"X\": 10, \"Y\": 20, \"Z\": 30 }, \"MachineCoordinateState\": { \"B\": 45 } }, { \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true }, \"MachineCoordinateState\": { \"X\": 0, \"Y\": 0, \"Z\": 100, \"B\": 0 } } ] }, \"ProgramXyz\": { \"X\": 0, \"Y\": 0, \"Z\": 100 } } Constructors ReferenceReturnSyntax() Initializes a new instance with default settings (BareG28 = Alarm). public ReferenceReturnSyntax() ReferenceReturnSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public ReferenceReturnSyntax(XElement src) Parameters src XElement Source XML element. Properties BareG28 Behaviour for a G28 block with no axis specifiers. Defaults to Alarm. public BareG28Behavior BareG28 { get; set; } Property Value BareG28Behavior Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.RotaryAxisUtil.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.RotaryAxisUtil.html",
    "title": "Class RotaryAxisUtil | HiAPI-C# 2025",
    "summary": "Class RotaryAxisUtil Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Shared utilities for rotary axis (A/B/C) resolution. Used by G53p1RotaryPositionSyntax, McAbcSyntax, IsoG68p2TiltSyntax, and other syntaxes that read or write rotary axis values. public static class RotaryAxisUtil Inheritance object RotaryAxisUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods ConsumeAxis(JsonObject, string, ISentenceCarrier, NcDiagnosticProgress) Consumes an optional axis value (degrees) from Parsing. Post-processor hints (e.g., A/B/C on G68.2 or G53.1 lines) are parsed by FloatTagSetupSyntax into Parsing as doubles. Returns the value and removes the key, or null if not present. A non-numeric value (e.g. \"#124\" left by the parser stage) raises VariableExpression--Unevaluated via GetParsedDouble(JsonObject, string, ISentenceCarrier, NcDiagnosticProgress) instead of silently dropping the post-processor hint. The key is consumed regardless so downstream syntaxes do not re-process it. public static double? ConsumeAxis(JsonObject parsing, string axisName, ISentenceCarrier sentenceCarrier, NcDiagnosticProgress diag) Parameters parsing JsonObject axisName string sentenceCarrier ISentenceCarrier diag NcDiagnosticProgress Returns double? GetRotaryAxes(IMachineAxisConfig) Gets the rotary axis names from the given IMachineAxisConfig. Returns an empty array if no rotary axes exist. public static string[] GetRotaryAxes(IMachineAxisConfig axisConfig) Parameters axisConfig IMachineAxisConfig Returns string[]"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensCircularMotionSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensCircularMotionSyntax.html",
    "title": "Class SiemensCircularMotionSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensCircularMotionSyntax Namespace Hi.NcParsers.LogicSyntaxs.Siemens Assembly HiMech.dll Siemens variant of CircularMotionSyntax (replaces it in the Siemens preset — do not run both): writes McArc motion for G02/G03 blocks from I/J/K center offsets or the Siemens signed radius CR= (captured as Parsing.CR by an equals-form FloatTagValueSyntax), with the helix turn count from TURN= (Parsing.TURN). Differences from the Fanuc/ISO parent, per the corpus-driven plan: CR replaces R — same math (ResolveCenterFromSignedRadius(Vec3d, Vec3d, int, bool, double); negative CR selects the >180° arc), but a CR full circle (start ≈ end on the plane) is invalid on Sinumerik and the chord collapse would produce a NaN center — rejected with Arc-CR--ClosedChord, params left visible. TURN=N means N additional full circles: AdditionalCircleNum = TURN + (closed ? 1 : 0) — no −1 (the legacy HardNc path treated TURN like Fanuc L and silently undercounted Siemens helices by one turn; deliberately not ported). The closed-loop +1 stacks on the same closure heuristic used when TURN is absent, because the downstream angle wrap yields 0 rad for closed arcs and the whole loop count must come from AdditionalCircleNum. No L and no K-as-pitch reading — Siemens L{n} is a subprogram call and helix travel is endpoint + TURN driven. Per-word absolute center: an I=AC(...) / J=AC(...) / K=AC(...) wrapper (unwrapped by SiemensAcIcSyntax into a numeric Parsing value plus a PositioningOverride entry) switches that one component from the default incremental offset-from-start to an absolute center coordinate (ResolveCenterFromMixedIjk(Vec3d, int, double, double, double, bool, bool, bool)); components without an entry — and IC()-wrapped ones — keep the incremental reading. Blocks without the section take the legacy ResolveCenterFromIjk(Vec3d, int, double, double, double) path byte-for-byte. Must be placed before LinearMotionSyntax (shared Group 01 motion slot). public class SiemensCircularMotionSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensCircularMotionSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples All cases run with the current block's ProgramXyz already set and no #Previous: unless noted, so GetLastProgramXyz returns Vec3d.Zero; G17 XY plane is implicit. CR= 90° arc: G02 from (0,0,0) to (10,10,0) with CR=10 — same center math as ISO R: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G02\"], \"CR\": 10 }, \"ProgramXyz\": { \"X\": 10, \"Y\": 10, \"Z\": 0 } } #AfterBuild: { \"ProgramXyz\": { \"X\": 10, \"Y\": 10, \"Z\": 0 }, \"MotionState\": { \"Term\": \"G02\" }, \"MotionEvent\": { \"Form\": \"McArc\", \"ArcCenter\": { \"X\": 10, \"Y\": 0, \"Z\": 0 }, \"IsCcw\": false, \"AdditionalCircleNum\": 0 } } Negative CR selects the >180° side — center flips across the chord relative to the case above: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G02\"], \"CR\": -10 }, \"ProgramXyz\": { \"X\": 10, \"Y\": 10, \"Z\": 0 } } #AfterBuild: { \"ProgramXyz\": { \"X\": 10, \"Y\": 10, \"Z\": 0 }, \"MotionState\": { \"Term\": \"G02\" }, \"MotionEvent\": { \"Form\": \"McArc\", \"ArcCenter\": { \"X\": 0, \"Y\": 10, \"Z\": 0 }, \"IsCcw\": false, \"AdditionalCircleNum\": 0 } } Corpus helix shape (G3 X.. Y.. Z.. I.. J.. TURN=16, reduced): I/J center on the begin plane, XY endpoint differs from start (open arc) so AdditionalCircleNum = TURN exactly — no −1: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G03\"], \"I\": 5, \"J\": 0, \"TURN\": 16 }, \"ProgramXyz\": { \"X\": 0, \"Y\": 5, \"Z\": -48 } } #AfterBuild: { \"ProgramXyz\": { \"X\": 0, \"Y\": 5, \"Z\": -48 }, \"MotionState\": { \"Term\": \"G03\" }, \"MotionEvent\": { \"Form\": \"McArc\", \"ArcCenter\": { \"X\": 5, \"Y\": 0, \"Z\": 0 }, \"IsCcw\": true, \"AdditionalCircleNum\": 16 } } Closed full circle with TURN=2 — base circle + 2 extra turns = 3 loops total; the closure +1 stacks on TURN because the downstream angle wrap contributes 0 rad for start == end: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G02\"], \"I\": 5, \"J\": 0, \"TURN\": 2 }, \"ProgramXyz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } } #AfterBuild: { \"ProgramXyz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 }, \"MotionState\": { \"Term\": \"G02\" }, \"MotionEvent\": { \"Form\": \"McArc\", \"ArcCenter\": { \"X\": 5, \"Y\": 0, \"Z\": 0 }, \"IsCcw\": false, \"AdditionalCircleNum\": 3 } } CR= with start ≈ end (invalid on Sinumerik — the chord defines no center): rejected with Arc-CR--ClosedChord; params stay visible as residue, and the modal MotionState is still recorded so following continuation arc blocks keep their circular mode (the G02 flag was already consumed): #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G02\"], \"CR\": 5 }, \"ProgramXyz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } } #AfterBuild: { \"Parsing\": { \"CR\": 5 }, \"ProgramXyz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 }, \"MotionState\": { \"Term\": \"G02\" } } Per-word absolute center (G2 X10 Y10 I=AC(10) J=AC(5) after unwrap + evaluation): begin is (10,0,0) from #Previous:, and the flagged I/J are the center coordinates themselves — an incremental misread would land on (20,5) instead. The override section stays on the block (nothing consumes it away): #Previous: { \"ProgramXyz\": { \"X\": 10, \"Y\": 0, \"Z\": 0 } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G02\"], \"I\": 10, \"J\": 5 }, \"PositioningOverride\": { \"I\": \"Absolute\", \"J\": \"Absolute\" }, \"ProgramXyz\": { \"X\": 10, \"Y\": 10, \"Z\": 0 } } #AfterBuild: { \"PositioningOverride\": { \"I\": \"Absolute\", \"J\": \"Absolute\" }, \"ProgramXyz\": { \"X\": 10, \"Y\": 10, \"Z\": 0 }, \"MotionState\": { \"Term\": \"G02\" }, \"MotionEvent\": { \"Form\": \"McArc\", \"ArcCenter\": { \"X\": 10, \"Y\": 5, \"Z\": 0 }, \"IsCcw\": false, \"AdditionalCircleNum\": 0 } } Mixed form — I=AC(10) J5: the absolute I is the center X, the plain J keeps the incremental offset-from-start reading; same center as above: #Previous: { \"ProgramXyz\": { \"X\": 10, \"Y\": 0, \"Z\": 0 } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G02\"], \"I\": 10, \"J\": 5 }, \"PositioningOverride\": { \"I\": \"Absolute\" }, \"ProgramXyz\": { \"X\": 10, \"Y\": 10, \"Z\": 0 } } #AfterBuild: { \"PositioningOverride\": { \"I\": \"Absolute\" }, \"ProgramXyz\": { \"X\": 10, \"Y\": 10, \"Z\": 0 }, \"MotionState\": { \"Term\": \"G02\" }, \"MotionEvent\": { \"Form\": \"McArc\", \"ArcCenter\": { \"X\": 10, \"Y\": 5, \"Z\": 0 }, \"IsCcw\": false, \"AdditionalCircleNum\": 0 } } Constructors SiemensCircularMotionSyntax() Initializes a new instance with default settings. public SiemensCircularMotionSyntax() SiemensCircularMotionSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public SiemensCircularMotionSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensCoordinateOffsetSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensCoordinateOffsetSyntax.html",
    "title": "Class SiemensCoordinateOffsetSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensCoordinateOffsetSyntax Namespace Hi.NcParsers.LogicSyntaxs.Siemens Assembly HiMech.dll Siemens Sinumerik: resolves work coordinate offset from G54–G57 (ISO-compatible), G505–G599 (extended Siemens), and G500 (cancel — machine coordinate mode). Reads from Flags, looks up IsoCoordinateTable dependency, composes into ProgramToMcTransform. public class SiemensCoordinateOffsetSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensCoordinateOffsetSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Unlike IsoCoordinateOffsetSyntax (Fanuc/ISO), this Siemens variant does not consume the coordinate flag from Parsing.Flags — the flag stays for downstream syntaxes / reconstruction. Mat4d arrays are 16 plain doubles in column-major order; pure translation by (tx,ty,tz) is [1,0,0,0, 0,1,0,0, 0,0,1,0, tx,ty,tz,1]. G54 with an IsoCoordinateTable providing G54 → (10, 20, -100) — same shape as IsoCoordinateOffsetSyntax but the G54 flag survives: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G54\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"G54\"] }, \"CoordinateOffset\": { \"CoordinateId\": \"G54\", \"Offset_X\": 10, \"Offset_Y\": 20, \"Offset_Z\": -100 }, \"ProgramToMcTransform\": [ { \"Source\": \"CoordinateOffset\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 10,20,-100,1] } ] } Siemens-extended G505 with a table entry for the same id — proves the syntax recognises the extended series, not only the ISO-compat G54–G57 subset: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G505\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"G505\"] }, \"CoordinateOffset\": { \"CoordinateId\": \"G505\", \"Offset_X\": 100, \"Offset_Y\": 50, \"Offset_Z\": -200 }, \"ProgramToMcTransform\": [ { \"Source\": \"CoordinateOffset\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 100,50,-200,1] } ] } G500 cancel with no IIsoCoordinateConfig on the dep list — falls back to Vec3d.Zero; the resolved offset is zero and the composed translation is identity (matching the special case inside GetCoordinateOffset(string) for G500): #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G500\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"G500\"] }, \"CoordinateOffset\": { \"CoordinateId\": \"G500\", \"Offset_X\": 0, \"Offset_Y\": 0, \"Offset_Z\": 0 }, \"ProgramToMcTransform\": [ { \"Source\": \"CoordinateOffset\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } Constructors SiemensCoordinateOffsetSyntax() Initializes a new instance with default settings. public SiemensCoordinateOffsetSyntax() SiemensCoordinateOffsetSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public SiemensCoordinateOffsetSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensCutCompModeSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensCutCompModeSyntax.html",
    "title": "Class SiemensCutCompModeSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensCutCompModeSyntax Namespace Hi.NcParsers.LogicSyntaxs.Siemens Assembly HiMech.dll Consumes the Siemens CUT3DC flag (3D circumferential cutter compensation mode, used with TRAORI) from Flags and records a non-modal block-root CutCompMode section. The offline RadiusCompensationSyntax only models the 2D plane modes, so a SiemensCutComp–Unsupported warning is emitted: a later G41/G42 in this program simulates as plane compensation, not as the control's 3D surface-normal offset — recognized, visibly not simulated, never a half-guess. Capture side: CUT3DC is a bare word collected by the Siemens preset's FlagSyntax word list. public class SiemensCutCompModeSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensCutCompModeSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild: { \"Parsing\": { \"Flags\": [\"CUT3DC\"] } } #AfterBuild: { \"CutCompMode\": { \"Term\": \"CUT3DC\" } } Constructors SiemensCutCompModeSyntax() Initializes a new instance with default settings. public SiemensCutCompModeSyntax() SiemensCutCompModeSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public SiemensCutCompModeSyntax(XElement src) Parameters src XElement Source XML element. Fields CutCompMode Block-root section key recording the consumed mode word. public const string CutCompMode = \"CutCompMode\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensCycle800TiltSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensCycle800TiltSyntax.html",
    "title": "Class SiemensCycle800TiltSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensCycle800TiltSyntax Namespace Hi.NcParsers.LogicSyntaxs.Siemens Assembly HiMech.dll Siemens CYCLE800 (swivel cycle): resolves the tilted work plane from the positional arguments captured by SiemensCycleCallSyntax and composes it into ProgramToMcTransform as the shared TransformSource entry — the Siemens sibling of IsoG68p2TiltSyntax its XmlDoc promises. Unlike Fanuc G68.2 (plane only), CYCLE800 also positions the rotary axes implicitly (the G53.1 half): with IMachineKinematics wired, the tilt normal is solved to machine ABC and written into MachineCoordinateState, and the block gets a non-modal rapid MotionEvent with Term = “CYCLE800” (mirroring G53p1RotaryPositionSyntax). Argument layout (HardNc reference NcArgCycle800): CYCLE800(FR, TC, ST, MODE, X0, Y0, Z0, A, B, C, X1, Y1, Z1, DIR [, FR_I, DMODE]) — 15- and 16-arg post variants both occur in the corpus. MODE is bit-coded: bits 7-6 select the swivel mode (00 axis-by-axis, 01 solid angle, 10 projection angle, 11 direct rotary), bit pairs 1-0/3-2/5-4 select each angle's axis (01=X, 10=Y, 11=Z). The motion-convention matrix is T(X1,Y1,Z1) · R · T(X0,Y0,Z0) (row-vector; the post-rotation zero offset applies innermost). ST units digit 1 composes additively onto the current programmable frame; FR/FR_I retraction and DIR solution preference are recorded in the section but not simulated (DIR = 0 suppresses the rotary positioning, per the control's frame-only variant). Cancel forms — bare CYCLE800, empty parentheses, the single-argument CYCLE800(0), or swivel-data-record name TC = \"0\" — reset the tilt to the shared inactive sentinel (Term = \"G69\" + identity entry, HardNc's convention). An in-between argument count (1–9 with a live TC) is treated as a truncated/unmodeled capture, not a cancel — warning + visible residue, so a mis-parsed call can never silently drop an active swivel. The rotary axes are not re-positioned on cancel: the retract/re-orient behavior depends on the machine's swivel data record, which does not exist offline; corpus programs follow the cancel with explicit G0 A.. C.. moves anyway. Fail-soft: a non-numeric argument (machine-runtime variable) leaves the Parsing.CYCLE800 residue visible and applies no transform (Coord-Tilt--003); an IK failure keeps the euler tilt and skips positioning (Coord-Tilt--004); a rotating CYCLE800 on a machine without kinematics/rotary axes keeps the tilt and warns (Coord-Tilt--005). Must run before SiemensProgrammableFrameSyntax (which owns the once-per-block TiltTransform modal carry and composes additive AROT/ATRANS onto this cycle's fresh matrix) and before the coordinate-offset syntaxes (chain order: frame entry ahead of CoordinateOffset). public class SiemensCycle800TiltSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensCycle800TiltSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Cancel via empty parentheses — tilt reset to the shared inactive sentinel: #BeforeBuild: { \"Parsing\": { \"CYCLE800\": { \"Args\": [] } } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"G69\" }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } Cancel via the bare word (corpus N140 CYCLE800 shape): #BeforeBuild: { \"Parsing\": { \"CYCLE800\": { \"Bare\": true } } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"G69\" }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } Cancel via swivel-data-record deselection (TC = “0”): #BeforeBuild: { \"Parsing\": { \"CYCLE800\": { \"Args\": [\"0\", \"\\\"0\\\"\", \"0\", \"57\"] } } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"G69\" }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } Full-parameter corpus shape, no kinematics dependency — the tilt is complete on its own (positioning would warn only when a rotation is commanded; here MODE 57 maps A→X, B→Y, C→Z and A=30 gives Rx(30°)). 15-arg “R_DATA” family with DIR = -1: #BeforeBuild: { \"Parsing\": { \"CYCLE800\": { \"Args\": [ \"1\", \"\\\"R_DATA\\\"\", \"0\", \"57\", \"0\", \"0\", \"0\", \"30\", \"0\", \"0\", \"0\", \"0\", \"0\", \"-1\", \"0\" ] } } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"CYCLE800\", \"TC\": \"R_DATA\", \"ST\": 0, \"MODE\": 57, \"X0\": 0, \"Y0\": 0, \"Z0\": 0, \"A\": 30, \"B\": 0, \"C\": 0, \"X1\": 0, \"Y1\": 0, \"Z1\": 0, \"DIR\": -1 }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [ 1, 0, 0, 0, 0, 0.8660254037844387, 0.49999999999999994, 0, 0, -0.49999999999999994, 0.8660254037844387, 0, 0, 0, 0, 1 ] } ] } Constructors SiemensCycle800TiltSyntax() Initializes a new instance with default settings. public SiemensCycle800TiltSyntax() SiemensCycle800TiltSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public SiemensCycle800TiltSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensFixedPointReturnSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensFixedPointReturnSyntax.html",
    "title": "Class SiemensFixedPointReturnSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensFixedPointReturnSyntax Namespace Hi.NcParsers.LogicSyntaxs.Siemens Assembly HiMech.dll Consumes the Siemens G74 (reference-point approach) / G75 (fixed-point approach) statement captured into Parsing.G74 / Parsing.G75 by the Siemens preset's dedicated ParameterizedFlagSyntax instance, and emits a one-shot machine-coordinate move for the participating axes. Siemens semantics honored here: non-modal; only the axes written in the block participate; the numeric axis value is a dummy (conventionally 0) and is discarded; the motion happens in MACHINE coordinates ignoring every active frame; the F word in the block does not change the modal feed (the machine travels at its own rapid). The frame bypass reuses the MachineCoordSelectSyntax mechanism — write MachineCoordinateState directly and back-derive ProgramXyz through the inverse of the composed ProgramToMcTransform — so a G54/G505 offset or programmable frame shifts the recovered program coordinate, never the machine target. Target position: G74 (reference-point approach) reads the per-axis machine reference from GetHomePosition(string) (MD34010 on a Siemens table; 0 when the axis has no configured home). G75 (fixed-point approach) reads the fixed-point table MD30600 $MA_FIX_POINT_POS via GetFixPointPosition(string), falling back per axis to the same reference position when no fixed point is configured — so machines whose fixed point differs from the reference retract to the right place. Only fixed point 1 is modeled; a FP= word in the block emits Coord-FixPoint--003 and uses fixed point 1. Non-participating linear axes keep the previous machine position; rotary axes participate only when written and configured rotary (their target lands in the shared MC section, wrapped shortest-path later by McAbcCyclicPathSyntax). Placement: after ReferenceReturnSyntax (the G28 slot) — behind every coordinate-offset / frame syntax so the composed transform is complete for the ProgramXyz back-derivation, and before McXyzSyntax / LinearMotionSyntax (the stamped MotionEvent makes the motion syntaxes skip the block; a G0/G1 word on the block is claimed into the modal MotionState exactly like MachineCoordSelectSyntax does). Without an IHomeMcConfig dependency the statement stays in Parsing and surfaces as unconsumed residue. public class SiemensFixedPointReturnSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensFixedPointReturnSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples All cases hardcode a TestDeps.HomeMc with X/Y home at 0 and Z home at 100, and leave the ProgramToMcTransform chain at identity so ProgramXyz equals MachineCoordinateState. The corpus shape N19 G75 Z0 F8000 — only Z participates (its dummy 0 is discarded), X/Y keep the previous machine position, the F stays inside the consumed statement (modal feed untouched), and a rapid one-shot machine move is stamped: #Previous: { \"MachineCoordinateState\": { \"X\": 50, \"Y\": 60, \"Z\": -20 } } #BeforeBuild: { \"Parsing\": { \"G75\": { \"Z\": 0, \"F\": 8000 } } } #AfterBuild: { \"MachineCoordinateState\": { \"X\": 50, \"Y\": 60, \"Z\": 100 }, \"ProgramXyz\": { \"X\": 50, \"Y\": 60, \"Z\": 100 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true, \"Term\": \"G75\" } } G74 X0 Z0 — reference-point approach for X and Z; Y keeps the previous machine position: #Previous: { \"MachineCoordinateState\": { \"X\": 50, \"Y\": 60, \"Z\": -20 } } #BeforeBuild: { \"Parsing\": { \"G74\": { \"X\": 0, \"Z\": 0 } } } #AfterBuild: { \"MachineCoordinateState\": { \"X\": 0, \"Y\": 60, \"Z\": 100 }, \"ProgramXyz\": { \"X\": 0, \"Y\": 60, \"Z\": 100 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true, \"Term\": \"G74\" } } Statement without any axis word — nothing participates, so the statement is consumed with a validation warning (Coord-FixPoint--001, diagnostic sink only) and no motion: #BeforeBuild: { \"Parsing\": { \"G75\": { \"F\": 8000 } } } #AfterBuild: {} G75 Z0 with a Siemens machine-data table carrying MD30600 $MA_FIX_POINT_POS Z = 1150 — the fixed point wins over the Z reference at 100 (840D-SL posts park at such a fixed point before M06); X/Y keep the previous machine position: #Previous: { \"MachineCoordinateState\": { \"X\": 50, \"Y\": 60, \"Z\": -20 } } #BeforeBuild: { \"Parsing\": { \"G75\": { \"Z\": 0 } } } #AfterBuild: { \"MachineCoordinateState\": { \"X\": 50, \"Y\": 60, \"Z\": 1150 }, \"ProgramXyz\": { \"X\": 50, \"Y\": 60, \"Z\": 1150 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true, \"Term\": \"G75\" } } G74 Z0 with the same table — G74 is the reference-point approach and deliberately ignores the fixed-point table; Z travels to the reference at 100: #Previous: { \"MachineCoordinateState\": { \"X\": 50, \"Y\": 60, \"Z\": -20 } } #BeforeBuild: { \"Parsing\": { \"G74\": { \"Z\": 0 } } } #AfterBuild: { \"MachineCoordinateState\": { \"X\": 50, \"Y\": 60, \"Z\": 100 }, \"ProgramXyz\": { \"X\": 50, \"Y\": 60, \"Z\": 100 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true, \"Term\": \"G74\" } } Constructors SiemensFixedPointReturnSyntax() Initializes a new instance with default settings. public SiemensFixedPointReturnSyntax() SiemensFixedPointReturnSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public SiemensFixedPointReturnSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensModalCycleSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensModalCycleSyntax.html",
    "title": "Class SiemensModalCycleSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensModalCycleSyntax Namespace Hi.NcParsers.LogicSyntaxs.Siemens Assembly HiMech.dll Maps Siemens MCALL CYCLE8x(…) modal drilling calls onto the shared canned-cycle machinery — the “setup half” of the Fanuc G66-style modal pattern; the “expansion half” needs no new code because CannedCycleResolveSyntax's previous-block modal lookback already re-triggers the armed cycle at every subsequent block carrying X/Y words, exactly Sinumerik's MCALL semantic. MCALL CYCLE81/82(RTP,RFP,SDIS,DP,DPR[,DTB]) → an armed CannedCycle section (Term G81/G82) with Params.R = RFP + |SDIS|, Params.Z = DP (or RFP − DPR), dwell P = DTB for G82. MCALL CYCLE83(…,FDEP,FDPR,DAM,DTB,DTS,FRF,VARI,…) → G83 (VARI≠0, full retract) or G73 (VARI=0, chip-break) with Q = |RFP − FDEP| or |FDPR|. The FDEP/DAM decreasing peck chain is approximated by that constant first-peck depth. MCALL CYCLE85(…,DTB,FFR,RFF) → G89 (DTB>0, dwell) or G85, feed-in F = FFR; the separate retract feed RFF has no slot in the shared expansion (retract reuses F). bare MCALL → the G80 cancel sentinel (WriteCannedCycleCancel(JsonObject, string)). The MCALL block itself must NOT execute the cycle (Sinumerik arms only), so no Parsing.G8x section is written here — the armed section rides the ModalCarrySyntax CannedCycle tracked key to the following motion blocks. Return plane: ReturnMode = G98 (previous-block Z); RTP has no slot in the shared expansion — programs that park at RTP before the first trigger get exactly RTP back, the corpus shape. Fail-soft paths (consume + structured warning + no arm): non-literal arguments (R-parameter args — cycle args bypass the P2 evaluator), missing RFP / depth / peck values, and any callee outside the CYCLE8x map (MCALL L123 modal subprogram calls are not simulated). Pipeline placement: before CannedCycleResolveSyntax in the Siemens Logic bundle. public class SiemensModalCycleSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensModalCycleSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Arm from the corpus 9-arg CYCLE81 Operate form — R = 327.9137 + 0.5, Z = DP, no immediate execution: #BeforeBuild: { \"Parsing\": { \"MCALL\": { \"CycleName\": \"CYCLE81\", \"Args\": [\"500.\", \"327.9137\", \"0.5\", \"324.564\", \"\", \"\", \"0\", \"1\", \"0\"] } } } #AfterBuild: { \"CannedCycle\": { \"Term\": \"G81\", \"ReturnMode\": \"G98\", \"Params\": { \"R\": 328.4137, \"Z\": 324.564 } } } Bare MCALL cancels — the G80 sentinel stops the modal lookback: #BeforeBuild: { \"Parsing\": { \"MCALL\": { \"Bare\": true } } } #AfterBuild: { \"CannedCycle\": { \"Term\": \"G80\" } } CYCLE83 chip-break variant routes to G73 with the first-peck Q: #BeforeBuild: { \"Parsing\": { \"MCALL\": { \"CycleName\": \"CYCLE83\", \"Args\": [\"50\", \"0.4\", \"2\", \"-10\", \"\", \"\", \"5\", \"3\", \"0\", \"0\", \"1\", \"0\"] } } } #AfterBuild: { \"CannedCycle\": { \"Term\": \"G73\", \"ReturnMode\": \"G98\", \"Params\": { \"R\": 2.4, \"Z\": -10, \"Q\": 5 } } } Constructors SiemensModalCycleSyntax() Parameterless instance (no XML state). public SiemensModalCycleSyntax() SiemensModalCycleSyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public SiemensModalCycleSyntax(XElement src) Parameters src XElement Root element named XName. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensPathSmoothingSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensPathSmoothingSyntax.html",
    "title": "Class SiemensPathSmoothingSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensPathSmoothingSyntax Namespace Hi.NcParsers.LogicSyntaxs.Siemens Assembly HiMech.dll Records the Siemens path-control / smoothing modal registers into the brand-invariant PathSmoothing section (fields per ISiemensPathSmoothingDef): the G-code groups G60/G64/G641/G642 (path control) and G601/G602 (exact-stop criterion) from Flags, the bare modal words FNORM / SOFT / BRISK / FFWON / FFWOF / COMPCAD / COMPON / COMPOF / UPATH / SPATH (captured by the preset's FlagSyntax word list), and the Parsing.CYCLE832 call sub-object (captured by SiemensCycleCallSyntax) whose first argument arms the high-speed tolerance (0 / empty parentheses cancel it). Record-only — simulation does not alter the tool path (same contract as the Fanuc G05.1 sibling FanucPathSmoothingSyntax, which this class replaces in the Siemens preset: that one reads only the Parsing[\"G05.1\"] sub-object no Siemens capture produces). IsEnabled is derived — true while a CYCLE832 tolerance is armed or the path-control group sits on a continuous-path mode (G64/G641/G642). Modal behavior: a block touching any group starts from a clone of the previous block's section, applies the touched groups and rewrites the section; untouched blocks write nothing and ModalCarrySyntax (whose TrackedKeys already contain PathSmoothing) carries the previous section forward. The stream's first block stamps a conservative { IsEnabled: false } default — the actual delivered state of a real control is machine-data dependent, so no term is invented for it. public class SiemensPathSmoothingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensPathSmoothingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Corpus header shape G60 G601 FNORM (reduced to this syntax's flags) on a first block — three groups recorded, exact stop means smoothing off: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G60\", \"G601\", \"FNORM\"] } } #AfterBuild: { \"PathSmoothing\": { \"IsEnabled\": false, \"PathControl\": \"G60\", \"Term\": \"G60\", \"ExactStopCriterion\": \"G601\", \"FeedProfile\": \"FNORM\" } } CYCLE832 arm on a block whose previous section holds the header registers — tolerance/mode recorded, IsEnabled flips, untouched groups inherit: #Previous: { \"PathSmoothing\": { \"IsEnabled\": false, \"PathControl\": \"G60\", \"ExactStopCriterion\": \"G601\", \"FeedProfile\": \"FNORM\", \"Term\": \"G60\" } } #BeforeBuild: { \"Parsing\": { \"CYCLE832\": { \"Args\": [\"0.05\", \"_ORI_FINISH\", \"0.8\"] } } } #AfterBuild: { \"PathSmoothing\": { \"IsEnabled\": true, \"PathControl\": \"G60\", \"ExactStopCriterion\": \"G601\", \"FeedProfile\": \"FNORM\", \"Term\": \"CYCLE832\", \"Tolerance\": 0.05, \"Mode\": \"_ORI_FINISH\" } } CYCLE832 cancel (empty parentheses) — tolerance/mode removed; the inherited continuous-path G642 keeps IsEnabled true (G64-family blending itself never stopped): #Previous: { \"PathSmoothing\": { \"IsEnabled\": true, \"PathControl\": \"G642\", \"Term\": \"CYCLE832\", \"Tolerance\": 0.01, \"Mode\": \"_FINISH\" } } #BeforeBuild: { \"Parsing\": { \"CYCLE832\": { \"Args\": [] } } } #AfterBuild: { \"PathSmoothing\": { \"IsEnabled\": true, \"PathControl\": \"G642\", \"Term\": \"CYCLE832\" } } Bare-word block SOFT FFWON (corpus shape) — auxiliary groups update, Term unchanged (no path-mode change on this block): #Previous: { \"PathSmoothing\": { \"IsEnabled\": true, \"PathControl\": \"G64\", \"Term\": \"G64\" } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"SOFT\", \"FFWON\"] } } #AfterBuild: { \"PathSmoothing\": { \"IsEnabled\": true, \"PathControl\": \"G64\", \"Term\": \"G64\", \"AccelProfile\": \"SOFT\", \"FeedForward\": \"FFWON\" } } Untouched first block — conservative default section only: #BeforeBuild: { \"Parsing\": { \"X\": 10 } } #AfterBuild: { \"Parsing\": { \"X\": 10 }, \"PathSmoothing\": { \"IsEnabled\": false } } Constructors SiemensPathSmoothingSyntax() Initializes a new instance with default settings. public SiemensPathSmoothingSyntax() SiemensPathSmoothingSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public SiemensPathSmoothingSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensPivotTransformationSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensPivotTransformationSyntax.html",
    "title": "Class SiemensPivotTransformationSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensPivotTransformationSyntax Namespace Hi.NcParsers.LogicSyntaxs.Siemens Assembly HiMech.dll Siemens pivot gate over the shared engine (PivotTransformUtil): writes the PivotTransformSource entry on blocks where commanded XYZ needs the Pn→MC kinematic rigid transform — active TRAORI RTCP (SiemensTraoriSyntax's ToolHeightCompensation.Term), an active swivel/tilt (CYCLE800, or a mixed-dialect G68/G68.2 term), or a Dynamic chain entry. The Siemens-specific exclusion: a plain geometric frame (TRANS/ATRANS/ROT/AROT, IsPlainGeometryFrame(string)) transforms coordinates only and implies no physically positioned rotaries, so it must not open the gate — a corpus TRANS X0 Y0 Z0 reset would otherwise leave the modal term folding the pivot on every later plain-mode block. The ISO/Fanuc sibling gate is PivotTransformationSyntax; both write the identical JSON vocabulary through the shared engine, and only one of them is registered per brand pipeline. Same chain-position contract: after all Pn-frame writers, so the PivotTransform entry lands last. public class SiemensPivotTransformationSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensPivotTransformationSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Real-kinematics cases below wire TestDeps.CodeKinematics with the default chain code [O][Z][A][w];[O][Y][X][B][S][t] — a table-A / head-B 5-axis machine (see PivotTransformationSyntax's corpus notes for the zero-offset chain caveats). Plain-mode skip — no tilt, no RTCP: untouched. #BeforeBuild: {} #AfterBuild: {} The Siemens-specific exclusion: an active programmable frame (Term = \"TRANS\") with an indexed rotary — real kinematics wired, yet the gate must not fold the pivot (a geometric frame does not rotate the physical machine): #BeforeBuild: { \"TiltTransform\": { \"Term\": \"TRANS\", \"X\": 0, \"Y\": 0, \"Z\": 0 }, \"MachineCoordinateState\": { \"A\": 45 } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"TRANS\", \"X\": 0, \"Y\": 0, \"Z\": 0 }, \"MachineCoordinateState\": { \"A\": 45 } } Active TRAORI signalled by the ToolHeightCompensation term — the TestDeps.Kinematics stub makes the engine's pivot matrix collapse to identity; no Dynamic entry exists (stable rotary), so the entry stays Static — the branch the Dynamic-only detection would miss: #BeforeBuild: { \"ToolHeightCompensation\": { \"Offset_mm\": 50, \"Term\": \"TRAORI\", \"OffsetId\": 1 } } #AfterBuild: { \"ToolHeightCompensation\": { \"Offset_mm\": 50, \"Term\": \"TRAORI\", \"OffsetId\": 1 }, \"ProgramToMcTransform\": [ { \"Source\": \"PivotTransform\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } Active CYCLE800 swivel with an indexed table angle — real kinematics: the engine folds the table-A Rx(45°) rigid matrix, the same math the ISO sibling produces for G68.2: #BeforeBuild: { \"TiltTransform\": { \"Term\": \"CYCLE800\" }, \"MachineCoordinateState\": { \"A\": 45 } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"CYCLE800\" }, \"MachineCoordinateState\": { \"A\": 45 }, \"ProgramToMcTransform\": [ { \"Source\": \"PivotTransform\", \"Kind\": \"Static\", \"Mat4d\": [ 1, 0, 0, 0, 0, 0.7071067811865475, -0.7071067811865475, 0, 0, 0.7071067811865475, 0.7071067811865475, 0, 0, 0, 0, 1 ] } ] } Constructors SiemensPivotTransformationSyntax() Initializes a new instance with default settings. public SiemensPivotTransformationSyntax() SiemensPivotTransformationSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public SiemensPivotTransformationSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensProgrammableFrameSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensProgrammableFrameSyntax.html",
    "title": "Class SiemensProgrammableFrameSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensProgrammableFrameSyntax Namespace Hi.NcParsers.LogicSyntaxs.Siemens Assembly HiMech.dll Siemens programmable frame (TRANS/ATRANS/ROT/AROT incl. RPL=, plus the solid-angle forms ROTS/AROTS): consumes the structured Parsing.<keyword> sub-objects captured by SiemensFrameStatementSyntax, accumulates the programmable-frame matrix across blocks, and composes it into ProgramToMcTransform as the shared TransformSource entry — the same Source CYCLE800 writes, so the two stay mutually exclusive via AddOrReplaceTransform's in-place replacement (on a real Sinumerik, CYCLE800 itself writes the programmable frame chain, so single ownership mirrors the control). Semantics follow the Sinumerik programmable-frame rules (HardNc reference: HardNcLine.ParseSiemensFrameTransform + NcArgSiemensFrame): the absolute forms TRANS/ROT reset the whole programmable frame and set only their own component; the additive forms ATRANS/AROT compose onto the current frame with the new operation applied first (M = M_op · M_prev, row-vector convention — an AROT after a TRANS rotates inside the translated frame). A bare keyword (any of the four) resets the programmable frame entirely — written as the shared inactive sentinel Term = \"G69\" plus an identity chain entry (the same convention HardNc's CYCLE800 reset uses). Multi-axis rotation in one statement applies the Sinumerik RPY order (intrinsic Z → Y′ → X″, i.e. row-vector Rx·Ry·Rz); RPL rotates about the active G17/G18/G19 plane normal and composes after the axis angles. The solid-angle forms ROTS/AROTS follow the Sinumerik rules (Programming Manual Fundamentals 03/2010 §12.5, \"ROTS and AROTS behave in the same way as ROT and AROT\"): at most two solid angles orient a plane, composed first-named axis first with the second rotation about the original (extrinsic) axis — the pair X,Y keeps the new X axis in the old Z/X plane (row-vector Rx·Ry), Y,Z keeps the new Y axis in the old X/Y plane (Ry·Rz), Z,X keeps the new Z axis in the old Y/Z plane (Rz·Rx). A single angle is identical to ROT/AROT; RPL= alone rotates in the active plane. Three angles, or RPL mixed with axis angles, fall outside the documented grammar: the statement is left unapplied with a SiemensFrame--SolidAngleInvalid warning plus the visible Parsing--Unconsumed residue — never a guessed frame. CROTS/SCALE/ASCALE/MIRROR/AMIRROR (zero corpus occurrences; CROTS references the control's frame database which has no offline counterpart, SCALE/MIRROR would inject non-rigid matrices whose remaining breakages are the radius-compensation magnitude, the program-space path length feeding durations, and the writeback Euler decomposition) are consumed recognized-but-not-simulated with a SiemensFrame--Unsupported warning and zero transform effect. A structured keyword whose capture fell back to the verbatim Statement shape, or whose value is an unevaluated variable expression, is left in Parsing — the VariableExpression--Unevaluated diagnostic plus the visible Parsing--Unconsumed residue is the correct fail-soft (P2 acceptance doctrine); the frame is not partially applied. Must run after SiemensCycle800TiltSyntax (this syntax owns the once-per-block TiltTransform modal carry: it carries only when no earlier syntax authored the section on this block) and before the coordinate-offset syntaxes, so the frame entry lands ahead of CoordinateOffset in the chain (McXyz = ProgramXyz · M_frame · M_offset · … — the programmable frame applies to program coordinates first, then the settable G54 frame, matching the Sinumerik frame chain). public class SiemensProgrammableFrameSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensProgrammableFrameSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Bare cancel — programmable frame reset to the shared inactive sentinel (identity entry overwrites any previously composed frame): #BeforeBuild: { \"Parsing\": { \"ROT\": { \"Bare\": true } } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"G69\" }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } Absolute translation — corpus reset idiom (TRANS X10 Y20 Z-5 arrives structured from the Parsing stage): #BeforeBuild: { \"Parsing\": { \"TRANS\": { \"X\": 10, \"Y\": 20, \"Z\": -5 } } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"TRANS\", \"X\": 10, \"Y\": 20, \"Z\": -5 }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 10,20,-5,1] } ] } Additive rotation onto a previous translation — M = Rx(30°) · T(10,0,0): the rotation applies first (inside the translated frame), the translation column survives: #Previous: { \"TiltTransform\": { \"Term\": \"TRANS\", \"X\": 10 }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 10,0,0,1] } ] } #BeforeBuild: { \"Parsing\": { \"AROT\": { \"X\": 30 } } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"AROT\", \"X\": 30 }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [ 1, 0, 0, 0, 0, 0.8660254037844387, 0.49999999999999994, 0, 0, -0.49999999999999994, 0.8660254037844387, 0, 10, 0, 0, 1 ] } ] } In-plane rotation — no PlaneSelect section on the block, so the default XY plane (Z normal) applies: #BeforeBuild: { \"Parsing\": { \"ROT\": { \"RPL\": 30 } } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"ROT\", \"RPL\": 30 }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [ 0.8660254037844387, 0.49999999999999994, 0, 0, -0.49999999999999994, 0.8660254037844387, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ] } ] } Recognized-but-not-simulated keyword — consumed with a SiemensFrame–Unsupported warning, zero transform effect (the JSON shape shows only the consumption; no chain entry, no section beyond the first-block default): #BeforeBuild: { \"Parsing\": { \"SCALE\": { \"Statement\": \"X2 Y2\" } } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"G69\" } } Solid-angle pair X,Y — ROTS X30 Y40 applies X first, then Y about the original axis (row-vector Rx·Ry); the resulting first row (the new X axis) has a zero Y component — the manual's “the new X axis lies in the old Z/X plane”: #BeforeBuild: { \"Parsing\": { \"ROTS\": { \"X\": 30, \"Y\": 40 } } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"ROTS\", \"X\": 30, \"Y\": 40 }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [ 0.766044443118978, 0, -0.6427876096865393, 0, 0.32139380484326957, 0.8660254037844387, 0.38302222155948895, 0, 0.5566703992264194, -0.49999999999999994, 0.6634139481689384, 0, 0, 0, 0, 1 ] } ] } Solid-angle pair Y,Z additively composed onto a previous translation — M = (Ry(20°)·Rz(50°)) · T(10,0,0): the second row (the new Y axis) has a zero Z component — “the new Y axis lies in the old X/Y plane” — and the translation column survives: #Previous: { \"TiltTransform\": { \"Term\": \"TRANS\", \"X\": 10 }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 10,0,0,1] } ] } #BeforeBuild: { \"Parsing\": { \"AROTS\": { \"Y\": 20, \"Z\": 50 } } } #AfterBuild: { \"TiltTransform\": { \"Term\": \"AROTS\", \"Y\": 20, \"Z\": 50 }, \"ProgramToMcTransform\": [ { \"Source\": \"TiltTransform\", \"Kind\": \"Static\", \"Mat4d\": [ 0.6040227735550537, 0.7198463103929542, -0.3420201433256687, 0, -0.766044443118978, 0.6427876096865394, 0, 0, 0.2198463103929542, 0.2620026302293849, 0.9396926207859084, 0, 10, 0, 0, 1 ] } ] } Three solid angles fall outside the documented grammar (“up to 2 solid angles may be programmed”) — the statement is left unapplied with a SiemensFrame–SolidAngleInvalid warning and the residue stays visible for the Parsing–Unconsumed report: #BeforeBuild: { \"Parsing\": { \"ROTS\": { \"X\": 10, \"Y\": 20, \"Z\": 30 } } } #AfterBuild: { \"Parsing\": { \"ROTS\": { \"X\": 10, \"Y\": 20, \"Z\": 30 } }, \"TiltTransform\": { \"Term\": \"G69\" } } Constructors SiemensProgrammableFrameSyntax() Initializes a new instance with default settings. public SiemensProgrammableFrameSyntax() SiemensProgrammableFrameSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public SiemensProgrammableFrameSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensStopreSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensStopreSyntax.html",
    "title": "Class SiemensStopreSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensStopreSyntax Namespace Hi.NcParsers.LogicSyntaxs.Siemens Assembly HiMech.dll Consumes the Siemens STOPRE flag (stop preprocessing — the control's look-ahead buffer sync) from Flags and records a non-modal block-root Stopre section. STOPRE has no effect in offline simulation (there is no preprocessing buffer to flush), so an Stopre–NoOp Unsupported Message is emitted: recognized, intentionally not simulated, safe offline. Capture side: STOPRE is a bare word collected by the Siemens preset's FlagSyntax word list. public class SiemensStopreSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensStopreSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild: { \"Parsing\": { \"Flags\": [\"STOPRE\"] } } #AfterBuild: { \"Stopre\": { \"Term\": \"STOPRE\" } } Constructors SiemensStopreSyntax() Initializes a new instance with default settings. public SiemensStopreSyntax() SiemensStopreSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public SiemensStopreSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensToolOffsetSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensToolOffsetSyntax.html",
    "title": "Class SiemensToolOffsetSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensToolOffsetSyntax Namespace Hi.NcParsers.LogicSyntaxs.Siemens Assembly HiMech.dll Siemens cutting-edge tool offset activation: consumes a standalone D word (D1 activates edge 1 of the active tool, D0 cancels compensation), resolves the effective length via TryGetToolHeightOffset_mm(int, int, out double) ($TC_DP3, geometry + additive wear) for the (active tool, D) pair — a pair without a $TC_DP row falls back to the generic IToolOffsetConfig height for the tool number (with a SiemensToolOffset–TcdpRowMissing configuration warning), so an unfilled per-case table follows the ToolHouse-fed source instead of silently machining with offset 0 — and writes the same downstream state as the ISO sibling ToolHeightOffsetSyntax: the IToolHeightCompensationDef section (with Term = “D”) plus the ToolHeightCompensation entry in the ProgramToMcTransform chain — sharing the transform Source keeps the two brands' compensation mutually exclusive via AddOrReplaceTransform's in-place replacement. The active tool number comes from the block's (or previous block's) ToolChange section; a string tool name resolves through FindToolNumberByName(string). Modal ownership follows the same yield protocol as the ISO sibling: blocks without a D word re-resolve only when the previous section's Term is ours (\"D\"); an ISO term (G43/G44/G49) leaves the section to ToolHeightOffsetSyntax — real Siemens files mix both dialects (G43H1 headers next to D1 blocks). Must therefore be placed after ToolHeightOffsetSyntax (and after ToolChangeSyntax) in the Logic bundle, and before the brand pivot gate (SiemensPivotTransformationSyntax in the Siemens list) so the pivot entry stays at the chain tail. Consuming Parsing.D here (Logic) intentionally precedes RadiusCompensationSyntax (PostLogic): on Siemens, D selects the cutting edge — it is not the Fanuc G41 D5 radius argument, and radius state derives from the same (T, D) edge ($TC_DP6; wiring the radius value is a follow-up). public class SiemensToolOffsetSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensToolOffsetSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples D2 with the active tool from the block's ToolChange section and a table mapping (T7, D2) → 50 mm (SUT dep configured in the test). Tool ≠ edge on purpose — the distinct Siemens feature is a two-key (tool, edge) lookup, so a transposed (edge, tool) or default-index resolve cannot pass. No ToolOrientation and no tilt entry, so the translation lies along UnitZ: #BeforeBuild: { \"Parsing\": { \"D\": 2 }, \"ToolChange\": { \"ToolId\": 7, \"IsChange\": false } } #AfterBuild: { \"ToolChange\": { \"ToolId\": 7, \"IsChange\": false }, \"ToolHeightCompensation\": { \"Offset_mm\": 50, \"Term\": \"D\", \"OffsetId\": 2 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,50,1] } ] } D0 cancel — sentinel section with Offset_mm = 0 and an identity matrix resets any previously composed translation: #BeforeBuild: { \"Parsing\": { \"D\": 0 } } #AfterBuild: { \"ToolHeightCompensation\": { \"Offset_mm\": 0, \"Term\": \"D\", \"OffsetId\": 0 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } No D on the block but #Previous: carries an active D edge — modal re-resolve against the current tool keeps the section and chain entry per-block self-contained: #Previous: { \"ToolChange\": { \"ToolId\": 7, \"IsChange\": false }, \"ToolHeightCompensation\": { \"Offset_mm\": 50, \"Term\": \"D\", \"OffsetId\": 2 } } #BeforeBuild: { \"ToolChange\": { \"ToolId\": 7, \"IsChange\": false } } #AfterBuild: { \"ToolChange\": { \"ToolId\": 7, \"IsChange\": false }, \"ToolHeightCompensation\": { \"Offset_mm\": 50, \"Term\": \"D\", \"OffsetId\": 2 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,50,1] } ] } Previous modal belongs to ISO G43 — this syntax yields (no write at all) so ToolHeightOffsetSyntax carries its own state: #Previous: { \"ToolHeightCompensation\": { \"Offset_mm\": 99.98, \"Term\": \"G43\", \"OffsetId\": 1 } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M03\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\"] } } A (T7, D1) pair without a $TC_DP row falls back to the generic tool-number-keyed table (SUT deps in the test: an empty SiemensToolOffsetTable plus a generic table mapping offset 7 → 132.6 mm) and emits SiemensToolOffset–TcdpRowMissing: #BeforeBuild: { \"Parsing\": { \"D\": 1 }, \"ToolChange\": { \"ToolId\": 7, \"IsChange\": false } } #AfterBuild: { \"ToolChange\": { \"ToolId\": 7, \"IsChange\": false }, \"ToolHeightCompensation\": { \"Offset_mm\": 132.6, \"Term\": \"D\", \"OffsetId\": 1 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,132.6,1] } ] } The generic table's NaN sentinel (ToolHouse refresh with an unresolvable tool tip) degrades to offset 0 instead of poisoning the transform chain (same deps shape, generic height = NaN): #BeforeBuild: { \"Parsing\": { \"D\": 1 }, \"ToolChange\": { \"ToolId\": 7, \"IsChange\": false } } #AfterBuild: { \"ToolChange\": { \"ToolId\": 7, \"IsChange\": false }, \"ToolHeightCompensation\": { \"Offset_mm\": 0, \"Term\": \"D\", \"OffsetId\": 1 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } Constructors SiemensToolOffsetSyntax() Initializes a new instance with default settings. public SiemensToolOffsetSyntax() SiemensToolOffsetSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public SiemensToolOffsetSyntax(XElement src) Parameters src XElement Source XML element. Fields DTerm Term value marking the section as owned by the Siemens D-edge activation. public const string DTerm = \"D\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensTraoriSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Siemens.SiemensTraoriSyntax.html",
    "title": "Class SiemensTraoriSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensTraoriSyntax Namespace Hi.NcParsers.LogicSyntaxs.Siemens Assembly HiMech.dll Siemens TRAORI/TRAFOOF (orientation transformation = RTCP): the Siemens sibling of G43p4RtcpSyntax. While TRAORI is active, the IToolHeightCompensationDef section carries Term = “TRAORI” and the ToolHeightCompensation chain entry becomes a tool-normal · offset translation at the block endpoint ABC (MakeToolHeightMat(IMachineKinematics, Vec3d, double)), tagged KindDynamic when the rotary state changes across the block — the single signal that routes the block to ClLinear per-step IK. Tool length ownership stays with the (T,D) machinery: on real Sinumerik, TRAORI uses the active D edge's length. Activation adopts the compensation the D edge (or a mixed-dialect ISO G43) has already resolved — SiemensToolOffsetSyntax runs earlier in the bundle, so an explicit D1 on any TRAORI-modal block first resolves Term = \"D\" and this syntax re-takes the section with the fresh Offset_mm. The adopted owner is recorded in PriorTermKey; TRAFOOF hands the section back to it (default \"D\"), because plain length compensation survives TRAORI deactivation on the control — TRAFOOF only ends the orientation-following. A TRAFOOF with no active TRAORI (the corpus' ubiquitous defensive preamble) is consumed silently. Must run after ToolHeightOffsetSyntax / SiemensToolOffsetSyntax / the coordinate-offset syntaxes (mirroring G43p4RtcpSyntax's Fanuc slot) and before SiemensPivotTransformationSyntax, whose gate recognizes the TRAORI term and folds the kinematic pivot. Silently degrades to a plain UnitZ · offset translation when IMachineKinematics is absent. public class SiemensTraoriSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensTraoriSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Activation with no prior compensation and no kinematics — the section is taken with zero offset and the chain entry collapses to identity (Static: no rotary change is observable on a single block): #BeforeBuild: { \"Parsing\": { \"Flags\": [\"TRAORI\"] } } #AfterBuild: { \"ToolHeightCompensation\": { \"Offset_mm\": 0, \"Term\": \"TRAORI\", \"OffsetId\": 0 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } Activation adopting the D edge resolved earlier on the same block (SiemensToolOffsetSyntax has already written Term = “D” and its entry) — the section is re-taken with the fresh offset and the owner recorded for the TRAFOOF hand-back: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"TRAORI\"] }, \"ToolHeightCompensation\": { \"Offset_mm\": 50, \"Term\": \"D\", \"OffsetId\": 2 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,50,1] } ] } #AfterBuild: { \"ToolHeightCompensation\": { \"Offset_mm\": 50, \"Term\": \"TRAORI\", \"OffsetId\": 2, \"PriorTerm\": \"D\" }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,50,1] } ] } Modal continuation — no flag on the block, the previous block carries the TRAORI section; the snapshot (incl. the recorded owner) is carried and the entry rebuilt: #Previous: { \"ToolHeightCompensation\": { \"Offset_mm\": 50, \"Term\": \"TRAORI\", \"OffsetId\": 2, \"PriorTerm\": \"D\" } } #BeforeBuild: {} #AfterBuild: { \"ToolHeightCompensation\": { \"Offset_mm\": 50, \"Term\": \"TRAORI\", \"OffsetId\": 2, \"PriorTerm\": \"D\" }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,50,1] } ] } TRAFOOF hand-back — the section returns to the recorded owner (“D”), the plain translation entry is rebuilt, and the D modal re-resolve resumes on following blocks: #Previous: { \"ToolHeightCompensation\": { \"Offset_mm\": 50, \"Term\": \"TRAORI\", \"OffsetId\": 2, \"PriorTerm\": \"D\" } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"TRAFOOF\"] } } #AfterBuild: { \"ToolHeightCompensation\": { \"Offset_mm\": 50, \"Term\": \"D\", \"OffsetId\": 2 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,50,1] } ] } Defensive TRAFOOF with no active TRAORI (corpus preamble idiom) — consumed silently, nothing written: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"TRAFOOF\"] } } #AfterBuild: {} The first block after a program end — #Previous: carries the ProgramEnd section next to the still-active TRAORI. This is the reset edge (ProgramEndSyntax): the control's reset deactivates the transformation (the MD20110 default is TRAFOOF on reset) while the tool's D compensation stays active, so the block gets exactly the TRAFOOF hand-back — the section returns to the recorded owner with the plain translation entry: #Previous: { \"ProgramEnd\": { \"Term\": \"M30\" }, \"ToolHeightCompensation\": { \"Offset_mm\": 50, \"Term\": \"TRAORI\", \"OffsetId\": 2, \"PriorTerm\": \"D\" } } #BeforeBuild: {} #AfterBuild: { \"ToolHeightCompensation\": { \"Offset_mm\": 50, \"Term\": \"D\", \"OffsetId\": 2 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,50,1] } ] } Constructors SiemensTraoriSyntax() Initializes a new instance with default settings. public SiemensTraoriSyntax() SiemensTraoriSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public SiemensTraoriSyntax(XElement src) Parameters src XElement Source XML element. Fields PriorTermKey Extra ToolHeightCompensation section key recording which owner's compensation TRAORI adopted at activation (“D” or an ISO term) — the term TRAFOOF hands the section back to. Absent when TRAORI activated with no prior compensation (hand-back then defaults to “D”, the native Siemens owner). public const string PriorTermKey = \"PriorTerm\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.Siemens.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.Siemens.html",
    "title": "Namespace Hi.NcParsers.LogicSyntaxs.Siemens | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.LogicSyntaxs.Siemens Classes SiemensCircularMotionSyntax Siemens variant of CircularMotionSyntax (replaces it in the Siemens preset — do not run both): writes McArc motion for G02/G03 blocks from I/J/K center offsets or the Siemens signed radius CR= (captured as Parsing.CR by an equals-form FloatTagValueSyntax), with the helix turn count from TURN= (Parsing.TURN). Differences from the Fanuc/ISO parent, per the corpus-driven plan: CR replaces R — same math (ResolveCenterFromSignedRadius(Vec3d, Vec3d, int, bool, double); negative CR selects the >180° arc), but a CR full circle (start ≈ end on the plane) is invalid on Sinumerik and the chord collapse would produce a NaN center — rejected with Arc-CR--ClosedChord, params left visible. TURN=N means N additional full circles: AdditionalCircleNum = TURN + (closed ? 1 : 0) — no −1 (the legacy HardNc path treated TURN like Fanuc L and silently undercounted Siemens helices by one turn; deliberately not ported). The closed-loop +1 stacks on the same closure heuristic used when TURN is absent, because the downstream angle wrap yields 0 rad for closed arcs and the whole loop count must come from AdditionalCircleNum. No L and no K-as-pitch reading — Siemens L{n} is a subprogram call and helix travel is endpoint + TURN driven. Per-word absolute center: an I=AC(...) / J=AC(...) / K=AC(...) wrapper (unwrapped by SiemensAcIcSyntax into a numeric Parsing value plus a PositioningOverride entry) switches that one component from the default incremental offset-from-start to an absolute center coordinate (ResolveCenterFromMixedIjk(Vec3d, int, double, double, double, bool, bool, bool)); components without an entry — and IC()-wrapped ones — keep the incremental reading. Blocks without the section take the legacy ResolveCenterFromIjk(Vec3d, int, double, double, double) path byte-for-byte. Must be placed before LinearMotionSyntax (shared Group 01 motion slot). SiemensCoordinateOffsetSyntax Siemens Sinumerik: resolves work coordinate offset from G54–G57 (ISO-compatible), G505–G599 (extended Siemens), and G500 (cancel — machine coordinate mode). Reads from Flags, looks up IsoCoordinateTable dependency, composes into ProgramToMcTransform. SiemensCutCompModeSyntax Consumes the Siemens CUT3DC flag (3D circumferential cutter compensation mode, used with TRAORI) from Flags and records a non-modal block-root CutCompMode section. The offline RadiusCompensationSyntax only models the 2D plane modes, so a SiemensCutComp–Unsupported warning is emitted: a later G41/G42 in this program simulates as plane compensation, not as the control's 3D surface-normal offset — recognized, visibly not simulated, never a half-guess. Capture side: CUT3DC is a bare word collected by the Siemens preset's FlagSyntax word list. SiemensCycle800TiltSyntax Siemens CYCLE800 (swivel cycle): resolves the tilted work plane from the positional arguments captured by SiemensCycleCallSyntax and composes it into ProgramToMcTransform as the shared TransformSource entry — the Siemens sibling of IsoG68p2TiltSyntax its XmlDoc promises. Unlike Fanuc G68.2 (plane only), CYCLE800 also positions the rotary axes implicitly (the G53.1 half): with IMachineKinematics wired, the tilt normal is solved to machine ABC and written into MachineCoordinateState, and the block gets a non-modal rapid MotionEvent with Term = “CYCLE800” (mirroring G53p1RotaryPositionSyntax). Argument layout (HardNc reference NcArgCycle800): CYCLE800(FR, TC, ST, MODE, X0, Y0, Z0, A, B, C, X1, Y1, Z1, DIR [, FR_I, DMODE]) — 15- and 16-arg post variants both occur in the corpus. MODE is bit-coded: bits 7-6 select the swivel mode (00 axis-by-axis, 01 solid angle, 10 projection angle, 11 direct rotary), bit pairs 1-0/3-2/5-4 select each angle's axis (01=X, 10=Y, 11=Z). The motion-convention matrix is T(X1,Y1,Z1) · R · T(X0,Y0,Z0) (row-vector; the post-rotation zero offset applies innermost). ST units digit 1 composes additively onto the current programmable frame; FR/FR_I retraction and DIR solution preference are recorded in the section but not simulated (DIR = 0 suppresses the rotary positioning, per the control's frame-only variant). Cancel forms — bare CYCLE800, empty parentheses, the single-argument CYCLE800(0), or swivel-data-record name TC = \"0\" — reset the tilt to the shared inactive sentinel (Term = \"G69\" + identity entry, HardNc's convention). An in-between argument count (1–9 with a live TC) is treated as a truncated/unmodeled capture, not a cancel — warning + visible residue, so a mis-parsed call can never silently drop an active swivel. The rotary axes are not re-positioned on cancel: the retract/re-orient behavior depends on the machine's swivel data record, which does not exist offline; corpus programs follow the cancel with explicit G0 A.. C.. moves anyway. Fail-soft: a non-numeric argument (machine-runtime variable) leaves the Parsing.CYCLE800 residue visible and applies no transform (Coord-Tilt--003); an IK failure keeps the euler tilt and skips positioning (Coord-Tilt--004); a rotating CYCLE800 on a machine without kinematics/rotary axes keeps the tilt and warns (Coord-Tilt--005). Must run before SiemensProgrammableFrameSyntax (which owns the once-per-block TiltTransform modal carry and composes additive AROT/ATRANS onto this cycle's fresh matrix) and before the coordinate-offset syntaxes (chain order: frame entry ahead of CoordinateOffset). SiemensFixedPointReturnSyntax Consumes the Siemens G74 (reference-point approach) / G75 (fixed-point approach) statement captured into Parsing.G74 / Parsing.G75 by the Siemens preset's dedicated ParameterizedFlagSyntax instance, and emits a one-shot machine-coordinate move for the participating axes. Siemens semantics honored here: non-modal; only the axes written in the block participate; the numeric axis value is a dummy (conventionally 0) and is discarded; the motion happens in MACHINE coordinates ignoring every active frame; the F word in the block does not change the modal feed (the machine travels at its own rapid). The frame bypass reuses the MachineCoordSelectSyntax mechanism — write MachineCoordinateState directly and back-derive ProgramXyz through the inverse of the composed ProgramToMcTransform — so a G54/G505 offset or programmable frame shifts the recovered program coordinate, never the machine target. Target position: G74 (reference-point approach) reads the per-axis machine reference from GetHomePosition(string) (MD34010 on a Siemens table; 0 when the axis has no configured home). G75 (fixed-point approach) reads the fixed-point table MD30600 $MA_FIX_POINT_POS via GetFixPointPosition(string), falling back per axis to the same reference position when no fixed point is configured — so machines whose fixed point differs from the reference retract to the right place. Only fixed point 1 is modeled; a FP= word in the block emits Coord-FixPoint--003 and uses fixed point 1. Non-participating linear axes keep the previous machine position; rotary axes participate only when written and configured rotary (their target lands in the shared MC section, wrapped shortest-path later by McAbcCyclicPathSyntax). Placement: after ReferenceReturnSyntax (the G28 slot) — behind every coordinate-offset / frame syntax so the composed transform is complete for the ProgramXyz back-derivation, and before McXyzSyntax / LinearMotionSyntax (the stamped MotionEvent makes the motion syntaxes skip the block; a G0/G1 word on the block is claimed into the modal MotionState exactly like MachineCoordSelectSyntax does). Without an IHomeMcConfig dependency the statement stays in Parsing and surfaces as unconsumed residue. SiemensModalCycleSyntax Maps Siemens MCALL CYCLE8x(…) modal drilling calls onto the shared canned-cycle machinery — the “setup half” of the Fanuc G66-style modal pattern; the “expansion half” needs no new code because CannedCycleResolveSyntax's previous-block modal lookback already re-triggers the armed cycle at every subsequent block carrying X/Y words, exactly Sinumerik's MCALL semantic. MCALL CYCLE81/82(RTP,RFP,SDIS,DP,DPR[,DTB]) → an armed CannedCycle section (Term G81/G82) with Params.R = RFP + |SDIS|, Params.Z = DP (or RFP − DPR), dwell P = DTB for G82. MCALL CYCLE83(…,FDEP,FDPR,DAM,DTB,DTS,FRF,VARI,…) → G83 (VARI≠0, full retract) or G73 (VARI=0, chip-break) with Q = |RFP − FDEP| or |FDPR|. The FDEP/DAM decreasing peck chain is approximated by that constant first-peck depth. MCALL CYCLE85(…,DTB,FFR,RFF) → G89 (DTB>0, dwell) or G85, feed-in F = FFR; the separate retract feed RFF has no slot in the shared expansion (retract reuses F). bare MCALL → the G80 cancel sentinel (WriteCannedCycleCancel(JsonObject, string)). The MCALL block itself must NOT execute the cycle (Sinumerik arms only), so no Parsing.G8x section is written here — the armed section rides the ModalCarrySyntax CannedCycle tracked key to the following motion blocks. Return plane: ReturnMode = G98 (previous-block Z); RTP has no slot in the shared expansion — programs that park at RTP before the first trigger get exactly RTP back, the corpus shape. Fail-soft paths (consume + structured warning + no arm): non-literal arguments (R-parameter args — cycle args bypass the P2 evaluator), missing RFP / depth / peck values, and any callee outside the CYCLE8x map (MCALL L123 modal subprogram calls are not simulated). Pipeline placement: before CannedCycleResolveSyntax in the Siemens Logic bundle. SiemensPathSmoothingSyntax Records the Siemens path-control / smoothing modal registers into the brand-invariant PathSmoothing section (fields per ISiemensPathSmoothingDef): the G-code groups G60/G64/G641/G642 (path control) and G601/G602 (exact-stop criterion) from Flags, the bare modal words FNORM / SOFT / BRISK / FFWON / FFWOF / COMPCAD / COMPON / COMPOF / UPATH / SPATH (captured by the preset's FlagSyntax word list), and the Parsing.CYCLE832 call sub-object (captured by SiemensCycleCallSyntax) whose first argument arms the high-speed tolerance (0 / empty parentheses cancel it). Record-only — simulation does not alter the tool path (same contract as the Fanuc G05.1 sibling FanucPathSmoothingSyntax, which this class replaces in the Siemens preset: that one reads only the Parsing[\"G05.1\"] sub-object no Siemens capture produces). IsEnabled is derived — true while a CYCLE832 tolerance is armed or the path-control group sits on a continuous-path mode (G64/G641/G642). Modal behavior: a block touching any group starts from a clone of the previous block's section, applies the touched groups and rewrites the section; untouched blocks write nothing and ModalCarrySyntax (whose TrackedKeys already contain PathSmoothing) carries the previous section forward. The stream's first block stamps a conservative { IsEnabled: false } default — the actual delivered state of a real control is machine-data dependent, so no term is invented for it. SiemensPivotTransformationSyntax Siemens pivot gate over the shared engine (PivotTransformUtil): writes the PivotTransformSource entry on blocks where commanded XYZ needs the Pn→MC kinematic rigid transform — active TRAORI RTCP (SiemensTraoriSyntax's ToolHeightCompensation.Term), an active swivel/tilt (CYCLE800, or a mixed-dialect G68/G68.2 term), or a Dynamic chain entry. The Siemens-specific exclusion: a plain geometric frame (TRANS/ATRANS/ROT/AROT, IsPlainGeometryFrame(string)) transforms coordinates only and implies no physically positioned rotaries, so it must not open the gate — a corpus TRANS X0 Y0 Z0 reset would otherwise leave the modal term folding the pivot on every later plain-mode block. The ISO/Fanuc sibling gate is PivotTransformationSyntax; both write the identical JSON vocabulary through the shared engine, and only one of them is registered per brand pipeline. Same chain-position contract: after all Pn-frame writers, so the PivotTransform entry lands last. SiemensProgrammableFrameSyntax Siemens programmable frame (TRANS/ATRANS/ROT/AROT incl. RPL=, plus the solid-angle forms ROTS/AROTS): consumes the structured Parsing.<keyword> sub-objects captured by SiemensFrameStatementSyntax, accumulates the programmable-frame matrix across blocks, and composes it into ProgramToMcTransform as the shared TransformSource entry — the same Source CYCLE800 writes, so the two stay mutually exclusive via AddOrReplaceTransform's in-place replacement (on a real Sinumerik, CYCLE800 itself writes the programmable frame chain, so single ownership mirrors the control). Semantics follow the Sinumerik programmable-frame rules (HardNc reference: HardNcLine.ParseSiemensFrameTransform + NcArgSiemensFrame): the absolute forms TRANS/ROT reset the whole programmable frame and set only their own component; the additive forms ATRANS/AROT compose onto the current frame with the new operation applied first (M = M_op · M_prev, row-vector convention — an AROT after a TRANS rotates inside the translated frame). A bare keyword (any of the four) resets the programmable frame entirely — written as the shared inactive sentinel Term = \"G69\" plus an identity chain entry (the same convention HardNc's CYCLE800 reset uses). Multi-axis rotation in one statement applies the Sinumerik RPY order (intrinsic Z → Y′ → X″, i.e. row-vector Rx·Ry·Rz); RPL rotates about the active G17/G18/G19 plane normal and composes after the axis angles. The solid-angle forms ROTS/AROTS follow the Sinumerik rules (Programming Manual Fundamentals 03/2010 §12.5, \"ROTS and AROTS behave in the same way as ROT and AROT\"): at most two solid angles orient a plane, composed first-named axis first with the second rotation about the original (extrinsic) axis — the pair X,Y keeps the new X axis in the old Z/X plane (row-vector Rx·Ry), Y,Z keeps the new Y axis in the old X/Y plane (Ry·Rz), Z,X keeps the new Z axis in the old Y/Z plane (Rz·Rx). A single angle is identical to ROT/AROT; RPL= alone rotates in the active plane. Three angles, or RPL mixed with axis angles, fall outside the documented grammar: the statement is left unapplied with a SiemensFrame--SolidAngleInvalid warning plus the visible Parsing--Unconsumed residue — never a guessed frame. CROTS/SCALE/ASCALE/MIRROR/AMIRROR (zero corpus occurrences; CROTS references the control's frame database which has no offline counterpart, SCALE/MIRROR would inject non-rigid matrices whose remaining breakages are the radius-compensation magnitude, the program-space path length feeding durations, and the writeback Euler decomposition) are consumed recognized-but-not-simulated with a SiemensFrame--Unsupported warning and zero transform effect. A structured keyword whose capture fell back to the verbatim Statement shape, or whose value is an unevaluated variable expression, is left in Parsing — the VariableExpression--Unevaluated diagnostic plus the visible Parsing--Unconsumed residue is the correct fail-soft (P2 acceptance doctrine); the frame is not partially applied. Must run after SiemensCycle800TiltSyntax (this syntax owns the once-per-block TiltTransform modal carry: it carries only when no earlier syntax authored the section on this block) and before the coordinate-offset syntaxes, so the frame entry lands ahead of CoordinateOffset in the chain (McXyz = ProgramXyz · M_frame · M_offset · … — the programmable frame applies to program coordinates first, then the settable G54 frame, matching the Sinumerik frame chain). SiemensStopreSyntax Consumes the Siemens STOPRE flag (stop preprocessing — the control's look-ahead buffer sync) from Flags and records a non-modal block-root Stopre section. STOPRE has no effect in offline simulation (there is no preprocessing buffer to flush), so an Stopre–NoOp Unsupported Message is emitted: recognized, intentionally not simulated, safe offline. Capture side: STOPRE is a bare word collected by the Siemens preset's FlagSyntax word list. SiemensToolOffsetSyntax Siemens cutting-edge tool offset activation: consumes a standalone D word (D1 activates edge 1 of the active tool, D0 cancels compensation), resolves the effective length via TryGetToolHeightOffset_mm(int, int, out double) ($TC_DP3, geometry + additive wear) for the (active tool, D) pair — a pair without a $TC_DP row falls back to the generic IToolOffsetConfig height for the tool number (with a SiemensToolOffset–TcdpRowMissing configuration warning), so an unfilled per-case table follows the ToolHouse-fed source instead of silently machining with offset 0 — and writes the same downstream state as the ISO sibling ToolHeightOffsetSyntax: the IToolHeightCompensationDef section (with Term = “D”) plus the ToolHeightCompensation entry in the ProgramToMcTransform chain — sharing the transform Source keeps the two brands' compensation mutually exclusive via AddOrReplaceTransform's in-place replacement. The active tool number comes from the block's (or previous block's) ToolChange section; a string tool name resolves through FindToolNumberByName(string). Modal ownership follows the same yield protocol as the ISO sibling: blocks without a D word re-resolve only when the previous section's Term is ours (\"D\"); an ISO term (G43/G44/G49) leaves the section to ToolHeightOffsetSyntax — real Siemens files mix both dialects (G43H1 headers next to D1 blocks). Must therefore be placed after ToolHeightOffsetSyntax (and after ToolChangeSyntax) in the Logic bundle, and before the brand pivot gate (SiemensPivotTransformationSyntax in the Siemens list) so the pivot entry stays at the chain tail. Consuming Parsing.D here (Logic) intentionally precedes RadiusCompensationSyntax (PostLogic): on Siemens, D selects the cutting edge — it is not the Fanuc G41 D5 radius argument, and radius state derives from the same (T, D) edge ($TC_DP6; wiring the radius value is a follow-up). SiemensTraoriSyntax Siemens TRAORI/TRAFOOF (orientation transformation = RTCP): the Siemens sibling of G43p4RtcpSyntax. While TRAORI is active, the IToolHeightCompensationDef section carries Term = “TRAORI” and the ToolHeightCompensation chain entry becomes a tool-normal · offset translation at the block endpoint ABC (MakeToolHeightMat(IMachineKinematics, Vec3d, double)), tagged KindDynamic when the rotary state changes across the block — the single signal that routes the block to ClLinear per-step IK. Tool length ownership stays with the (T,D) machinery: on real Sinumerik, TRAORI uses the active D edge's length. Activation adopts the compensation the D edge (or a mixed-dialect ISO G43) has already resolved — SiemensToolOffsetSyntax runs earlier in the bundle, so an explicit D1 on any TRAORI-modal block first resolves Term = \"D\" and this syntax re-takes the section with the fresh Offset_mm. The adopted owner is recorded in PriorTermKey; TRAFOOF hands the section back to it (default \"D\"), because plain length compensation survives TRAORI deactivation on the control — TRAFOOF only ends the orientation-following. A TRAFOOF with no active TRAORI (the corpus' ubiquitous defensive preamble) is consumed silently. Must run after ToolHeightOffsetSyntax / SiemensToolOffsetSyntax / the coordinate-offset syntaxes (mirroring G43p4RtcpSyntax's Fanuc slot) and before SiemensPivotTransformationSyntax, whose gate recognizes the TRAORI term and folds the kinematic pivot. Silently degrades to a plain UnitZ · offset translation when IMachineKinematics is absent."
  },
  "api/Hi.NcParsers.LogicSyntaxs.SpindleSpeedSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.SpindleSpeedSyntax.html",
    "title": "Class SpindleSpeedSyntax | HiAPI-C# 2025",
    "summary": "Class SpindleSpeedSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Consumes S (spindle speed) and spindle direction M-codes from Parsing. Both are modal — persist across blocks via backward node lookback. Writes resolved state to a ISpindleSpeedDef section. Direction is converted from M-codes to the conventional SpindleDirection enum at this layer. Direction M-codes: the ISO defaults M03 (CW) / M04 (CCW) / M05 (STOP) always apply; a machine that starts/stops its spindle with custom M-codes (e.g., ultrasonic M203/M205) declares them on an ISpindleControlConfig dependency (ControllerParameterTableBase), which this syntax consults first — mapped flags are consumed like the ISO ones. Fallback: an S > 0 with no direction ever issued is contradictory (physics would silently never run). The build assumes CW and emits a one-shot SpindleDirection--AssumedCw validation warning — once is structural, not stateful: the stamped CW propagates modally, so later blocks no longer lack a direction. An explicit M05 (STOP) is a real direction and never triggers the fallback. public class SpindleSpeedSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SpindleSpeedSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples New S + M03 (CW) — both consumed; SpindleSpeed section written with the converted direction enum string: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M03\"], \"S\": 2000 } } #AfterBuild: { \"SpindleSpeed\": { \"SpindleSpeed_rpm\": 2000, \"Direction\": \"CW\" } } M04 (CCW) only — RPM inherited from #Previous:; direction updated to the new CCW state: #Previous: { \"SpindleSpeed\": { \"SpindleSpeed_rpm\": 1500, \"Direction\": \"CW\" } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M04\"] } } #AfterBuild: { \"SpindleSpeed\": { \"SpindleSpeed_rpm\": 1500, \"Direction\": \"CCW\" } } M05 (STOP) only — RPM still carried from #Previous: for bidirectional round-tripping; downstream consumers gate on Direction == STOP rather than RPM == 0: #Previous: { \"SpindleSpeed\": { \"SpindleSpeed_rpm\": 1500, \"Direction\": \"CW\" } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M05\"] } } #AfterBuild: { \"SpindleSpeed\": { \"SpindleSpeed_rpm\": 1500, \"Direction\": \"STOP\" } } Custom direction M-code (test hardcodes an ISpindleControlConfig dependency mapping M203 → CW) — the mapped flag is consumed exactly like an ISO one: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M203\"], \"S\": 1670 } } #AfterBuild: { \"SpindleSpeed\": { \"SpindleSpeed_rpm\": 1670, \"Direction\": \"CW\" } } S with no direction ever issued — fallback assumes CW (and emits the one-shot SpindleDirection–AssumedCw validation warning): #BeforeBuild: { \"Parsing\": { \"S\": 1670 } } #AfterBuild: { \"SpindleSpeed\": { \"SpindleSpeed_rpm\": 1670, \"Direction\": \"CW\" } } Explicit M05 alongside S — a real direction, fallback must not fire: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M05\"], \"S\": 500 } } #AfterBuild: { \"SpindleSpeed\": { \"SpindleSpeed_rpm\": 500, \"Direction\": \"STOP\" } } Constructors SpindleSpeedSyntax() Initializes a new instance with default settings. public SpindleSpeedSyntax() SpindleSpeedSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public SpindleSpeedSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.TappingCycleSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.TappingCycleSyntax.html",
    "title": "Class TappingCycleSyntax | HiAPI-C# 2025",
    "summary": "Class TappingCycleSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll G84 (right-hand) / G74 (left-hand) tapping cycles. Supports modal repetition. Cycle sequence: Rapid to init position (target XY, previous Z) Rapid from init to R-point Feed from R-point to bottom Z Spindle reverse at bottom Feed retract to final Z (G98 → init Z, G99 → R) Spindle restore to forward direction G84: forward = CW (M03), reverse = CCW (M04). G74: forward = CCW (M04), reverse = CW (M03). Reads absolute coordinates from the cycle section, which is resolved by CannedCycleResolveSyntax (modal repetition, G91 conversion, missing-axis fallback) before this syntax runs. Must be placed after CannedCycleResolveSyntax and before IncrementalResolveSyntax in the syntax chain. public class TappingCycleSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object TappingCycleSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Both cases G98 — pre-populated CannedCycle, no #Previous: so initZ = 0, F=600 → 10 mm/s. Six items each: init, R, feed-down, spindle reverse, feed retract, spindle restore. The retract is a feed (not a rapid) because the tap is physically threaded into the workpiece and a rapid would strip the threads. G84 right-hand — forward CW (M03), reverse CCW (M04) at the bottom to back out, then restore CW after retract: #BeforeBuild: { \"Parsing\": { \"G84\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2, \"F\": 600 } }, \"CannedCycle\": { \"Term\": \"G84\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2 } } } #AfterBuild: { \"CannedCycle\": { \"Term\": \"G84\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2 } }, \"Feedrate\": { \"FeedrateValue\": 600, \"Term\": \"G94\", \"Unit\": \"mm/min\" }, \"CompoundMotion\": { \"Term\": \"G84\", \"Items\": [ { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 2 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": -10 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"Feedrate_mmds\": 10 } }, { \"SpindleControl\": { \"Direction\": \"CCW\" } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"Feedrate_mmds\": 10 } }, { \"SpindleControl\": { \"Direction\": \"CW\" } } ] }, \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 } } G74 left-hand — same shape but the two spindle items are flipped: forward CCW (M04), reverse CW (M03) at the bottom, restore CCW after retract. Tests that the syntax dispatches on cycleCode == G84 to pick the right pair: #BeforeBuild: { \"Parsing\": { \"G74\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2, \"F\": 600 } }, \"CannedCycle\": { \"Term\": \"G74\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2 } } } #AfterBuild: { \"CannedCycle\": { \"Term\": \"G74\", \"ReturnMode\": \"G98\", \"Params\": { \"X\": 50, \"Y\": 30, \"Z\": -10, \"R\": 2 } }, \"Feedrate\": { \"FeedrateValue\": 600, \"Term\": \"G94\", \"Unit\": \"mm/min\" }, \"CompoundMotion\": { \"Term\": \"G74\", \"Items\": [ { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 2 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": -10 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"Feedrate_mmds\": 10 } }, { \"SpindleControl\": { \"Direction\": \"CW\" } }, { \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"Feedrate_mmds\": 10 } }, { \"SpindleControl\": { \"Direction\": \"CCW\" } } ] }, \"ProgramXyz\": { \"X\": 50, \"Y\": 30, \"Z\": 0 } } Constructors TappingCycleSyntax() Initializes a new instance with default settings. public TappingCycleSyntax() TappingCycleSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public TappingCycleSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string SupportedCodes Cycle codes this syntax consumes; defaults to G84 + G74. Brands where a code means something else narrow the list — the Siemens preset keeps only G84 because Siemens G74 is reference-point approach, not a tapping cycle (its capture is likewise excluded from that preset's CannedCycleCodes; narrowing here keeps the two layers agreeing even if some future syntax writes a Parsing.G74 section of its own). public List<string> SupportedCodes { get; set; } Property Value List<string> XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.TiltTransformUtil.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.TiltTransformUtil.html",
    "title": "Class TiltTransformUtil | HiAPI-C# 2025",
    "summary": "Class TiltTransformUtil Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Shared utilities for all tilt transform syntaxes (ISO, Siemens, Heidenhain). Handles section IO, backward lookback, and ProgramToMcTransform composition. public static class TiltTransformUtil Inheritance object TiltTransformUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields TransformSource Identifier used as the transform source key when composing the tilt rotation into ProgramToMcTransform. public const string TransformSource = \"TiltTransform\" Field Value string Methods CarryForwardFromPrevious(LazyLinkedListNode<SyntaxPiece>, JsonObject) Carries forward the tilt transform from a previous node when the current block has no new tilt command. Shared by all tilt syntaxes (G68, G68.2, CYCLE800, PLANE SPATIAL). At the program-end edge (IsResetEdge(LazyLinkedListNode<SyntaxPiece>) — the previous block carried M02 / M30 / END PGM) an active term is not carried: the controller's reset cancels the tilted work plane, the coordinate rotation and the programmable frames, so the successor gets the explicit cancel state (G69 section + identity entry, the shape TryHandleG69(JsonObject, JsonObject) writes) — an explicit section, so ModalCarrySyntax does not clone the predecessor's active section onto it. public static void CarryForwardFromPrevious(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, JsonObject json) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> json JsonObject ComposeRotation(JsonObject, Mat4d) Composes the tilt rotation into ProgramToMcTransform. Tilt is a fixed geometric rotation per block, so the entry is always KindStatic. public static void ComposeRotation(JsonObject json, Mat4d tiltMat) Parameters json JsonObject tiltMat Mat4d FindPreviousMode(LazyLinkedListNode<SyntaxPiece>) Returns the tilt mode written on the immediately previous block, or null when none. Each prior block is guaranteed to carry a TiltTransform section (LogicSyntax-stage authored, or PostSyntax-stage carried by ModalCarrySyntax), so a single-step lookup replaces the legacy EnumerateBack() walk. public static string FindPreviousMode(LazyLinkedListNode<SyntaxPiece> node) Parameters node LazyLinkedListNode<SyntaxPiece> Returns string FindPreviousTiltMat(LazyLinkedListNode<SyntaxPiece>) Returns the tilt Mat4d stored on the immediately previous block's transform list, or Idt when none. public static Mat4d FindPreviousTiltMat(LazyLinkedListNode<SyntaxPiece> node) Parameters node LazyLinkedListNode<SyntaxPiece> Returns Mat4d GetCurrentMode(JsonObject) Gets the current node's existing tilt mode (e.g., from initializer). public static string GetCurrentMode(JsonObject json) Parameters json JsonObject Returns string IsPlainGeometryFrame(string) True when mode is one of the Hi.NcParsers.LogicSyntaxs.TiltTransformUtil.PlainGeometryFrameTerms. Null-safe (null → false). public static bool IsPlainGeometryFrame(string mode) Parameters mode string Returns bool TryHandleG69(JsonObject, JsonObject) Handles G69 cancellation: writes identity tilt and consumes G69 from Flags. Idempotent — safe to call from multiple tilt syntaxes. Returns true if G69 was found and handled. public static bool TryHandleG69(JsonObject json, JsonObject parsing) Parameters json JsonObject parsing JsonObject Returns bool WriteSection(JsonObject, string, JsonObject) Writes the TiltTransform debug section to the JsonObject. public static void WriteSection(JsonObject json, string mode, JsonObject additionalParams = null) Parameters json JsonObject The target JsonObject. mode string Active tilt mode string (e.g., “G68.2”, “G69”). additionalParams JsonObject Optional G-code parameters (I,J,K,X,Y,Z etc.) for debug output."
  },
  "api/Hi.NcParsers.LogicSyntaxs.ToolChangeMotionSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.ToolChangeMotionSyntax.html",
    "title": "Class ToolChangeMotionSyntax | HiAPI-C# 2025",
    "summary": "Class ToolChangeMotionSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Synthesizes the machine motion of a tool change: on a block whose SectionName section carries IsChangeKey = true AND whose tool number actually differs from the previously equipped tool, overlays IToolingMcConfig's per-axis tooling position onto the current machine pose (NaN / missing axis = stays) and emits a one-item rapid ICompoundMotionDef to that target — the axis travel a real machine's M06 macro performs before the changer cycle runs. Root ProgramXyz (and the moved rotary axes in root MachineCoordinateState) are overwritten for subsequent-block modal lookback, mirroring HardNcLine's M06 handling (McXyz/McAbc_rad overlay + RebuildProgramXyzByMc). A same-number tool call (M06 without an actual change) emits no motion — the parity twin of HardNc's preT != T overlay gate. A block with its own motion words folds them into the single rapid: the overlay applies on top of the block's commanded position and the stamped CompoundMotion makes LinearMotionSyntax skip the block, so one contour covers both — the HardNc M06 branch shape. Placement: the ReferenceReturnSyntax (G28) slot — after the offset/frame syntaxes (the ProgramXyz back-derivation needs the composed transform), before McXyzSyntax / McAbcCyclicPathSyntax (root MC XYZ backfill; rotary targets wrapped shortest-path by the cyclic tail-pass). Programs that retract on their own (G75/G28/SUPA before M06 — every healthy post) reach the tooling position before the M06 block, so the synthesized move is zero-length and CompoundMotionSemantic emits nothing. Only a program that leaves the tool elsewhere (typically hand-edited) gets an actual synthesized travel — and the machining steps along it surface any material contact, plus the runtime's ToolChange--UnsafePose diagnostic. public class ToolChangeMotionSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object ToolChangeMotionSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples All cases run with a ToolingMcConfig shaped like Default3Axis (X/Y stay, Z moves to 0) unless stated otherwise, and leave the ProgramToMcTransform chain at identity so ProgramXyz equals MachineCoordinateState. M06 with an actual tool change (previously equipped tool 1, new tool 2) while the machine sits at (50,60,-20): Z retracts to 0, X/Y keep the previous position, and the target lands in a one-item rapid CompoundMotion plus root ProgramXyz for modal lookback: #Previous: { \"MachineCoordinateState\": { \"X\": 50, \"Y\": 60, \"Z\": -20 }, \"ToolChange\": { \"ToolId\": 1, \"IsChange\": true } } #BeforeBuild: { \"ToolChange\": { \"ToolId\": 2, \"IsChange\": true, \"Term\": \"M06\" } } #AfterBuild: { \"ToolChange\": { \"ToolId\": 2, \"IsChange\": true, \"Term\": \"M06\" }, \"CompoundMotion\": { \"Term\": \"M06\", \"Items\": [ { \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true }, \"MachineCoordinateState\": { \"X\": 50, \"Y\": 60, \"Z\": 0 } } ] }, \"ProgramXyz\": { \"X\": 50, \"Y\": 60, \"Z\": 0 } } Same tool re-called (previous change equipped tool 5, M06 calls 5 again) — no motion is synthesized, the block passes through untouched: #Previous: { \"MachineCoordinateState\": { \"X\": 50, \"Y\": 60, \"Z\": -20 }, \"ToolChange\": { \"ToolId\": 5, \"IsChange\": true } } #BeforeBuild: { \"ToolChange\": { \"ToolId\": 5, \"IsChange\": true, \"Term\": \"M06\" } } #AfterBuild: { \"ToolChange\": { \"ToolId\": 5, \"IsChange\": true, \"Term\": \"M06\" } } No IToolingMcConfig dependency — the syntax early-returns (no motion source to read): #Previous: { \"MachineCoordinateState\": { \"X\": 50, \"Y\": 60, \"Z\": -20 }, \"ToolChange\": { \"ToolId\": 1, \"IsChange\": true } } #BeforeBuild: { \"ToolChange\": { \"ToolId\": 2, \"IsChange\": true, \"Term\": \"M06\" } } #AfterBuild: { \"ToolChange\": { \"ToolId\": 2, \"IsChange\": true, \"Term\": \"M06\" } } Rotary tooling position: the config additionally sends B to 0 and the machine declares B rotary; the previous modal B is 30°. The rotary target rides in the same item and lands in root MC for modal carry (wrapped shortest-path later by McAbcCyclicPathSyntax): #Previous: { \"MachineCoordinateState\": { \"X\": 50, \"Y\": 60, \"Z\": -20, \"B\": 30 }, \"ToolChange\": { \"ToolId\": 1, \"IsChange\": true } } #BeforeBuild: { \"ToolChange\": { \"ToolId\": 2, \"IsChange\": true, \"Term\": \"M06\" } } #AfterBuild: { \"ToolChange\": { \"ToolId\": 2, \"IsChange\": true, \"Term\": \"M06\" }, \"MachineCoordinateState\": { \"B\": 0 }, \"CompoundMotion\": { \"Term\": \"M06\", \"Items\": [ { \"MotionEvent\": { \"Form\": \"McLinear\", \"IsRapid\": true }, \"MachineCoordinateState\": { \"X\": 50, \"Y\": 60, \"Z\": 0, \"B\": 0 } } ] }, \"ProgramXyz\": { \"X\": 50, \"Y\": 60, \"Z\": 0 } } Machine already at the tooling position (Z at 0) — the overlay target equals the current pose, so no motion is synthesized: #Previous: { \"MachineCoordinateState\": { \"X\": 50, \"Y\": 60, \"Z\": 0 }, \"ToolChange\": { \"ToolId\": 1, \"IsChange\": true } } #BeforeBuild: { \"ToolChange\": { \"ToolId\": 2, \"IsChange\": true, \"Term\": \"M06\" } } #AfterBuild: { \"ToolChange\": { \"ToolId\": 2, \"IsChange\": true, \"Term\": \"M06\" } } Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.ToolChangeSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.ToolChangeSyntax.html",
    "title": "Class ToolChangeSyntax | HiAPI-C# 2025",
    "summary": "Class ToolChangeSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Consumes T (tool number) and M06 (tool change) from Parsing. T is modal — persists across blocks. M06 triggers the change. Writes resolved state to a ToolChange section: { “ToolId”: 1, “IsChange”: true, “Term”: “M06” }. TermKey records the trigger command and is only written when IsChangeKey is true (i.e. the block actually carried the tool-change M code); modal-only blocks omit it. Two more keys mirror HardNc's T / PreparationT split. PreparedToolIdKey holds the second T of a dual tool word (T10 T2 M06: 10 is loaded, 2 is pre-selected) and is carried until the next change loads it. EquippedToolIdKey is written on non-change blocks and names the tool in the spindle — the ToolId of the last change — because ToolId on such a block may already be a pre-selection (T2 alone). Consumers read it through ReadEquippedToolId(JsonObject). ToolId is an int for numeric calls (T5) and a string for Siemens string tool calls (T=\"D8R1\", captured by SiemensToolCallSyntax); both shapes carry modally. String names are resolved to tool numbers at the semantic layer (ToolChangeSemantic) — this syntax records the call verbatim. The trigger is machine-configurable. A custom tool-change M-code (Siemens MD22560 $MC_TOOL_CHANGE_M_CODE) is declared on the controller parameter table (IsToolChange) and reaches this syntax already expanded to M06 by MCodeExpansionSyntax. Turret/lathe machines where the T word itself performs the change (Siemens MD22550 $MC_TOOL_CHANGE_MODE = 0) set ToolWordTriggersChange; the block then triggers with ToolWordTerm recorded as TermKey. Without that config a bare T block stays pre-selection only — magazine rotation is the PLC's business and moves no feed axis. public class ToolChangeSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object ToolChangeSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples T5 + M06 — full tool change on one block; both T and M06 flag consumed, Term written: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M06\"], \"T\": 5 } } #AfterBuild: { \"ToolChange\": { \"ToolId\": 5, \"IsChange\": true, \"Term\": \"M06\" } } T5 alone alongside an unrelated flag — modal arming only, no actual change; IsChange=false and Term omitted. M03 is left in place because CleanupParsing only runs on the M06 branch: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M03\"], \"T\": 7 } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\"] }, \"ToolChange\": { \"ToolId\": 7, \"IsChange\": false } } M06 alone — T comes from #Previous: modal lookback; IsChange=true, Term=“M06”: #Previous: { \"ToolChange\": { \"ToolId\": 5, \"IsChange\": false } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M06\"] } } #AfterBuild: { \"ToolChange\": { \"ToolId\": 5, \"IsChange\": true, \"Term\": \"M06\" } } Siemens string tool call + M06 — the name carries verbatim as a string ToolId: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M06\"], \"T\": \"D16R3Z6\" } } #AfterBuild: { \"ToolChange\": { \"ToolId\": \"D16R3Z6\", \"IsChange\": true, \"Term\": \"M06\" } } T alone under turret semantics (test hardcodes an IToolChangeTriggerConfig dependency with ToolWordTriggersChange = true) — the T word itself triggers the change and Term records “T”: #BeforeBuild: { \"Parsing\": { \"T\": 9 } } #AfterBuild: { \"ToolChange\": { \"ToolId\": 9, \"IsChange\": true, \"Term\": \"T\" } } Dual tool word T10 T2 M06 (Mazak; some Fanuc posts) — the parser keeps the first T in Parsing.T and lists the second under RepeatedWords: M06 loads 10, 2 is pre-selected as PreparedToolId (HardNc: T = first grab on the M06 branch, the leftover T becomes PreparationT): #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M06\"], \"T\": 10, \"RepeatedWords\": { \"T\": [2] } } } #AfterBuild: { \"ToolChange\": { \"ToolId\": 10, \"PreparedToolId\": 2, \"IsChange\": true, \"Term\": \"M06\" } } Bare M06 after a dual tool word — the change loads the prepared tool and consumes the slot (nothing stays armed): #Previous: { \"ToolChange\": { \"ToolId\": 10, \"PreparedToolId\": 2, \"IsChange\": true, \"Term\": \"M06\" } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M06\"] } } #AfterBuild: { \"ToolChange\": { \"ToolId\": 2, \"IsChange\": true, \"Term\": \"M06\" } } A block that performs no change carries the armed tool, the prepared tool and — for consumers that need the tool in the spindle rather than the armed one (ToolHeightOffsetSyntax's omitted-H fallback) — EquippedToolId, the ToolId of the last change: #Previous: { \"ToolChange\": { \"ToolId\": 10, \"PreparedToolId\": 2, \"IsChange\": true, \"Term\": \"M06\" } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M03\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\"] }, \"ToolChange\": { \"ToolId\": 10, \"PreparedToolId\": 2, \"IsChange\": false, \"EquippedToolId\": 10 } } Fields EquippedToolIdKey Section key holding the tool currently in the spindle on blocks that do not perform a change themselves (on a change block the equipped tool is ToolIdKey). Read through ReadEquippedToolId(JsonObject). public const string EquippedToolIdKey = \"EquippedToolId\" Field Value string IsChangeKey Section key indicating whether the current block actually triggers a tool change. public const string IsChangeKey = \"IsChange\" Field Value string PreparedToolIdKey Section key holding the tool pre-selected by the SECOND T word of a dual-word change block (T10 T2 M06: 10 is loaded, 2 is prepared). Carried modally until the next change consumes it. public const string PreparedToolIdKey = \"PreparedToolId\" Field Value string SectionName JSON section name where the resolved tool-change state is written. public const string SectionName = \"ToolChange\" Field Value string TermKey Section key recording the trigger command (e.g., M06) when IsChangeKey is true. public const string TermKey = \"Term\" Field Value string ToolIdKey Section key holding the active tool number (modal). public const string ToolIdKey = \"ToolId\" Field Value string ToolWordTerm TermKey value recorded when the T word itself triggered the change (ToolWordTriggersChange). public const string ToolWordTerm = \"T\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. ReadEquippedToolId(JsonObject) The numeric tool in the spindle at this block: the block's own ToolIdKey when it performs the change, otherwise the carried EquippedToolIdKey. Null before the first change of the program, and for a string (Siemens name) tool call. One-step read — no backward walk. public static int? ReadEquippedToolId(JsonObject json) Parameters json JsonObject The block's JSON object. Returns int? Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.ToolHeightOffsetSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.ToolHeightOffsetSyntax.html",
    "title": "Class ToolHeightOffsetSyntax | HiAPI-C# 2025",
    "summary": "Class ToolHeightOffsetSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Resolves ISO tool height offset (G43/G44/G49) to the effective offset value (mm) and composes the offset as a translation into the accumulated ProgramToMcTransform matrix. RTCP modes (G43.4, TRAORI, M128) are handled by separate brand-specific syntaxes (e.g., G43p4RtcpSyntax). public class ToolHeightOffsetSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object ToolHeightOffsetSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples All cases below have no ToolOrientation section and no TiltTransform entry in the chain — the composed translation therefore lies along UnitZ (the identity tilt's AxialNormal), so Mat4d.Trans = (0, 0, height_mm). G43 H1 with a TestDeps.ToolOffset mapping offset 1 to 99.98 mm — full consume from Parsing.G43, positive sign on G43: #BeforeBuild: { \"Parsing\": { \"G43\": { \"H\": \"1\" } } } #AfterBuild: { \"ToolHeightCompensation\": { \"Offset_mm\": 99.98, \"Term\": \"G43\", \"OffsetId\": 1 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,99.98,1] } ] } G49 cancel flag — writes a sentinel G49 section with Offset_mm = 0, OffsetId = 0, and composes an identity Mat4d so any previously composed tool-height translation is reset: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G49\"] } } #AfterBuild: { \"ToolHeightCompensation\": { \"Offset_mm\": 0, \"Term\": \"G49\", \"OffsetId\": 0 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } No G43/G44/G49 on the current block but #Previous: carries an active G43 H1 — modal lookback inherits the term + offset id, re-queries the tool table, and re-composes the translation. The unrelated M03 flag survives because the consume path only triggers when an ISO term is on the current block: #Previous: { \"ToolHeightCompensation\": { \"Offset_mm\": 99.98, \"Term\": \"G43\", \"OffsetId\": 1 } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M03\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\"] }, \"ToolHeightCompensation\": { \"Offset_mm\": 99.98, \"Term\": \"G43\", \"OffsetId\": 1 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,99.98,1] } ] } G44 H1 with the same TestDeps.ToolOffset offset-1 → 99.98 mm — G44 negates the table value, so Offset_mm = -99.98 and the composed translation lies along -UnitZ. The X/Y components of toolOrientation * -99.98 land on IEEE-754 negative zero (0 * -99.98 = -0.0), which System.Text.Json emits literally as -0: #BeforeBuild: { \"Parsing\": { \"G44\": { \"H\": \"1\" } } } #AfterBuild: { \"ToolHeightCompensation\": { \"Offset_mm\": -99.98, \"Term\": \"G44\", \"OffsetId\": 1 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, -0,-0,-99.98,1] } ] } G43 with no H word (G43 Z50. — the Fanuc/Mazak \"H omitted = this tool's row\" convention; 208 of CHEM20180926's 232 G43 blocks) on a block whose ToolChange section says tool 1 is in the spindle — the offset id is the equipped tool number, HardNc parity. A bare G43 arrives as a flag (no parameter object to hang an H on); it is consumed and the same offset-1 table provides 99.98 mm: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G43\"] }, \"ToolChange\": { \"ToolId\": 1, \"IsChange\": true, \"Term\": \"M06\" } } #AfterBuild: { \"ToolChange\": { \"ToolId\": 1, \"IsChange\": true, \"Term\": \"M06\" }, \"ToolHeightCompensation\": { \"Offset_mm\": 99.98, \"Term\": \"G43\", \"OffsetId\": 1 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,99.98,1] } ] } The first block after a program end — #Previous: carries the ProgramEnd section next to the still-active G43 H1. This is the reset edge (ProgramEndSyntax): the controller's reset cancels tool length compensation, so the modal is not carried and the block gets the same G49 sentinel and identity Mat4d an explicit G49 writes; the unrelated G00 flag survives: #Previous: { \"ProgramEnd\": { \"Term\": \"M30\" }, \"ToolHeightCompensation\": { \"Offset_mm\": 99.98, \"Term\": \"G43\", \"OffsetId\": 1 } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G00\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"G00\"] }, \"ToolHeightCompensation\": { \"Offset_mm\": 0, \"Term\": \"G49\", \"OffsetId\": 0 }, \"ProgramToMcTransform\": [ { \"Source\": \"ToolHeightCompensation\", \"Kind\": \"Static\", \"Mat4d\": [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1] } ] } Remarks Input data locations in JsonObject: Parsing.G43 / Parsing.G44 → from ParameterizedFlagSyntax, {\"H\": \"5\"} Parsing.H → from IntegerTagSetupSyntax, standalone modal H (int) Parsing.Flags → from NumberedFlagSyntax, \"G49\" for cancellation, and a bare \"G43\" / \"G44\" whose H is omitted (resolved from the equipped tool number — see the last example) ToolOrientation → from a prior syntax (optional, default = Transformation.AxialNormal or UnitZ) Modal state is persisted in the IToolHeightCompensationDef section (not syntax fields) and recovered from backward node traversal. Constructors ToolHeightOffsetSyntax() Initializes a new instance with default settings. public ToolHeightOffsetSyntax() ToolHeightOffsetSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public ToolHeightOffsetSyntax(XElement src) Parameters src XElement Source XML element. Fields ToolOrientationKey JSON key under which the upstream tool orientation vector is read. public const string ToolOrientationKey = \"ToolOrientation\" Field Value string TransformSource Identifier used as the transform source key when composing the tool-height translation into ProgramToMcTransform. public const string TransformSource = \"ToolHeightCompensation\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.UnitModeSyntax.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.UnitModeSyntax.html",
    "title": "Class UnitModeSyntax | HiAPI-C# 2025",
    "summary": "Class UnitModeSyntax Namespace Hi.NcParsers.LogicSyntaxs Assembly HiMech.dll Detects the unit-system code (ISO Group 06: G20 inch / G21 metric) from Flags and writes a Unit section (Term, System). Modal — absence of an explicit flag inherits the previous block's unit, defaulting to Metric at program start. The code vocabulary is configurable per brand: InchCodes / MetricCodes default to ISO G20 / G21; the Siemens preset uses G70+G700 / G710+G71 instead (G70/G71 switch geometry-word interpretation only, G700/G710 also switch feedrate interpretation — a distinction preserved via the verbatim Term but irrelevant to this record-only syntax; both inch variants warn identically). The first MetricCodes entry doubles as the program-start default Term. RS-274-D, Syntec and Fanuc turning G-code system C all spell the units G70 inch / G71 metric, and the Fanuc milling dialects (RS-274-D descendants) read them the same way, so the Fanuc/Syntec presets carry all four codes. The finishing/roughing-cycle collision exists only on Fanuc turning G-code systems A/B (system C moved those cycles to G72/G73) — a future turning preset for those systems must not inherit this milling preset's vocabulary. The HiNC pipeline works exclusively in millimetres. When an inch code is detected this syntax emits an Unit--InchNotSupported Unsupported Error so upstream callers are forced to pre-convert the NC program to metric — while still recording what the program said. Metric codes are accepted as no-op confirmations of the default. public class UnitModeSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object UnitModeSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G21\"] } } #AfterBuild: { \"Unit\": { \"Term\": \"G21\", \"System\": \"Metric\" } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G20\"] } } #AfterBuild: { \"Unit\": { \"Term\": \"G20\", \"System\": \"Inch\" } } #Previous: { \"Unit\": { \"Term\": \"G21\", \"System\": \"Metric\" } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"M03\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"M03\"] }, \"Unit\": { \"Term\": \"G21\", \"System\": \"Metric\" } } Siemens metric confirmation (SUT configured with InchCodes = [“G70”, “G700”], MetricCodes = [“G710”, “G71”]) — corpus header shape N1 G40 G17 G710 G94 G90 G64 reduced to the unit flag; the verbatim code is recorded as Term, unrelated flags stay: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G40\", \"G710\", \"G90\"] } } #AfterBuild: { \"Parsing\": { \"Flags\": [\"G40\", \"G90\"] }, \"Unit\": { \"Term\": \"G710\", \"System\": \"Metric\" } } Siemens inch code — recorded faithfully as Inch despite the Unit–InchNotSupported diagnostic (record what the program said, warn, don't silently coerce): #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G700\"] } } #AfterBuild: { \"Unit\": { \"Term\": \"G700\", \"System\": \"Inch\" } } Siemens no-flag block — modal inherit from the previous block's section; program-start default would be the first MetricCodes entry: #Previous: { \"Unit\": { \"Term\": \"G710\", \"System\": \"Metric\" } } #BeforeBuild: { \"Parsing\": { \"X\": 10 } } #AfterBuild: { \"Parsing\": { \"X\": 10 }, \"Unit\": { \"Term\": \"G710\", \"System\": \"Metric\" } } Fanuc/Syntec mill dialect (SUT configured with InchCodes = [“G20”, “G70”], MetricCodes = [“G21”, “G71”]) — the RS-274-D / Fanuc system C / Syntec spelling G71 is consumed exactly like G21: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G71\"] } } #AfterBuild: { \"Unit\": { \"Term\": \"G71\", \"System\": \"Metric\" } } Same instance reading the inch spelling G70 — recorded faithfully as Inch and the Unit–InchNotSupported error is emitted, exactly like G20: #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G70\"] } } #AfterBuild: { \"Unit\": { \"Term\": \"G70\", \"System\": \"Inch\" } } Constructors UnitModeSyntax() Initializes a new instance with default settings. public UnitModeSyntax() UnitModeSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public UnitModeSyntax(XElement src) Parameters src XElement Source XML element. Properties Default Default instance with standard settings. public static UnitModeSyntax Default { get; } Property Value UnitModeSyntax InchCodes Codes that select the inch input system; each detection emits Unit–InchNotSupported. Defaults to ISO G20; the Siemens preset uses G70 + G700. public List<string> InchCodes { get; set; } Property Value List<string> MetricCodes Codes that select the metric input system. Defaults to ISO G21; the Siemens preset uses G710 + G71. The first entry doubles as the program-start default Term. public List<string> MetricCodes { get; set; } Property Value List<string> Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.LogicSyntaxs.html": {
    "href": "api/Hi.NcParsers.LogicSyntaxs.html",
    "title": "Namespace Hi.NcParsers.LogicSyntaxs | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.LogicSyntaxs Classes BackBoringSyntax G87 back boring cycle. Supports modal repetition. Cuts upward from Z to R — used to bore the back side of a workpiece. Cycle sequence: Oriented spindle stop (OSS) at current position Rapid (shifted) to init position, then down to bottom Z — tool enters pre-drilled hole without contacting bore wall Shift back to hole center at bottom Spindle start (CW) Feed upward from Z to R-point (back boring cut) Oriented spindle stop at R Tool shift, rapid retract (shifted) to final Z Shift back to center, spindle restart Q specifies the lateral shift distance (mm). Shift direction defaults to +X (OSS angle 0°). Reads absolute coordinates from the cycle section, which is resolved by CannedCycleResolveSyntax before this syntax runs. BoringCycleSyntax G85/G86/G89 boring cycles. Cycle sequence: Rapid to init position (target XY, previous Z) Rapid from init to R-point Feed from R-point to bottom Z [G86 only] Spindle stop at bottom [G89 only] Dwell P seconds at bottom Retract: G85/G89 → feed retract, G86 → rapid retract [G86 only] Spindle restart (CW) after retract G85: feed to Z, feed retract — smooth bore finish. G86: feed to Z, spindle stop (implicit), rapid retract. G89: feed to Z, dwell P, feed retract — like G85 with bottom dwell. Reads absolute coordinates from the cycle section, which is resolved by CannedCycleResolveSyntax (modal repetition, G91 conversion, missing-axis fallback) before this syntax runs. Must be placed after CannedCycleResolveSyntax and before IncrementalResolveSyntax in the syntax chain. CannedCycleResolveSyntax Resolves the canned-cycle Group-09 state for the current block and writes the result to the CannedCycle section. Active cycle (direct G81..G89 or modal repeat): merges Parsing overrides with previous-cycle stored params, applies G91 incremental-to-absolute conversion and missing-axis fallback, writes CannedCycle with Term, ReturnMode, and Params. The resolved cycle sub-section is left in Parsing under the cycle code for downstream cycle syntaxes (DrillingCycleSyntax, etc.) to read. Explicit cancel (G80 flag present on a non-cycle block): consumes the G80 flag and writes CannedCycle = { Term: \"G80\" }, acting as a hard sentinel for Hi.NcParsers.LogicSyntaxs.CannedCycleSyntaxUtil modal lookback. No Group-09 activity: leaves the block untouched. Must be placed after PositioningSyntax and before the individual cycle syntaxes in the chain. CircularMotionSyntax Writes McArc motion for circular commands (ISO G02/G03). Detects motion mode from Flags, reads I/J/K center offsets or R radius from Parsing, computes arc center in program coordinates, and writes a one-shot MotionEvent (form + arc params) plus a modal MotionState (Term). G02/G03 mode is modal (Group 01) — persists across blocks via Term. Arc parameters (I/J/K/R) are per-block and must be present in every arc block. Must be placed before LinearMotionSyntax in the syntax chain. Both share the Group 01 motion slot; whichever writes a MotionEvent first claims it. IsIjkAbsolute switches the I/J/K reading to absolute center coordinates (Heidenhain DIN/ISO — the ISO twin of the Klartext CC pole; the Heidenhain list sets it, every other brand keeps the offset default). In that mode the center is modal: letters not written in a block inherit the previous absolute pole (AbsoluteIjkPoleKey, carried by the brand's ModalCarrySyntax), a letter never written falls back to the arc start's component, a letters-free block that commands an endpoint continues the modal arc off the pole (a flags-only block stays motionless), a G91 block reads offsets again and breaks the pole chain, and the plane-normal letter is a center coordinate — never the per-turn helix pitch. Behavior mirrors HardNcLine.BuildArcNcArg + ArcNcArg.GetCenterOrCenterOnBeginPlane (HiUniNc 3.1.152.2) bit for bit. CodedPositionUtil Shared coded-position resolution for the write-stage consumers (McAbcSyntax for rotary words, IncrementalResolveSyntax for linear words): turns a per-word PositioningOverride entry of the coded family (CodedAbsolute / CodedIncremental / CodedShortest / CodedPositiveOnly / CodedNegativeOnly — stamped by SiemensAcIcSyntax for CAC()/CIC()/CDC()/CACP()/CACN()) plus the evaluated position number into an axis coordinate via IIndexingPositionConfig, and names the plain override value the caller rewrites the entry to — so the McAbcCyclicPathSyntax tail-pass and every other downstream reader only ever see the established non-coded vocabulary. Failure semantics mirror the Siemens alarms as far as a simulator can: an invalid position number (alarm 17510) or a missing table reports an error diagnostic and resolves to \"hold\" — the caller writes the anchor so the axis does not move. CIC(0) also resolves to hold, by specification (\"the indexing axis is not traversed\") and silently. A CIC from between two indexing positions advances to the n-th next position in the programmed direction. On a cyclic indexing axis the incremental sign becomes a directional (PositiveOnly / NegativeOnly) approach; increments spanning more than one revolution reach the correct position but collapse the extra full turns (the tail-pass windows cover one revolution). CoolantSyntax Consumes M07 (mist ON), M08 (flood ON), and M09 (coolant OFF) from Flags and writes the ICoolantDef section with both IsOn (convenience flag) and Mode (abstract mode name: Flood / Mist / Off). Modal — persists via backward lookback. CoordinateOffsetUtil Shared utilities for all coordinate offset syntaxes (ISO, Siemens, Heidenhain). Handles section IO, backward lookback, and ProgramToMcTransform composition. DrillingCycleSyntax G81/G82 drilling cycle (rapid retract). Supports modal repetition. G82 covers G81 — the only difference is an optional dwell (P) at the bottom. Cycle sequence: Rapid to init position (target XY, previous Z) Rapid from init to R-point Feed from R-point to bottom Z [G82 only] Dwell P seconds at bottom Rapid from bottom to final (G98 → init Z, G99 → R) Reads absolute coordinates from the cycle section, which is resolved by CannedCycleResolveSyntax (modal repetition, G91 conversion, missing-axis fallback) before this syntax runs. Must be placed after CannedCycleResolveSyntax and before IncrementalResolveSyntax in the syntax chain. DwellSyntax Consumes the non-modal G4/G04 dwell sub-section captured by G4Syntax (Parsing.G4 / Parsing.G04) and emits a CompoundMotion with a single Dwell item, which Hi.NcParsers.Semantics.CompoundMotionSemanticUtil resolves into an ActDelay of the dwell duration. Argument dialects are configured per brand preset: Fanuc-family default — SecondsPrefixes = X/U (seconds), MillisecondsPrefixes = P (milliseconds), SpindleRevPrefixes = S (spindle revolutions). Siemens — G4 F<seconds> / G4 S<revolutions>: the preset sets SecondsPrefixes = F, clears the milliseconds list, keeps S revolutions. Because the capture layer owns the whole argument (the F/X/P word lands inside the dwell sub-section, never in Parsing.F / Parsing.X), a dwell block cannot poison the modal Feedrate and its X-word cannot mint a ghost motion — structural fixes for the G04 F60000 feed-poison and G04 X0.5 ghost-motion hazards. Spindle-revolution dwell needs the modal spindle speed: this syntax must be placed after SpindleSpeedSyntax in the Logic bundle so the block's own modal SpindleSpeed section is already written. When no positive rpm is known the dwell is consumed and recorded via an Unsupported Message (Dwell--SpindleRevUnresolved) instead of being time-simulated — no act is emitted. When several recognized argument prefixes appear on one block the resolution priority is seconds → milliseconds → revolutions; every recognized key is consumed either way. Unrecognized keys inside the sub-section are left in place so they surface through UnconsumedCheckSyntax. FanucPathSmoothingSyntax Consumes Fanuc G05.1 (high-precision contour / AICC II / Nano Smoothing) and records the modal state in the PathSmoothing JSON section using the FanucPathSmoothing schema. Q1 enables, Q0 disables; the optional R{n} precision-level is preserved as Level. The simulation does not alter the tool path — this is a controller-internal interpolation black box; the captured state exists for bidirectional NC-text reconstruction. Modal carry to subsequent blocks is handled by ModalCarrySyntax, which already tracks the PathSmoothing section key and deep-clones it forward. Also consumes the bare G05 P{n} HPCC family (captured by G05Syntax) into the block-local FanucHpcc section — recognized, intentionally not simulated (the SiemensStopreSyntax pattern). Ignoring P10000/P0 is safe offline; an ignored high-speed cycle machining call (P10001–P10999) means the simulation misses that machining, surfaced as a Warning. See IFanucHpccDef for the P function-selection semantics. The section is deliberately separate from the modal PathSmoothing section and is not modal-carried. FeedrateSyntax Consumes F (feedrate) from Parsing and G94/G95 mode from Flags. Both are modal — persist across blocks via backward node lookback. Writes resolved state to a IFeedrateDef section. FineBoringSyntax G76 fine boring cycle. Supports modal repetition. Cycle sequence: Rapid to init position (target XY, previous Z) Rapid from init to R-point Feed from R-point to bottom Z Oriented spindle stop (OSS) Tool shift by Q in +X direction (clear bore wall) Rapid retract (shifted) to final Z Tool shift back to center Spindle restart (CW) Q specifies the lateral shift distance (mm) to avoid dragging the tool across the finished bore surface during retract. Shift direction defaults to +X (OSS angle 0°). Reads absolute coordinates from the cycle section, which is resolved by CannedCycleResolveSyntax before this syntax runs. G43p4RtcpSyntax Handles G43.4 RTCP (Rotary Tool Center Point) activation. Writes the IToolHeightCompensationDef section and the ToolHeightCompensationSource entry in ProgramToMcTransform — a tool-normal · offset_mm translation at the block endpoint ABC. The chain entry is tagged KindDynamic when RTCP is active and ABC changes across the block, and KindStatic otherwise. The RTCP kinematic rotary part (Pn→MC rigid transform) is orthogonal to this syntax and is written by PivotTransformationSyntax on every block, because rotary state remains in effect beyond the RTCP modal (e.g. a non-RTCP G01 after G49 still inherits the last ABC from the program). The \"rotary dynamic\" distinction lives on the chain entry's KindKey alone and is read via HasDynamicEntry(JsonObject) by LinearMotionSyntax to pick ClLinear vs McLinear. G43.4 is used by Fanuc, Mazak, Syntec, and Okuma. Siemens (TRAORI) and Heidenhain (M128) are handled by separate syntaxes. Must be placed after ToolHeightOffsetSyntax (to override the ToolHeightCompensation entry when RTCP is active) and before PivotTransformationSyntax (which runs last in the chain). G53p1RotaryPositionSyntax G53.1 — non-modal, one-shot rotary axis positioning. Positions the rotary axes (A/B/C) to align the physical tool axis with the active tilted work plane defined by G68.2. XYZ position is unchanged; only rotary axes move via rapid traverse. Requires IsoG68p2TiltSyntax (or equivalent) to have written the tilt transform. Uses IMachineKinematics to solve for the target A/B/C via inverse kinematics. Must be placed after IsoG68p2TiltSyntax (needs tilt data) and before ProgramXyzSyntax in the syntax chain. Writes A/B/C into MachineCoordinateState. Motion is handled by LinearMotionSyntax via modal G00/G01. HighSpeedPeckCycleSyntax G73 high-speed peck drilling cycle (chip breaking). Supports modal repetition. Drills in increments of depth Q, partially retracting by PeckRetractionDistance_mm between strokes (instead of fully back to R like PeckDrillingCycleSyntax). Cycle sequence: Rapid to init position (target XY, previous Z) Rapid from init to R-point For each stroke: feed Q deeper, rapid retract by d If remainder exists: feed to bottom Z, rapid retract by d Rapid to final (G98 → init Z, G99 → R) Reads absolute coordinates from the cycle section, which is resolved by CannedCycleResolveSyntax (modal repetition, G91 conversion, missing-axis fallback) before this syntax runs. Must be placed after CannedCycleResolveSyntax and before IncrementalResolveSyntax in the syntax chain. IncrementalResolveSyntax Resolves G91 incremental axis values to absolute in-place within Parsing and its sub-sections. Reads Term written by PositioningSyntax. Per-word override: a block-root PositioningOverride section (written by SiemensAcIcSyntax for the Siemens per-word coordinate functions, and by the Heidenhain L / C / CC / CYCL CALL POS parsers for the klartext I-prefixed words — see HeidenhainIncrementalAxisWordUtil; the CYCL CALL POS words never reach this syntax, HeidenhainCannedCycleSyntax resolves them on the spot ahead of it) beats the modal term for the listed axes on this block only: an Incremental entry converts that word even under G90, an Absolute entry skips it even under G91 — as does, deliberately, every other non-Incremental value (the rotary-family Shortest / PositiveOnly / NegativeOnly entries are absolute targets; their swing resolution lives in McAbcCyclicPathSyntax, not here). A coded-position entry (CodedAbsolute / CodedIncremental — Siemens CAC()/CIC() on a linear indexing axis) carries an indexing position number instead of a coordinate: the number is resolved through IIndexingPositionConfig via TryResolveCodedTarget(IIndexingPositionConfig, string, string, double, double, ISentenceCarrier, NcDiagnosticProgress, out double, out string), the word is rewritten to the resolved absolute coordinate, and the entry to Absolute; a failed resolve reports an error and holds the last program position. Axes without an entry follow the modal term unchanged, so brands that never write the section (Fanuc/...) keep the exact legacy behavior. WorkingPathList specifies which JSON paths contain axis values that need incremental-to-absolute conversion. Default: [[\"Parsing\"], [\"Parsing\", \"G28\"]]; the Heidenhain bundle instead walks [\"Parsing\", \"CC\"] for the klartext circle-center record (CcAwareIncrementalResolveSyntax). All matching paths are converted against the same last program position — a nested record's words are distances from where the tool stands, exactly like the root's. Canned cycle paths (Parsing.G81, G82, G83, …) are intentionally excluded — their Z/R incremental semantics differ from normal axes (R is relative to init level, Z is relative to R-point). Resolution is handled by ResolveCycleCoordinates(JsonObject, Vec3d, double?, double?, double, double) inside each cycle syntax class, which runs before this syntax. Uses AxisNames to determine which tags are motion axes. Traces backward nodes for last known ProgramXyz to resolve incremental values. After this syntax, all axis values in the working paths are absolute — ProgramXyzSyntax can consume them without incremental logic. IsoCoordinateOffsetSyntax ISO/Fanuc/Mazak/Okuma/Syntec: resolves the G54–G59.9 work coordinate offset and the Fanuc-family additional work coordinate systems (G54.1 Pn, also spelled G54 Pn). Reads G54/G55/.../G59.9 from Flags and the captured Parsing.G54.1 = {P: n} object (written by G54p1Syntax for both spellings), which resolves to the coordinate id \"G54.1P{n}\" that the brand parameter tables map to #7001+ (IsoCoordinateAddressMap). Looks the offset Vec3d up via the IIsoCoordinateConfig dependencies (brand parameter table or IsoCoordinateTable) and composes it into ProgramToMcTransform. Modal — the active coordinate persists via backward lookback. Default coordinate ID is set by StaticInitializer. A block that selects a work coordinate system nobody has configured is reported on that block (never on the modal re-query of the following blocks): Coord-WorkOffset--AdditionalZero when an additional system (G54.1 Pn) resolves to no entry or to (0, 0, 0) — the brand tables seed every P row with zero, hardware-faithfully, so a zero there is the \"never entered\" state, whereas a zero row of the standard series (G54–G59 and the G59.1–G59.9 extension alike) is a legitimate authoring convention and stays silent; Coord-WorkOffset--NoTableEntry when no provider resolves the id at all (e.g. a G59.x on a runner carrying no brand-neutral table beside its brand table); and Coord-WorkOffset--IndexUnresolved when the P word is not a positive integer (vacant variable, non-integer), in which case the active system is kept. A bare G54.1 without P is not this syntax's business: the parameterized capture consumes nothing without a parameter, the dotted number lands in Parsing.Flags where it is not a G54-series member, so the active system is kept and the unconsumed check reports the flag. IsoG68RotationSyntax ISO/Fanuc: resolves G68 (2D coordinate rotation) and G69 (cancel). Computes a rotation Mat4d around the active plane normal and composes it into ProgramToMcTransform. No IMachineKinematics dependency needed — G68 is pure geometric rotation. Managed commands: G68, G69 (idempotent with IsoG68p2TiltSyntax). IsoG68p2TiltSyntax ISO/Fanuc: resolves G68.2 (tilted work plane) and G69 (cancel). Computes a tilt Mat4d from I/J/K euler angles (Fanuc ZXZ convention) and composes it into ProgramToMcTransform. Managed commands: G68.2, G69 (idempotent with IsoG68RotationSyntax). Siemens equivalent: CYCLE800 (separate syntax). Heidenhain equivalent: PLANE SPATIAL (separate syntax). IsoLocalCoordinateOffsetSyntax ISO G52: Local coordinate system offset (additive to G54-series). G52 X10 Y20 Z5 → sets local offset. G52 X0 Y0 Z0 → cancels (resets to zero). M30 (program end) → also cancels. Reads Parsing.G52 (from G52Syntax), writes IsoLocalCoordinateOffset section, and adds an \"IsoLocalCoordinateOffset\" entry to the transformation chain. Modal — persists via backward lookback until changed or cancelled. LinearMotionSyntax Writes McLinear motion for linear commands (ISO G00/G01, Heidenhain L/LN). Detects motion mode from Flags, writes a one-shot MotionEvent section (form + isRapid) plus a modal MotionState section (Term) when MachineCoordinateState exists on the block. McLinearMotionSemantic discriminates between XYZ-only and XYZABC motion by checking whether rotary axis values are present in MachineCoordinateState. Must be placed after McAbcSyntax in the syntax chain. MCodeExpansionSyntax Expands machine-declared M-codes (IMCodeDeclarationConfig on the controller parameter table) into the canonical ISO flags the regular consumers already understand: tool change → M06, spindle direction → M03/M04/M05, coolant → M07/M08/M09. Must run ahead of SpindleSpeedSyntax, CoolantSyntax, and ToolChangeSyntax — expanding early is what lets one composite OEM code (e.g. M13 = spindle CW + flood coolant) feed several downstream consumers without any of them fighting over who removes the original flag. Same rewrite-into-shared-vocabulary pattern as HeidenhainRadiusCompSyntax (RL/RR/R0 → G41/G42/G40). Two deliberate boundaries keep the rewrite faithful. Declarations whose sole content is a spindle direction (IsSpindleDirectionOnly) are NOT expanded — SpindleSpeedSyntax resolves them in place via TryResolveDirection(string, out SpindleDirection), which keeps legacy <SpindleMCode> configs bit-identical and avoids the expansion product being re-translated by that same custom-first map (e.g. a mirrored M03↔M04 remap would otherwise flip direction). Expansion codes are inserted at the declared flag's own position, and a code whose raw twin also appears un-declared elsewhere in the block is not emitted — the block's textual order keeps deciding last-wins conflicts exactly as it did before. Declared-but-unmodeled behavior stays loud: a declaration carrying an UnmodeledNote emits one DeclaredMCode--UnmodeledEffects informational diagnostic per occurrence — a declaration replaces the raw Parsing--Unconsumed warning with an explanation, never with silence. A declaration with no effects and no note consumes its code silently by explicit intent. Undeclared codes are untouched and keep falling through to UnconsumedCheckSyntax. MachineCoordSelectSyntax Handles machine coordinate selection — non-modal, one-shot. The axis values (X/Y/Z) in the block are interpreted as machine coordinates, bypassing all work offsets, local coordinates, tool height compensation, and coordinate rotations. If G91 (incremental) is active, the code is ignored per ISO standard. A per-word incremental stamp on the block (block-root PositioningOverride entry Incremental — Siemens SUPA Y=IC(-10), klartext L IY-10 M91) is a distance in the machine frame: the word is added to the previous machine position of that axis. Defaults to ISO G53. Brands with additional one-shot machine-coordinate codes widen SupportedCodes — the Siemens preset adds G153 and SUPA (both suppress every active frame for one block; in this pipeline all of those reduce to \"bypass the composed ProgramToMcTransform\", which the ProgramXyz back-derivation below already models). The matched code is stamped verbatim into Term for bidirectional source recovery. Rotary words on the same block (e.g. SUPA G0 B0, G53 A0 C0) are consumed by McAbcSyntax ahead of this syntax — machine and program rotary coincide while no rotary offsets are modeled — and the block is still a machine-coordinate positioning: the linear axes hold their machine position when no X/Y/Z word is given, and the motion is always McLinear. A machine-coordinate block never takes the RTCP tool-center-point linkage: on a real controller G53 applies no compensation, so a rotary swing commanded through it turns the axis in place instead of dragging X/Y/Z to pin the tool tip (the tip's post-swing program coordinate is what the back-derivation reports). Must be placed before IncrementalResolveSyntax and ProgramXyzSyntax in the syntax chain. When a supported code is active, this syntax consumes X/Y/Z from Parsing and writes MachineCoordinateState directly, preventing ProgramXyzSyntax from processing them as program coordinates — and, ahead of the resolve, reading a per-word incremental word raw instead of re-based into the program frame. McAbcCyclicPathSyntax Resolve modular rotary axes to the shortest cyclic path relative to the previous node. Uses IsModularRotary(string) to determine which axes within MachineCoordinateState need cyclic resolution. Falls back to hardcoded A/B/C if no IMachineAxisConfig is available. Must be placed after ProgramXyzSyntax in NcSyntaxList. Two stages, mirroring McXyzSyntax: Root MachineCoordinateState — anchored at the previous block's modal rotary state. CompoundMotion.ItemsKey[*] — sequential walk through items, anchoring item 0 at the previous block's modal state and item i > 0 at item i-1's post-cycle value (per-axis chain). Items without a rotary MachineCoordinateState are skipped. The items pass enables rotary motion (e.g. G28 ABC intermediate / home stages) to surface as motion IAct segments rather than a single root-MC stamp. Per-word directional override: a block-root PositioningOverride entry (stamped by SiemensAcIcSyntax) valued PositiveOnly (Siemens ACP()) or NegativeOnly (ACN()) swaps that axis's window for this block only: [anchor, anchor+360°) / (anchor-360°, anchor] instead of the default ±180° — the approach direction is forced even when it is the longer way around. A target congruent with the anchor (within an ULP-scale epsilon) keeps the anchor value verbatim — no move, never a spurious full turn, and no deg→rad→deg drift. Shortest (DC()) is the default window and needs no special path here. The override is read from the current block only (it is one-shot, never carried — deliberately unlike the modal RotaryWrap gate's one-step previous fallback) and applies to the root MC stage only, not to CompoundMotion items (G28/G74/G75 expansions capture their words in sub-objects the stamping syntax never sees, so an override can only ever describe a root word). Directional/shortest entries keyed by an axis outside the modular set are reported as Coord-McAbc--003 — the promise cannot be honored there and silence would mis-read the program's intent; an entry with no anchor to resolve against (first rotary value in the stream) is reported as Coord-McAbc--004 and adopted unwrapped, matching the default path. Per-word incremental override: an Incremental entry (Siemens IC(), klartext IC+270) is a signed traverse by definition — McAbcSyntax already wrote anchor + delta — so this pass keeps that value verbatim for the axis instead of folding it into the ±180° window (a +270° chain dimension must not become a -90° swing). Incremental entries on non-modular axes need no warning: the literal value is what the axis would do anyway. McAbcSyntax Writes rotary axis values (A/B/C) into MachineCoordinateState from Parsing and modal lookback. Only active when IMachineAxisConfig declares rotary axes. Works for both 3+2-axis (no IMachineKinematics) and simultaneous 5-axis configurations. This syntax is intentionally ABC-only. When the block is rotary-only (no ProgramXyz, e.g. G00 A30.) the section is created with ABC but without X/Y/Z. McAbcXyzFallbackSyntax — placed after McXyzSyntax — copies X/Y/Z from the previous block's MachineCoordinateState to finish the section. Splitting the XYZ fill out lets this syntax run before McXyzSyntax (and before G43p4RtcpSyntax) without accidentally filling X/Y/Z from prev and thereby short-circuiting DeriveMcXyz(JsonObject, Mat4d). Missing rotary axes are filled from previous MachineCoordinateState lookback, unless the current section already has the value (e.g., from HomeMcInitializer). Values are stored in degrees (matching McAbcCyclicPathSyntax). Per-word override: a block-root PositioningOverride section (written by SiemensAcIcSyntax for the Siemens AC()/IC() coordinate functions, and by the Heidenhain L / C parsers for the klartext IA+/IB+/IC+ words) marks a rotary word Incremental: the parsed value is then added to the previous modal value of that axis (previous MachineCoordinateState lookback, falling back to a value already present in the current section, then 0) instead of being written as an absolute angle. The accumulated raw degrees stay monotonic across iterations: the McAbcCyclicPathSyntax tail-pass keeps an Incremental-stamped axis literal (a chain dimension is a signed traverse, never re-shortened), so even a +270° step survives as net rotation. An Absolute entry (from AC()) matches the default write and needs no special path — and so, deliberately, do the rotary-family entries Shortest (DC()) / PositiveOnly (ACP()) / NegativeOnly (ACN()): this syntax writes the raw absolute target and the shortest/directional swing is resolved by the McAbcCyclicPathSyntax tail-pass, which owns the wrap math. Brands that never write the section keep the exact legacy behavior. Coded-position overrides (Siemens CAC()/CIC()/CDC()/CACP()/CACN()) carry an indexing position number instead of an angle: the number is resolved through IIndexingPositionConfig via TryResolveCodedTarget(IIndexingPositionConfig, string, string, double, double, ISentenceCarrier, NcDiagnosticProgress, out double, out string) and the override entry is rewritten to the plain vocabulary (Absolute / Shortest / PositiveOnly / NegativeOnly — a cyclic CIC keeps its programmed direction through the directional values) before the tail-pass runs, so the tail-pass never sees a coded value. A failed resolve (invalid number, missing table) reports an error and holds the axis at its previous value. Must be placed before McXyzSyntax so syntaxes that need the current-block ABC to compute transforms (e.g. G43p4RtcpSyntax) can see it; and before McAbcCyclicPathSyntax and LinearMotionSyntax. McAbcXyzFallbackSyntax Fills missing X/Y/Z on an ABC-only MachineCoordinateState section. Behaviour depends on whether the block is under RTCP with rotary motion, as indicated by HasDynamicEntry(JsonObject): Non-dynamic (no RTCP or RTCP with ABC stable) — the programmed tool tip stays put in MC while rotary axes (if any) are unchanged, so we simply copy X/Y/Z from the previous block's MachineCoordinateState. This matches NC modal XYZ carry-forward for rotary-only blocks such as G00 A30. (non-RTCP pivoting). Dynamic (RTCP active + ABC changing) — the programmed tool tip must stay fixed in program coordinates while MC XYZ shifts to compensate the new rotary state. Looks up the last ProgramXyz and re-derives MC = inheritedProgramXyz × composedTransform, where the composed transform is the block's endpoint chain (now including PivotTransformSource as a full rotation+translation Mat4d, so the chain already encodes the kinematic IK). The carried ProgramXyz is also stamped onto the current block so downstream consumers see a consistent ProgramXyz + MC pair. Pair with McAbcSyntax, which runs early to write ABC but deliberately leaves X/Y/Z empty so McXyzSyntax can still derive MC XYZ from ProgramXyz via the transform chain when the block carries linear motion. If McXyzSyntax has nothing to derive (no ProgramXyz), this syntax completes the MC section as described above. Does nothing when the section already carries all three of X/Y/Z (normal linear-motion blocks), or when there is no section at all (pure parse-only block that introduces no MC). Must be placed after McXyzSyntax and before McAbcCyclicPathSyntax / LinearMotionSyntax. McXyzSyntax Derives MachineCoordinateState from ProgramXyz by applying the composed ProgramToMcTransform. Processes two stages: Root ProgramXyz → root MachineCoordinate CompoundMotion.ItemsKey[*] — derives MachineCoordinate from ProgramXyz for items that have ProgramXyz but no MachineCoordinate Must be placed after syntaxes that write ProgramXyz (e.g., ReferenceReturnSyntax) and before syntaxes that read MachineCoordinate (e.g., LinearMotionSyntax). OrientationVectorResolveSyntax Shared vector-orientation resolve — the brand-independent half of tool-axis-vector 5-axis programming (Heidenhain LN TX/TY/TZ; the Fanuc/Syntec/Mazak G43.5 I/J/K and Siemens A3=/B3=/C3= slots when their adapters land). Consumes the ToolOrientationKey section a brand adapter wrote — { “Vector”: {X,Y,Z}, “Term”: “<brand word>” }, unit vector in program coordinates — and resolves it into rotary-axis degrees on MachineCoordinateState via OrientationToMcAbc(Vec3d, out Vec3d) (axial-only: rotation about the tool axis is free). Everything downstream is the existing RTCP pipeline untouched: the brand RTCP syntax sees the endpoint ABC, marks the tool-height entry KindDynamic on a rotary change, and LinearMotionSyntax routes the block to ClLinear per-step IK. Branch continuity is seeded explicitly: before solving, the chain is set to the previous block's rotary state (McAbcToMat(Vec3d) on the per-axis MC lookback) so the solver follows the current solution branch deterministically — the implicit chain state cannot be trusted under lazy or out-of-order rebuilds — and the solved angles are unwrapped to the nearest ±360° window of that anchor. Must run after McAbcSyntax (explicit rotary words and lookback land first; a vector on the same block overrides them) and before the brand RTCP syntax and McXyzSyntax (the section is created rotary-only, so the XYZ derivation still runs — the McAbcSyntax rotary-only discipline). Registered per brand list by the brand that has a vector adapter. Degradation is diagnosed, never silent: no IMachineKinematics → Orientation-Vector--NoKinematics; no rotary axes → Orientation-Vector--NoRotaryAxes; solver failure → Orientation-Vector--IkFailed. In every case the XYZ motion proceeds and the posture holds at its previous value (deliberately unlike the CLSF path, which drops the motion on IK failure — divergence recorded on the plan card). The section itself stays on the block as the semantic record. PeckDrillingCycleSyntax G83 peck drilling cycle. Supports modal repetition. Drills in increments of depth Q, fully retracting to R between strokes. Cycle sequence (per stroke): Rapid to init position (target XY, previous Z) Rapid from init to R-point For each stroke: rapid to clearance above previous depth, feed Q deeper, rapid back to R If remainder exists: feed to bottom Z, rapid to R Rapid from R/bottom to final (G98 → init Z, G99 → R) Retraction distance is read from ICannedCycleConfig (Fanuc #4002 / Syntec Pr4002, or FallbackConfig fallback). Reads absolute coordinates from the cycle section, which is resolved by CannedCycleResolveSyntax (modal repetition, G91 conversion, missing-axis fallback) before this syntax runs. Must be placed after CannedCycleResolveSyntax and before IncrementalResolveSyntax in the syntax chain. PivotTransformUtil Shared engine for the brand pivot-gate syntaxes (PivotTransformationSyntax — ISO/Fanuc family, SiemensPivotTransformationSyntax — Siemens). Each brand syntax owns only its gate (which modal terms mean “commanded XYZ needs the Pn→MC kinematic rigid transform”); the endpoint-ABC resolution and the PivotTransform chain entry composition live here so every brand writes the identical JSON vocabulary. PivotTransformationSyntax ISO/Fanuc-family pivot gate: writes the PivotTransformSource entry into ProgramToMcTransform on blocks where the controller is interpreting commanded XYZ in a frame that needs the Pn→MC kinematic rigid transform — namely active RTCP (G43.4) or active tilted plane (G68/G68.2). On plain-mode blocks (no RTCP, no tilted plane), the controller treats commanded XYZ as machine-frame directly, so the indexed rotary angle is a positioning value only and must not fold into the linear axes; this syntax skips those blocks and leaves the chain at identity (or whatever non-kinematic offsets earlier syntaxes contributed). Brand variants with their own modal vocabulary gate the same shared engine (PivotTransformUtil): Siemens TRAORI/CYCLE800 → SiemensPivotTransformationSyntax; Heidenhain M128/PLANE SPATIAL would follow the same pattern. Mirrors real Fanuc semantics: plain G43 offsets along the active tilted-plane normal (or machine Z when no tilt is active), and plain XYZ moves map directly to machine axis registers regardless of indexed table/head rotary position. Only G43.4 follows the live tool vector and only G68.2 redefines the work-plane orientation — both of which this guard detects via the existing chain markers. Chain position: must run after all Pn-frame writers (IsoG68p2TiltSyntax, ToolHeightOffsetSyntax, G43p4RtcpSyntax, IsoCoordinateOffsetSyntax, brand-specific coord offset syntaxes) so the guard sees the finalised mode markers and the PivotTransform entry — when emitted — naturally lands as the last chain element. Must run before McXyzSyntax / ProgramXyzSyntax so they see the completed chain. Silently no-ops when IMachineKinematics is absent (3-axis configurations without rotary kinematics). PlaneSelectSyntax Consumes G17/G18/G19 plane selection from Flags and writes IPlaneSelectDef section using conventional axis-pair names (XY/ZX/YZ). Modal — persists via backward lookback. Default is XY (G17). Downstream consumers (CircularMotionSyntax, IsoG68RotationSyntax) call GetPlaneNormalDir(JsonObject) to read the resolved plane. PolarGCodeCheckSyntax Warns on G-codes that Fanuc disallows during Polar Coordinate Interpolation (G12.1), per the manual whitelist mirrored from HardNc IsGCodePolarModeCompatible (IncompatibleDiagId). Placed FIRST in the Logic bundle so the scan sees Parsing Flags before the mode/plane/offset syntaxes consume their codes — at the old in-place check position, G17/G18/G19, G20/G21, G49, G53.1 and G68/G69 cancels had already been eaten and passed silently. Polar-active detection needs no valve of its own: the PREVIOUS block's PolarInterpolationState is already final (the whole Logic bundle ran for it) unless this block exits with G13.1; a block entering with G12.1 is checked too. Residual blind spot (documented): codes captured as Parsing sub-objects by ParameterizedFlagSyntax in the Parsing bundle (G28, G43/G44, G43.4, G05.1, G52, G54.1, G68/G68.2, canned cycles) never reach Flags and stay outside the scan. They cannot corrupt the polar trajectory — the plane normal is fixed by the polar pair — so the gap is diagnostic-only, same as HardNc's own per-code parse-time check. PolarInterpolationSyntax Maintains the modal Polar Coordinate Interpolation valve section (PolarInterpolationState) for Fanuc G12.1/G13.1. On a G12.1 block: consumes the flag, reads the block's own X/C words as the anchor (InitRxcz; the X word is a diameter and is halved), converts the previous program position (program X/Z + machine C angle) onto the polar hypothetical plane via GetProgramPolarRxczByOrdinaryProgramXcz(Vec3d), and writes both the state section and the entry ProgramPolarRxcz position. Mirrors HardNc HardNcLine case 12_100. On a G13.1 block: consumes the flag and stops carrying the state — the block itself is already Cartesian, matching HardNc case 13_100. On other blocks: re-materializes the previous block's state section (single-step lookback carry, the PositioningSyntax pattern), and warns FanucPolar--IncompatibleGCode for G-codes outside the Fanuc polar-mode whitelist (mirrors HardNc IsGCodePolarModeCompatible). Must be placed before McAbcSyntax so the downstream ProgramRxczSyntax can consume the hypothetical C word before it is interpreted as a rotary machine axis. PositioningSyntax Detects G90/G91 positioning mode from Flags (or by modal lookback) and writes a Positioning section (Term, Mode) to the block JSON. Fanuc/ISO: reads G90/G91 from Flags (global modal). Heidenhain: klartext has no modal word — the modal state stays at the G90 default and the I-prefixed words (IX+20) ride on the same per-word override as Siemens, stamped by the L / C / CC / CYCL CALL POS parsers (see HeidenhainIncrementalAxisWordUtil); the DIN/ISO dialect on that brand uses G90/G91 like Fanuc. Siemens: the AC()/IC() per-word override rides on top of this modal state — SiemensAcIcSyntax writes a PositioningOverride section the downstream consumers (IncrementalResolveSyntax, McAbcSyntax) honor per axis. Does NOT convert incremental values — that is handled by IncrementalResolveSyntax which can be placed later in the syntax chain, after canned cycle syntaxes have consumed their parameters with cycle-specific G91 semantics. ProgramEndCleanSyntax Clears the per-block Vars.Volatile dictionary on blocks that triggered program end (M02 / M30, identified by the ProgramEnd section written by ProgramEndSyntax). Real Fanuc clears non-retained common variables (#100-#499) on program end + reset; this syntax models that behaviour at the simulator level. The clear happens on the same block that carried M02/M30 — the next block's VolatileVariableReadingSyntax carry then sees an empty dictionary on the predecessor and starts fresh. Pipeline placement: must run after both ProgramEndSyntax (which writes the ProgramEnd section this syntax checks) and VolatileVariableReadingSyntax (so the carry has already happened on this block; this syntax overwrites the result). Retained common variables (#500-#999, owned by RetainedCommonVariableTable) are untouched — they survive program end on real hardware (NV-RAM). Local variables (#1-#33, scope: macro call frame) are also untouched here; their lifecycle belongs to G65/G66/M99 push/pop, not program end. Also clears any active FanucModalMacro on the same edge: a G66 modal that was still active when M02/M30 hit is implicitly cancelled, matching real Fanuc reset behaviour. The section is overwritten with a G67-shaped cancel marker so the carry mechanism in FanucModalMacroSyntax sees the boundary and does not propagate the modal past the program-end edge. ProgramEndSyntax Consumes M02/M30 (program end) from Flags and writes IProgramEndDef section. Downstream syntaxes that need to reset modal state on program end (e.g. IsoLocalCoordinateOffsetSyntax for G52 reset) should read the ProgramEnd section rather than scanning for M30 in Flags directly. The program-end edge. On a real controller M02/M30 ends the program and enters the reset state: the modal G codes return to their power-on defaults — tool length compensation is cancelled (G49, which also ends tool-center-point control: Fanuc TCP is cancelled by G49 or reset), the tilted work plane and coordinate rotation are cancelled (G69), cutter radius compensation is cancelled (G40), the canned cycle is cancelled (G80). A simulator that plays a file with several programs chained by M02 must keep playing, so the reset is modelled as an edge between the program-end block and its successor: the program-end block itself keeps the modal state it executed under (its own motion — G0 Z100. M30 — still sees the compensation), and the successor starts from the reset defaults. Each modal owner tests the edge with IsResetEdge(LazyLinkedListNode<SyntaxPiece>) in its single-step node.Previous lookback and writes its cancel state on the successor instead of carrying: ToolHeightOffsetSyntax (G43/G44 → G49), G43p4RtcpSyntax (G43.4 → G49), SiemensTraoriSyntax (TRAORI → TRAFOOF, the D compensation itself stays — Siemens retains the active tool on reset), HeidenhainRtcpSyntax (M128 / TCPM → off, TOOL CALL compensation stays), TiltTransformUtil (every tilt / rotation / frame term → G69), RadiusCompensationSyntax (G41/G42 → G40, the modal D is kept) and CannedCycleResolveSyntax (→ G80). Deliberately not reset: G00/G01, G90/G91, G17–G19, G94/G95, the work offset (G54–G59) and the path-smoothing mode — their reset defaults are controller-parameter dependent and they do not enter the program→machine transform chain; G20/G21 is retained by the controller itself. G52 keeps its existing behaviour of clearing on the program-end block (HardNc parity). A block right after the edge that has no words at all (a comment line) is still the edge — every owner handles it before any \"no Parsing\" early return, or the modal carry would clone the active section across it. Must be placed before syntaxes that depend on the ProgramEnd section. ProgramRxczSyntax Polar-mode sibling of ProgramXyzSyntax: while the PolarInterpolationState valve section is present, consumes the block's X/C/Z words as polar hypothetical-plane coordinates (X = diameter, halved; C = hypothetical axis in mm) and writes: ProgramPolarRxcz — the anchor-relative polar position (G90/G91 resolved against the previous block's position, mirroring HardNc NcGroup03.GetNcFromSyntax); ProgramXyz — the derived ordinary program position (radius, previous program Y, Z), so the downstream McXyzSyntax derives machine XYZ through the normal transform chain — ProgramXyzSyntax itself naturally no-ops because the axis words are already consumed; the machine C angle (degrees) into MachineCoordinateState — placed before McAbcSyntax, which then preserves the value instead of treating C as a directly-commanded rotary word; on motion-programmed blocks, MotionState and a MotionEvent with McPolarLinear (G00/G01) or McPolarArc (G02/G03 with R or I/J/K resolved on the hypothetical plane). The G12.1 entry block is skipped (its position was anchored by PolarInterpolationSyntax). Angle-branch resolution mirrors HardNc: GetOrdinaryProgramXcz_rad(Vec3d, double, Vec3d) chained from the previous machine C angle. ProgramStopSyntax Consumes the program-stop words in SupportedCodes (default M00 unconditional / M01 optional) from Flags and writes a IProgramStopDef section on the block that carried the flag. Non-modal: the section is written only on the exact block where the stop code appears. SupportedCodes is ordered by priority: when several listed words share a block the first listed one wins and stamps Term with its literal; every listed word is removed from the block either way. A brand preset widens the list for its own vocabulary (the Heidenhain STOP word — the SupportedCodes precedent). Siblings with ProgramEndSyntax (M02/M30) which handles end-of-program, not in-program stops. The parsing layer only records NC intent. Whether M01 actually pauses the run is a runtime/semantic decision gated by the operator's \"Optional Stop\" switch (analogous to IBlockSkipConfig for block skip). ProgramXyzSyntax Resolves ProgramXyz (leaf coordinate) from syntax XYZ tags. Writes ProgramXyz sub-object to SyntaxPiece.JsonObject. Must be placed after BundleSyntax since it uses cross-node lookback for last position. McXyzSyntax (placed after this in the chain) reads ProgramXyz and writes MachineCoordinateState. ProgramXyzUtil Shared utilities for ProgramXyz and MachineCoordinateState lookback and resolution. Used by ProgramXyzSyntax, ReferenceReturnSyntax, and semantic resolvers that need position lookback. Two strategies for \"what's the program coordinate at a block's endpoint?\" — both invert an MC value through an ProgramToMcTransform chain, but they pick the chain from different nodes: By current-state transform (ComputeProgramXyzByCurrentTransform(LazyLinkedListNode<SyntaxPiece>, Vec3d)) — modal anchor is MachineCoordinateState. Re-expresses an MC value (typically a predecessor's modal MC) into the current block's program frame using the current block's chain. Suitable for chain-change blocks where the spindle physically stays put while the chain (G54 swap, G68.2 activation, G43.4 toggle, tool-height change, ...) re-anchors the program frame; mirrors legacy HardNcLine.RebuildProgramXyzByMc. By corresponding-state transform (ComputeProgramXyzByCorrespondingTransform(LazyLinkedListNode<SyntaxPiece>)) — modal anchor is ProgramXyz. Recovers the program coordinate that nodeCarryingMc was originally commanded at, by inverting that same node's own transform on its own MC. Suitable for RTCP rotary-dynamic inheritance, where the modal invariant is \"tool tip in workpiece frame stays put while rotary axes turn\" — the recovered Vec3d carries forward as the next rotary block's modal ProgramXyz unchanged, regardless of how its PivotTransform differs. Both strategies yield the same Vec3d when prev and current share the same chain modal state; they only diverge across chain boundaries (RTCP toggle, coord-system swap, tilt activation) and at rotary motion (PivotTransform difference). Pick the wrong one and the result lands in a stale frame: Non-RTCP using \"corresponding\" — leaves the pre-chain-change values, so a block emitted right after G43.4 H03 would inherit ProgramXyz still in the G49 frame and the next motion's MC.Z drifts by the introduced tool-height offset. (This was the 2026-04-25 SoftNc / HardNc divergence found on a five-axis sample program.) RTCP using \"current\" — double-counts the rotary PivotTransform difference, so the inherited workpiece anchor rotates by the C delta on every rotary block. Direct callers of the two strategy helpers are rare — typically you call the dispatcher ResolveBlockProgramXyz(LazyLinkedListNode<SyntaxPiece>, Vec3d) (block's own MC vs predecessor lookback, picks strategy from HasDynamicEntry(JsonObject)) or GetLastProgramXyz(LazyLinkedListNode<SyntaxPiece>) (pure predecessor lookback). ReferenceReturnSyntax Writes ICompoundMotionDef section for G28 reference point return. Reads intermediate XYZ from Parsing.G28 (written by G28Syntax) and converts to machine coordinates via ResolveProgramXyz(JsonNode, LazyLinkedListNode<SyntaxPiece>, ISentenceCarrier, NcDiagnosticProgress). Must be placed after LinearMotionSyntax in the syntax chain. Removes the IMotionEventDef section written by LinearMotionSyntax (G28 handles its own motion). Overwrites root MachineCoordinateState and ProgramXyz with reference position for subsequent block lookback. RotaryAxisUtil Shared utilities for rotary axis (A/B/C) resolution. Used by G53p1RotaryPositionSyntax, McAbcSyntax, IsoG68p2TiltSyntax, and other syntaxes that read or write rotary axis values. SpindleSpeedSyntax Consumes S (spindle speed) and spindle direction M-codes from Parsing. Both are modal — persist across blocks via backward node lookback. Writes resolved state to a ISpindleSpeedDef section. Direction is converted from M-codes to the conventional SpindleDirection enum at this layer. Direction M-codes: the ISO defaults M03 (CW) / M04 (CCW) / M05 (STOP) always apply; a machine that starts/stops its spindle with custom M-codes (e.g., ultrasonic M203/M205) declares them on an ISpindleControlConfig dependency (ControllerParameterTableBase), which this syntax consults first — mapped flags are consumed like the ISO ones. Fallback: an S > 0 with no direction ever issued is contradictory (physics would silently never run). The build assumes CW and emits a one-shot SpindleDirection--AssumedCw validation warning — once is structural, not stateful: the stamped CW propagates modally, so later blocks no longer lack a direction. An explicit M05 (STOP) is a real direction and never triggers the fallback. TappingCycleSyntax G84 (right-hand) / G74 (left-hand) tapping cycles. Supports modal repetition. Cycle sequence: Rapid to init position (target XY, previous Z) Rapid from init to R-point Feed from R-point to bottom Z Spindle reverse at bottom Feed retract to final Z (G98 → init Z, G99 → R) Spindle restore to forward direction G84: forward = CW (M03), reverse = CCW (M04). G74: forward = CCW (M04), reverse = CW (M03). Reads absolute coordinates from the cycle section, which is resolved by CannedCycleResolveSyntax (modal repetition, G91 conversion, missing-axis fallback) before this syntax runs. Must be placed after CannedCycleResolveSyntax and before IncrementalResolveSyntax in the syntax chain. TiltTransformUtil Shared utilities for all tilt transform syntaxes (ISO, Siemens, Heidenhain). Handles section IO, backward lookback, and ProgramToMcTransform composition. ToolChangeMotionSyntax Synthesizes the machine motion of a tool change: on a block whose SectionName section carries IsChangeKey = true AND whose tool number actually differs from the previously equipped tool, overlays IToolingMcConfig's per-axis tooling position onto the current machine pose (NaN / missing axis = stays) and emits a one-item rapid ICompoundMotionDef to that target — the axis travel a real machine's M06 macro performs before the changer cycle runs. Root ProgramXyz (and the moved rotary axes in root MachineCoordinateState) are overwritten for subsequent-block modal lookback, mirroring HardNcLine's M06 handling (McXyz/McAbc_rad overlay + RebuildProgramXyzByMc). A same-number tool call (M06 without an actual change) emits no motion — the parity twin of HardNc's preT != T overlay gate. A block with its own motion words folds them into the single rapid: the overlay applies on top of the block's commanded position and the stamped CompoundMotion makes LinearMotionSyntax skip the block, so one contour covers both — the HardNc M06 branch shape. Placement: the ReferenceReturnSyntax (G28) slot — after the offset/frame syntaxes (the ProgramXyz back-derivation needs the composed transform), before McXyzSyntax / McAbcCyclicPathSyntax (root MC XYZ backfill; rotary targets wrapped shortest-path by the cyclic tail-pass). Programs that retract on their own (G75/G28/SUPA before M06 — every healthy post) reach the tooling position before the M06 block, so the synthesized move is zero-length and CompoundMotionSemantic emits nothing. Only a program that leaves the tool elsewhere (typically hand-edited) gets an actual synthesized travel — and the machining steps along it surface any material contact, plus the runtime's ToolChange--UnsafePose diagnostic. ToolChangeSyntax Consumes T (tool number) and M06 (tool change) from Parsing. T is modal — persists across blocks. M06 triggers the change. Writes resolved state to a ToolChange section: { “ToolId”: 1, “IsChange”: true, “Term”: “M06” }. TermKey records the trigger command and is only written when IsChangeKey is true (i.e. the block actually carried the tool-change M code); modal-only blocks omit it. Two more keys mirror HardNc's T / PreparationT split. PreparedToolIdKey holds the second T of a dual tool word (T10 T2 M06: 10 is loaded, 2 is pre-selected) and is carried until the next change loads it. EquippedToolIdKey is written on non-change blocks and names the tool in the spindle — the ToolId of the last change — because ToolId on such a block may already be a pre-selection (T2 alone). Consumers read it through ReadEquippedToolId(JsonObject). ToolId is an int for numeric calls (T5) and a string for Siemens string tool calls (T=\"D8R1\", captured by SiemensToolCallSyntax); both shapes carry modally. String names are resolved to tool numbers at the semantic layer (ToolChangeSemantic) — this syntax records the call verbatim. The trigger is machine-configurable. A custom tool-change M-code (Siemens MD22560 $MC_TOOL_CHANGE_M_CODE) is declared on the controller parameter table (IsToolChange) and reaches this syntax already expanded to M06 by MCodeExpansionSyntax. Turret/lathe machines where the T word itself performs the change (Siemens MD22550 $MC_TOOL_CHANGE_MODE = 0) set ToolWordTriggersChange; the block then triggers with ToolWordTerm recorded as TermKey. Without that config a bare T block stays pre-selection only — magazine rotation is the PLC's business and moves no feed axis. ToolHeightOffsetSyntax Resolves ISO tool height offset (G43/G44/G49) to the effective offset value (mm) and composes the offset as a translation into the accumulated ProgramToMcTransform matrix. RTCP modes (G43.4, TRAORI, M128) are handled by separate brand-specific syntaxes (e.g., G43p4RtcpSyntax). UnitModeSyntax Detects the unit-system code (ISO Group 06: G20 inch / G21 metric) from Flags and writes a Unit section (Term, System). Modal — absence of an explicit flag inherits the previous block's unit, defaulting to Metric at program start. The code vocabulary is configurable per brand: InchCodes / MetricCodes default to ISO G20 / G21; the Siemens preset uses G70+G700 / G710+G71 instead (G70/G71 switch geometry-word interpretation only, G700/G710 also switch feedrate interpretation — a distinction preserved via the verbatim Term but irrelevant to this record-only syntax; both inch variants warn identically). The first MetricCodes entry doubles as the program-start default Term. RS-274-D, Syntec and Fanuc turning G-code system C all spell the units G70 inch / G71 metric, and the Fanuc milling dialects (RS-274-D descendants) read them the same way, so the Fanuc/Syntec presets carry all four codes. The finishing/roughing-cycle collision exists only on Fanuc turning G-code systems A/B (system C moved those cycles to G72/G73) — a future turning preset for those systems must not inherit this milling preset's vocabulary. The HiNC pipeline works exclusively in millimetres. When an inch code is detected this syntax emits an Unit--InchNotSupported Unsupported Error so upstream callers are forced to pre-convert the NC program to metric — while still recording what the program said. Metric codes are accepted as no-op confirmations of the default. Enums BareG28Behavior Configurable handling for a G28 block with no axis specifiers (“bare G28”) — value of BareG28. Real Fanuc-class controllers vary: older 0i-M alarms (PS010), some 30i variants send every configured axis to home. Default to Alarm so silent NC bugs surface; opt into AllAxesHome per syntax instance."
  },
  "api/Hi.NcParsers.NcCompositionGate.html": {
    "href": "api/Hi.NcParsers.NcCompositionGate.html",
    "title": "Class NcCompositionGate | HiAPI-C# 2025",
    "summary": "Class NcCompositionGate Namespace Hi.NcParsers Assembly HiMech.dll License gate for the NC composition layer — the capability of registering external (non-built-in) processing units into a SoftNcRunner pipeline, and of executing NC-embedded C# scripts (ActLineCsScript). The boundary: the script layer (calling the public API from your own application code, e.g. session scripts) needs no extra license; the composition layer (registering or replacing processing units inside the interpretation pipeline — NcSyntaxList, PipelineNcDependencyList, NcSemanticList, NcInitializationList, Segmenter — or injecting per-line scripts into it) requires NcComposition. A unit is built-in when its concrete type lives in this library's own assembly; anything else is external. Order, count, duplication and constructor configuration of built-in units are unrestricted — the gate never inspects the shape of the pipeline, only the identity of each unit. Degradation is silent and functional: without the license the built-in dialects run unchanged; external units are skipped for the session and a single Composition--NotLicensed diagnostic lists them. The decision and its rejection record live in the native license module. public static class NcCompositionGate Inheritance object NcCompositionGate Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods CollectForeignUnits(SoftNcRunner, List<INcDependency>) Collects every external (non-built-in) processing unit reachable from the given runner's five pipeline members: the syntax list (descending into BundleSyntax nesting), the dependency list, the semantic list, the initializer list, and the segmenter. Pure inspection — nothing is licensed, mutated, or resolved here. public static List<object> CollectForeignUnits(SoftNcRunner runner, List<INcDependency> resolvedNcDependencyList = null) Parameters runner SoftNcRunner Runner whose composed pipeline is inspected. resolvedNcDependencyList List<INcDependency> Optional proxy-resolved dependency list to inspect instead of the runner's raw PipelineNcDependencyList (the session gate passes EffectiveNcDependencyList so the concrete proxied instances are judged, not the proxies). Returns List<object> The external units, in pipeline order per member. IsBuiltIn(Type) Whether the given concrete processing-unit type is built-in — i.e. defined in this library's own assembly. External (customer-authored) unit types return false regardless of their name. public static bool IsBuiltIn(Type unitType) Parameters unitType Type Concrete type of a pipeline processing unit. Returns bool True when the type is built-in. IsEmbeddedScriptLicensed() Whether NC-embedded C# scripts (ActLineCsScript — NC-comment markers, CSV script columns, per-line script injection) may execute. Fresh native license query for NcComposition; callers on hot paths cache the answer per play. public static bool IsEmbeddedScriptLicensed() Returns bool PassComposition(IReadOnlyCollection<object>) Native decision point: pass when no external unit is present, or when NcComposition is licensed. The rejection (with the unit names) is recorded on the native side. A core.dll that predates the gate fails closed for external units. public static bool PassComposition(IReadOnlyCollection<object> foreignUnits) Parameters foreignUnits IReadOnlyCollection<object> External units collected by CollectForeignUnits(SoftNcRunner, List<INcDependency>). Returns bool True when the composed pipeline may run as-is."
  },
  "api/Hi.NcParsers.NcDiagnostic.html": {
    "href": "api/Hi.NcParsers.NcDiagnostic.html",
    "title": "Class NcDiagnostic | HiAPI-C# 2025",
    "summary": "Class NcDiagnostic Namespace Hi.NcParsers Assembly HiMech.dll A structured diagnostic from the SoftNcRunner pipeline, designed for IProgress<T> consumption. Implements IMessage so it shares the common message channel with SimpleMessage, step diagnostics, and progress fractions, while additionally carrying an NC-source SentenceCarrier anchor that non-NC messages do not have. Also an ISentenceCarrier itself — GetSentence() and SentenceIndex delegate to SentenceCarrier so a diagnostic can be used directly anywhere a carrier is expected, without the consumer unwrapping the inner anchor. Id is composed as {Primary}-{Secondary}--{Abbrev} (e.g., Cycle-Peck--BadPeckQ, Syntax-Build--Exception). For irregular cases that don't fit the pattern, use a custom string. public class NcDiagnostic : IMessage, ISentenceCarrier, IGetSentence, ISentenceIndexed Inheritance object NcDiagnostic Implements IMessage ISentenceCarrier IGetSentence ISentenceIndexed Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NcDiagnostic(Severity, Category, string, FormattableString, object, ISentenceCarrier) Creates a templated NcDiagnostic: the interpolated template and its values are kept on Format / Args and Notification becomes the culture-invariant English rendering. An interpolated string literal passed to the string constructor is NOT captured here — call sites opt in through the *Fmt methods on NcDiagnosticProgress. public NcDiagnostic(Severity severity, Category category, string id, FormattableString notification, object detail = null, ISentenceCarrier sentenceCarrier = null) Parameters severity Severity Importance level — see Severity. category Category Diagnostic category — see Category. id string Structured diagnostic ID (see Id). notification FormattableString Interpolated notification template. detail object Optional detail data or exception. Null if not applicable. sentenceCarrier ISentenceCarrier Carrier for the NC source block that triggered this diagnostic; null for pipeline-level messages. NcDiagnostic(Severity, Category, string, string, object, ISentenceCarrier) Creates a fully-populated NcDiagnostic. public NcDiagnostic(Severity severity, Category category, string id, string notification, object detail = null, ISentenceCarrier sentenceCarrier = null) Parameters severity Severity Importance level — see Severity. category Category Diagnostic category — see Category. id string Structured diagnostic ID (see Id). notification string End-user friendly notification text. detail object Optional detail data or exception. Null if not applicable. sentenceCarrier ISentenceCarrier Carrier for the NC source block that triggered this diagnostic; null for pipeline-level messages. NcDiagnostic(Severity, Category, string, string, string, object[], object, ISentenceCarrier) Creates an NcDiagnostic carrying an already-split template — used when re-wrapping another IMessage whose format / args must survive (e.g. AsMessageSink(ISentenceCarrier)) instead of re-interpolating. public NcDiagnostic(Severity severity, Category category, string id, string notification, string format, object[] args, object detail = null, ISentenceCarrier sentenceCarrier = null) Parameters severity Severity Importance level — see Severity. category Category Diagnostic category — see Category. id string Structured diagnostic ID (see Id). notification string Already-rendered notification text. format string Composite-format template behind notification; null when untemplated. args object[] Values interpolated into format; null when untemplated. detail object Optional detail data or exception. Null if not applicable. sentenceCarrier ISentenceCarrier Carrier for the NC source block that triggered this diagnostic; null for pipeline-level messages. Properties Args Values interpolated into Format; null when untemplated. public object[] Args { get; } Property Value object[] Category Diagnostic category. public Category Category { get; } Property Value Category Detail Optional detail data or exception. Null if not applicable. public object Detail { get; } Property Value object Format Composite-format template behind Notification; null when the diagnostic was built from a plain string (untemplated). public string Format { get; } Property Value string Id Structured diagnostic ID for filtering and suppression. Normally {Primary}-{Secondary}–{Abbrev}. public string Id { get; } Property Value string Notification End-user friendly notification text. public string Notification { get; } Property Value string SentenceCarrier Carrier of the NC source block that triggered this diagnostic, exposing both the source Sentence (via GetSentence()) and the execution-order SentenceIndex. Null for pipeline-level messages (e.g., lifecycle start/done) that have no source block. public ISentenceCarrier SentenceCarrier { get; } Property Value ISentenceCarrier SentenceIndex Execution-order ordinal of the anchored NC source block, delegated from SentenceCarrier. Returns -1 (the “not in pipeline” sentinel) for pipeline-level messages whose SentenceCarrier is null. public int SentenceIndex { get; } Property Value int Severity Importance level. public Severity Severity { get; } Property Value Severity Methods GetArgs() Gets the values interpolated into GetFormat(); null when GetFormat() is null, possibly empty for a hole-less template. Default interface method so external implementers are unaffected. public object[] GetArgs() Returns object[] The interpolation arguments, or null when untemplated. GetCategory() Gets the classification — see Category. public Category GetCategory() Returns Category The category of this message. GetDetail() Gets the optional detail payload or exception; null when not applicable. public object GetDetail() Returns object The detail object, or null. GetFormat() Gets the composite-format template behind GetNotification() — a {0}-style .NET format string — when this message was produced from an interpolated template; null when the notification has no structured template. Together with GetArgs() this lets a consumer re-render the message in another language without losing the interpolated live values, while GetNotification() stays the invariant English rendering. Default interface method so external implementers are unaffected. public string GetFormat() Returns string The composite format string, or null when untemplated. GetId() Gets the structured id used for filtering / suppression; may be null. public string GetId() Returns string The message id, or null when not applicable. GetNotification() Gets the end-user friendly notification text. public string GetNotification() Returns string The notification text. GetSentence() Returns the anchored NC source Sentence, delegated from SentenceCarrier; null when there is no source block (pipeline-level messages). public Sentence GetSentence() Returns Sentence GetSeverity() Gets the importance level — see Severity. public Severity GetSeverity() Returns Severity The severity of this message. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.NcParsers.NcDiagnosticProgress.html": {
    "href": "api/Hi.NcParsers.NcDiagnosticProgress.html",
    "title": "Class NcDiagnosticProgress | HiAPI-C# 2025",
    "summary": "Class NcDiagnosticProgress Namespace Hi.NcParsers Assembly HiMech.dll Helper that emits NcDiagnostic records — retaining them in Diagnostics (their canonical home) and forwarding each to an IProgress<T> of IMessage sink for live consumption. Provides one method per (Category, Severity) pair, each with an optional Sentence overload locating the issue in the NC source. Each method has a *Fmt sibling taking a FormattableString that keeps the interpolated template and values (Format / Args) for client-side localization; the sibling must be opted into by name — an interpolated string literal passed to the string method binds to string and is not captured. A caller that runs a bounded operation (an NC play, a writeback run) can wrap it in BeginRepeatFold() so identical repeated diagnostics fold into a first occurrence plus one counted summary instead of flooding the sink. public class NcDiagnosticProgress : IProgress<NcDiagnostic> Inheritance object NcDiagnosticProgress Implements IProgress<NcDiagnostic> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NcDiagnosticProgress(IProgress<IMessage>) Creates a NcDiagnosticProgress that retains every reported NcDiagnostic in Diagnostics and also forwards it to shippingProgress for live consumption. public NcDiagnosticProgress(IProgress<IMessage> shippingProgress) Parameters shippingProgress IProgress<IMessage> Sink that receives each diagnostic. An IProgress<T> of object (e.g. the legacy SessionProgress0) is accepted here via IProgress<T> contravariance, so existing call sites keep forwarding diagnostics to the legacy message panel unchanged during the migration. Properties Diagnostics All diagnostics reported through this instance, in report order. This is the canonical home for NC diagnostics — consumers read from here rather than from a shared, mixed message collection. public IReadOnlyList<NcDiagnostic> Diagnostics { get; } Property Value IReadOnlyList<NcDiagnostic> Methods AsMessageSink(ISentenceCarrier) Returns an IProgress<T> of IMessage face over this sink: each reported message is wrapped into an NcDiagnostic (an already-typed NcDiagnostic passes through; sentenceCarrier anchors the wrapped ones) and reported here. Lets sink-agnostic IMessage producers (e.g. the HardNc parse pipeline) feed the NC-diagnostic home. public IProgress<IMessage> AsMessageSink(ISentenceCarrier sentenceCarrier = null) Parameters sentenceCarrier ISentenceCarrier Optional NC-source anchor for the wrapped messages. Returns IProgress<IMessage> BeginRepeatFold() Opens a repeat-fold window over this sink — production wraps each NC play / writeback run in one window. While the window is open, the first diagnostic of each (Id, Notification) pair is appended as usual — keeping its NC-source anchor, the position a reader jumps to — and identical repeats are absorbed and only counted. Disposing the window appends, for every pair that repeated, one summary diagnostic carrying the original severity / category / id, a [repeated Nx in this run, first at Sn=...] suffix and the last occurrence's anchor. The window only ever appends, so incremental readers (e.g. the webservice sinceIndex polling) never see an already-delivered index change. public IDisposable BeginRepeatFold() Returns IDisposable Remarks A nested call returns a no-op scope — the outermost window wins. Clear() during an open window also drops the window's accumulation, so summaries never resurrect diagnostics from before the clear. The fold key is exactly the (id, notification) pair: distinct notifications under the same id stay separate entries, while repeats matching on both fold even when their Detail objects differ — absorbed repeats' details are not retained and the summary carries a null detail. Clear() Removes all diagnostics (e.g. on runtime / controller reset). public void Clear() ConfigurationError(ISentenceCarrier, string, string, object) Emits Configuration + Error located at sentenceCarrier. public void ConfigurationError(ISentenceCarrier sentenceCarrier, string id, string text, object detail = null) Parameters sentenceCarrier ISentenceCarrier id string text string detail object ConfigurationError(string, string, object) Emits Configuration + Error (dependency/config missing, cannot proceed). public void ConfigurationError(string id, string text, object detail = null) Parameters id string text string detail object ConfigurationErrorFmt(ISentenceCarrier, string, FormattableString, object) Templated ConfigurationError(ISentenceCarrier, string, string, object) — keeps format + args for localization. public void ConfigurationErrorFmt(ISentenceCarrier sentenceCarrier, string id, FormattableString text, object detail = null) Parameters sentenceCarrier ISentenceCarrier id string text FormattableString detail object ConfigurationErrorFmt(string, FormattableString, object) Templated ConfigurationError(string, string, object) — keeps format + args for localization. public void ConfigurationErrorFmt(string id, FormattableString text, object detail = null) Parameters id string text FormattableString detail object ConfigurationMessage(ISentenceCarrier, string, string) Emits Configuration + Message located at sentenceCarrier. public void ConfigurationMessage(ISentenceCarrier sentenceCarrier, string id, string text) Parameters sentenceCarrier ISentenceCarrier id string text string ConfigurationMessage(string, string) Emits Configuration + Message (dependency/config applied, informational event). public void ConfigurationMessage(string id, string text) Parameters id string text string ConfigurationMessageFmt(ISentenceCarrier, string, FormattableString) Templated ConfigurationMessage(ISentenceCarrier, string, string) — keeps format + args for localization. public void ConfigurationMessageFmt(ISentenceCarrier sentenceCarrier, string id, FormattableString text) Parameters sentenceCarrier ISentenceCarrier id string text FormattableString ConfigurationMessageFmt(string, FormattableString) Templated ConfigurationMessage(string, string) — keeps format + args for localization. public void ConfigurationMessageFmt(string id, FormattableString text) Parameters id string text FormattableString ConfigurationWarning(ISentenceCarrier, string, string, object) Emits Configuration + Warning located at sentenceCarrier. public void ConfigurationWarning(ISentenceCarrier sentenceCarrier, string id, string text, object detail = null) Parameters sentenceCarrier ISentenceCarrier id string text string detail object ConfigurationWarning(string, string, object) Emits Configuration + Warning (dependency/config missing, using fallback). public void ConfigurationWarning(string id, string text, object detail = null) Parameters id string text string detail object ConfigurationWarningFmt(ISentenceCarrier, string, FormattableString, object) Templated ConfigurationWarning(ISentenceCarrier, string, string, object) — keeps format + args for localization. public void ConfigurationWarningFmt(ISentenceCarrier sentenceCarrier, string id, FormattableString text, object detail = null) Parameters sentenceCarrier ISentenceCarrier id string text FormattableString detail object ConfigurationWarningFmt(string, FormattableString, object) Templated ConfigurationWarning(string, string, object) — keeps format + args for localization. public void ConfigurationWarningFmt(string id, FormattableString text, object detail = null) Parameters id string text FormattableString detail object Report(NcDiagnostic) Reports a progress update. public void Report(NcDiagnostic value) Parameters value NcDiagnostic The value of the updated progress. SystemError(ISentenceCarrier, string, string, object) Emits System + Error located at sentenceCarrier. public void SystemError(ISentenceCarrier sentenceCarrier, string id, string text, object detail = null) Parameters sentenceCarrier ISentenceCarrier id string text string detail object SystemError(string, string, object) Emits System + Error (pipeline exception or unconsidered case). public void SystemError(string id, string text, object detail = null) Parameters id string text string detail object SystemErrorFmt(ISentenceCarrier, string, FormattableString, object) Templated SystemError(ISentenceCarrier, string, string, object) — keeps format + args for localization. public void SystemErrorFmt(ISentenceCarrier sentenceCarrier, string id, FormattableString text, object detail = null) Parameters sentenceCarrier ISentenceCarrier id string text FormattableString detail object SystemErrorFmt(string, FormattableString, object) Templated SystemError(string, string, object) — keeps format + args for localization. public void SystemErrorFmt(string id, FormattableString text, object detail = null) Parameters id string text FormattableString detail object SystemMessage(ISentenceCarrier, string, string) Emits System + Message located at sentenceCarrier. public void SystemMessage(ISentenceCarrier sentenceCarrier, string id, string text) Parameters sentenceCarrier ISentenceCarrier id string text string SystemMessage(string, string) Emits System + Message (pipeline lifecycle / informational). public void SystemMessage(string id, string text) Parameters id string text string SystemMessageFmt(ISentenceCarrier, string, FormattableString) Templated SystemMessage(ISentenceCarrier, string, string) — keeps format + args for localization. public void SystemMessageFmt(ISentenceCarrier sentenceCarrier, string id, FormattableString text) Parameters sentenceCarrier ISentenceCarrier id string text FormattableString SystemMessageFmt(string, FormattableString) Templated SystemMessage(string, string) — keeps format + args for localization. public void SystemMessageFmt(string id, FormattableString text) Parameters id string text FormattableString UnsupportedError(ISentenceCarrier, string, string, object) Emits Unsupported + Error located at sentenceCarrier. public void UnsupportedError(ISentenceCarrier sentenceCarrier, string id, string text, object detail = null) Parameters sentenceCarrier ISentenceCarrier id string text string detail object UnsupportedError(string, string, object) Emits Unsupported + Error (recognized but unimplemented, likely matters). public void UnsupportedError(string id, string text, object detail = null) Parameters id string text string detail object UnsupportedErrorFmt(ISentenceCarrier, string, FormattableString, object) Templated UnsupportedError(ISentenceCarrier, string, string, object) — keeps format + args for localization. public void UnsupportedErrorFmt(ISentenceCarrier sentenceCarrier, string id, FormattableString text, object detail = null) Parameters sentenceCarrier ISentenceCarrier id string text FormattableString detail object UnsupportedErrorFmt(string, FormattableString, object) Templated UnsupportedError(string, string, object) — keeps format + args for localization. public void UnsupportedErrorFmt(string id, FormattableString text, object detail = null) Parameters id string text FormattableString detail object UnsupportedMessage(ISentenceCarrier, string, string, object) Emits Unsupported + Message located at sentenceCarrier. public void UnsupportedMessage(ISentenceCarrier sentenceCarrier, string id, string text, object detail = null) Parameters sentenceCarrier ISentenceCarrier id string text string detail object UnsupportedMessage(string, string, object) Emits Unsupported + Message (recognized, intentionally not simulated, considered safe / no-op offline). public void UnsupportedMessage(string id, string text, object detail = null) Parameters id string text string detail object UnsupportedMessageFmt(ISentenceCarrier, string, FormattableString, object) Templated UnsupportedMessage(ISentenceCarrier, string, string, object) — keeps format + args for localization. public void UnsupportedMessageFmt(ISentenceCarrier sentenceCarrier, string id, FormattableString text, object detail = null) Parameters sentenceCarrier ISentenceCarrier id string text FormattableString detail object UnsupportedMessageFmt(string, FormattableString, object) Templated UnsupportedMessage(string, string, object) — keeps format + args for localization. public void UnsupportedMessageFmt(string id, FormattableString text, object detail = null) Parameters id string text FormattableString detail object UnsupportedWarning(ISentenceCarrier, string, string, object) Emits Unsupported + Warning located at sentenceCarrier. public void UnsupportedWarning(ISentenceCarrier sentenceCarrier, string id, string text, object detail = null) Parameters sentenceCarrier ISentenceCarrier id string text string detail object UnsupportedWarning(string, string, object) Emits Unsupported + Warning (recognized but unimplemented, likely harmless). public void UnsupportedWarning(string id, string text, object detail = null) Parameters id string text string detail object UnsupportedWarningFmt(ISentenceCarrier, string, FormattableString, object) Templated UnsupportedWarning(ISentenceCarrier, string, string, object) — keeps format + args for localization. public void UnsupportedWarningFmt(ISentenceCarrier sentenceCarrier, string id, FormattableString text, object detail = null) Parameters sentenceCarrier ISentenceCarrier id string text FormattableString detail object UnsupportedWarningFmt(string, FormattableString, object) Templated UnsupportedWarning(string, string, object) — keeps format + args for localization. public void UnsupportedWarningFmt(string id, FormattableString text, object detail = null) Parameters id string text FormattableString detail object ValidationError(ISentenceCarrier, string, string, object) Emits Validation + Error located at sentenceCarrier. public void ValidationError(ISentenceCarrier sentenceCarrier, string id, string text, object detail = null) Parameters sentenceCarrier ISentenceCarrier id string text string detail object ValidationError(string, string, object) Emits Validation + Error (manufacturing/physics is unfeasible). public void ValidationError(string id, string text, object detail = null) Parameters id string text string detail object ValidationErrorFmt(ISentenceCarrier, string, FormattableString, object) Templated ValidationError(ISentenceCarrier, string, string, object) — keeps format + args for localization. public void ValidationErrorFmt(ISentenceCarrier sentenceCarrier, string id, FormattableString text, object detail = null) Parameters sentenceCarrier ISentenceCarrier id string text FormattableString detail object ValidationErrorFmt(string, FormattableString, object) Templated ValidationError(string, string, object) — keeps format + args for localization. public void ValidationErrorFmt(string id, FormattableString text, object detail = null) Parameters id string text FormattableString detail object ValidationWarning(ISentenceCarrier, string, string, object) Emits Validation + Warning located at sentenceCarrier. public void ValidationWarning(ISentenceCarrier sentenceCarrier, string id, string text, object detail = null) Parameters sentenceCarrier ISentenceCarrier id string text string detail object ValidationWarning(string, string, object) Emits Validation + Warning (manufacturing/physics may be unfeasible). public void ValidationWarning(string id, string text, object detail = null) Parameters id string text string detail object ValidationWarningFmt(ISentenceCarrier, string, FormattableString, object) Templated ValidationWarning(ISentenceCarrier, string, string, object) — keeps format + args for localization. public void ValidationWarningFmt(ISentenceCarrier sentenceCarrier, string id, FormattableString text, object detail = null) Parameters sentenceCarrier ISentenceCarrier id string text FormattableString detail object ValidationWarningFmt(string, FormattableString, object) Templated ValidationWarning(string, string, object) — keeps format + args for localization. public void ValidationWarningFmt(string id, FormattableString text, object detail = null) Parameters id string text FormattableString detail object Events Cleared Raised after Clear() empties the collection. public event Action Cleared Event Type Action MessageAdded Raised after a diagnostic has been appended. Carries the index it landed at in Diagnostics and the appended diagnostic, so a consumer can place it and reach nearby items by indexing into Diagnostics. public event Action<int, NcDiagnostic> MessageAdded Event Type Action<int, NcDiagnostic>"
  },
  "api/Hi.NcParsers.NcRunnerSuit.html": {
    "href": "api/Hi.NcParsers.NcRunnerSuit.html",
    "title": "Class NcRunnerSuit | HiAPI-C# 2025",
    "summary": "Class NcRunnerSuit Namespace Hi.NcParsers Assembly HiMech.dll A switchable “runner suit”: bundles the per-machine NC pipeline (SoftNcRunner plus its optional side-file path SoftNcRunnerFile) with the per-workpiece PerCaseNcDependencyList the runner's INcDependencyProxy placeholders resolve against. The suit is the proxies' INcDependencyListHost, so the runner and its case data switch together as one unit — load a different suit to switch the active parser (NC or CSV) within a session. Read/Write only (pure IO, no own XxxFile identity pointer): the owning project serializes the suit's two members flat in the project XML, keeping the per-workpiece PerCaseNcDependencyList project-local rather than a shared side file. public class NcRunnerSuit : IMakeXmlSource, INcDependencyListHost Inheritance object NcRunnerSuit Implements IMakeXmlSource INcDependencyListHost Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NcRunnerSuit() Creates a default suit (Fanuc preset runner, empty per-case list). public NcRunnerSuit() NcRunnerSuit(XElement, string, string, IProgress<IMessage>, object[]) Reconstructs a suit from a <NcRunnerSuit> element previously produced by MakeXmlSource(string, string, bool). The runner unwraps an optional SoftNcRunnerFile side-file ref (stamped back onto SoftNcRunnerFile); the per-case list falls back to the legacy element name NcDependencyList. Proxies are bound to this suit before returning. public NcRunnerSuit(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress, object[] res = null) Parameters src XElement baseDirectory string relFile string progress IProgress<IMessage> res object[] Properties PerCaseNcDependencyList The case-specific dependencies (tool offsets, coordinate tables, parameter tables, …) that proxies take from — never the runner's own fixed list. A get-or-create proxy may also append the dependency it makes here. public List<INcDependency> PerCaseNcDependencyList { get; set; } Property Value List<INcDependency> SoftNcRunner The per-machine NC pipeline. Plain auto-property: callers that (re)assign it at construction or switch time call WireNcDependencyProxies() explicitly once the per-case list is also in place (so proxy host binding is not run prematurely against a stale list). public SoftNcRunner SoftNcRunner { get; set; } Property Value SoftNcRunner SoftNcRunnerFile Project-relative file path of the SoftNcRunner XML. When non-null the runner is written to a sibling side file and referenced; when null it is inlined. Mirrors MachiningEquipment.MachiningChainFile. public string SoftNcRunnerFile { get; set; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Serializes the suit as <NcRunnerSuit> containing <SoftNcRunner> (honouring SoftNcRunnerFile — inline when null, side-file ref otherwise) and <PerCaseNcDependencyList>. The owning project wraps this in its own <NcRunnerSuit> slot and reloads it via XFactory's GenByChild. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string relFile string exhibitionOnly bool Returns XElement Reg(XFactory) Registers NcRunnerSuit and chains Reg(XFactory) for every pipeline component a suit may deserialize. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory WireNcDependencyProxies() Binds every INcDependencyProxy in SoftNcRunner's pipeline list to THIS suit as host; a get-or-create proxy materializes its data into PerCaseNcDependencyList. Idempotent. Call after (re)assigning SoftNcRunner or PerCaseNcDependencyList. public void WireNcDependencyProxies()"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.BlockSkipSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.BlockSkipSyntax.html",
    "title": "Class BlockSkipSyntax | HiAPI-C# 2025",
    "summary": "Class BlockSkipSyntax Namespace Hi.NcParsers.ParsingSyntaxs Assembly HiMech.dll Parses the ISO 6983 / Fanuc Block Delete (a.k.a. Block Skip) prefix / or /N (N = 1..9) at the head of an NC block. Behaviour: No leading / → no-op, no BlockSkip section is written. / with IBlockSkipConfig layer OFF (or the dependency absent) → prefix is consumed, BlockSkip Symbol/Layer recorded for audit, Body stays null; the rest of the block stays in UnparsedText and parses normally. / with layer ON → the remaining block text is moved from UnparsedText into Body and UnparsedText is cleared. Downstream parsing syntaxes see no NC text so they emit nothing; semantics therefore produce no act. Must run after comment / CsScript syntaxes so that comments (and CsScript embedded in comments) continue to take effect regardless of the skip switch. public class BlockSkipSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object BlockSkipSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild.UnparsedText: /X100 Y200 #AfterBuild: { \"UnparsedText\": \"X100 Y200\", \"BlockSkip\": { \"Symbol\": \"/\", \"Layer\": 1 } } #BeforeBuild.UnparsedText: /3 G01 X0 #AfterBuild: { \"UnparsedText\": \"G01 X0\", \"BlockSkip\": { \"Symbol\": \"/\", \"Layer\": 3 } } Constructors BlockSkipSyntax() Initializes a new instance with default settings. public BlockSkipSyntax() BlockSkipSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public BlockSkipSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.CommentSyntaxs.QuoteCommentSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.CommentSyntaxs.QuoteCommentSyntax.html",
    "title": "Class QuoteCommentSyntax | HiAPI-C# 2025",
    "summary": "Class QuoteCommentSyntax Namespace Hi.NcParsers.ParsingSyntaxs.CommentSyntaxs Assembly HiMech.dll Parses parenthesized comments such as (comment text) from the remaining unparsed text and emits a Comment section with the () symbol. public class QuoteCommentSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object QuoteCommentSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild.UnparsedText: (only a comment) #AfterBuild: { \"Comment\": { \"Symbol\": \"()\", \"Text\": \"only a comment\" } } #BeforeBuild.UnparsedText: G01 X100 (mid-line comment) #AfterBuild: { \"UnparsedText\": \"G01 X100\", \"Comment\": { \"Symbol\": \"()\", \"Text\": \"mid-line comment\" } } Constructors QuoteCommentSyntax() Initializes a new instance with default settings. public QuoteCommentSyntax() QuoteCommentSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public QuoteCommentSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.CommentSyntaxs.TailCommentSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.CommentSyntaxs.TailCommentSyntax.html",
    "title": "Class TailCommentSyntax | HiAPI-C# 2025",
    "summary": "Class TailCommentSyntax Namespace Hi.NcParsers.ParsingSyntaxs.CommentSyntaxs Assembly HiMech.dll In-situ syntax that strips a trailing comment from the NC line: text from a configured TailSymbol to end-of-line is moved into Comment on the block JSON. Line-aware on multi-line sentences (Heidenhain grouped / ~-continued blocks): the marker-to-end-of-line strip applies per physical line, so a ; comment on one cycle-parameter line never swallows the following lines. Stripped comment texts are joined into a single Comment record. Single-line sentences behave exactly as before. public class TailCommentSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object TailCommentSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild.UnparsedText: ;header comment (with TailSymbol=\";\") #AfterBuild: { \"Comment\": { \"Symbol\": \";\", \"Text\": \"header comment\" } } #BeforeBuild.UnparsedText: G01 X100 ;mid comment (with TailSymbol=\";\") #AfterBuild: { \"UnparsedText\": \"G01 X100\", \"Comment\": { \"Symbol\": \";\", \"Text\": \"mid comment\" } } #BeforeBuild.UnparsedText: MSG(“A;B”) ;note (with TailSymbol=\";\" — the ‘;’ inside the quoted string is not a comment start) #AfterBuild: { \"UnparsedText\": \"MSG(\\\"A;B\\\")\", \"Comment\": { \"Symbol\": \";\", \"Text\": \"note\" } } Constructors TailCommentSyntax(string) Creates syntax with the given tail marker; used from code or tests without XML. public TailCommentSyntax(string tailSymbol) Parameters tailSymbol string Marker that starts the tail comment segment. TailCommentSyntax(XElement) Loads TailSymbol from persisted XML. public TailCommentSyntax(XElement src) Parameters src XElement Serialized syntax element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string TailSymbol First character(s) of the tail comment marker (e.g. ; or //). public string TailSymbol { get; set; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.CommentSyntaxs.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.CommentSyntaxs.html",
    "title": "Namespace Hi.NcParsers.ParsingSyntaxs.CommentSyntaxs | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.ParsingSyntaxs.CommentSyntaxs Classes QuoteCommentSyntax Parses parenthesized comments such as (comment text) from the remaining unparsed text and emits a Comment section with the () symbol. TailCommentSyntax In-situ syntax that strips a trailing comment from the NC line: text from a configured TailSymbol to end-of-line is moved into Comment on the block JSON. Line-aware on multi-line sentences (Heidenhain grouped / ~-continued blocks): the marker-to-end-of-line strip applies per physical line, so a ; comment on one cycle-parameter line never swallows the following lines. Stripped comment texts are joined into a single Comment record. Single-line sentences behave exactly as before."
  },
  "api/Hi.NcParsers.ParsingSyntaxs.CsScriptSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.CsScriptSyntax.html",
    "title": "Class CsScriptSyntax | HiAPI-C# 2025",
    "summary": "Class CsScriptSyntax Namespace Hi.NcParsers.ParsingSyntaxs Assembly HiMech.dll Extracts C# script markers from the oral content of a comment. PreMarker marks a script that runs before the NC block; PostMarker marks a script that runs after. The symbols are configurable and serialized to XML. public class CsScriptSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object CsScriptSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CsScriptSyntax() Creates syntax with DefaultPreMarker and DefaultPostMarker. public CsScriptSyntax() CsScriptSyntax(XElement) Loads pre/post script markers from persisted XML. public CsScriptSyntax(XElement src) Parameters src XElement Root element named XName. Fields DefaultPostMarker Default end-of-block script delimiter when none is configured in XML. public const string DefaultPostMarker = \"@@^\" Field Value string DefaultPreMarker Default begin-of-block script delimiter when none is configured in XML. public const string DefaultPreMarker = \"@@\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string PostMarker Marker prefix for end-of-block script (runs after the NC block). public string PostMarker { get; set; } Property Value string PreMarker Marker prefix for begin-of-block script (runs before the NC block). public string PreMarker { get; set; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Fanuc.FanucGotoParsingSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Fanuc.FanucGotoParsingSyntax.html",
    "title": "Class FanucGotoParsingSyntax | HiAPI-C# 2025",
    "summary": "Class FanucGotoParsingSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Fanuc Assembly HiMech.dll Parses Fanuc Custom Macro B GOTO phrases out of the remaining UnparsedText into a Parsing.FanucGoto sub-object. Two forms are recognised: GOTO <n> — unconditional jump. IF [<bool-expr>] GOTO <n> — conditional jump. IF [...] GOTO is matched as a single phrase, not as an IF syntax composed with a GOTO syntax — Fanuc only permits the two fixed forms (the other being IF [...] THEN <assignment>, out of scope here), so a phrase-level parser is more faithful and avoids parsing-ambiguity rabbit holes. <n> is captured as a raw token (literal like \"100\", variable like \"#1\", or bracketed expression like \"#[#2+5]\"). VariableEvaluatorSyntax substitutes the resolved literal back into the same field downstream; FanucGotoSyntax then parses the final string as an int. Storing as a string at parsing time mirrors how axis tags and canned-cycle params accept #N references and the evaluator rewrites them in place. Pipeline placement: after HeadIndexSyntax (so the leading N{seq} on a block like N50 GOTO 100 has already been consumed) and after QuoteCommentSyntax (so a parenthesised (GOTO 100) inside a comment never matches). The phrase consumes the entire remaining text on the block — Fanuc allows only the GOTO / IF-GOTO phrase after any preceding head index, no other instructions on the same block. public class FanucGotoParsingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object FanucGotoParsingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild.UnparsedText: GOTO 100 #AfterBuild: { \"Parsing\": { \"FanucGoto\": { \"Term\": \"GOTO\", \"N\": \"100\" } } } #BeforeBuild.UnparsedText: GOTO #1 #AfterBuild: { \"Parsing\": { \"FanucGoto\": { \"Term\": \"GOTO\", \"N\": \"#1\" } } } #BeforeBuild.UnparsedText: IF [#1 GT 0] GOTO 100 #AfterBuild: { \"Parsing\": { \"FanucGoto\": { \"Term\": \"IF...GOTO\", \"N\": \"100\", \"Condition\": \"#1 GT 0\" } } } Constructors FanucGotoParsingSyntax() Parameterless instance for bundle composition (no XML state). public FanucGotoParsingSyntax() FanucGotoParsingSyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public FanucGotoParsingSyntax(XElement src) Parameters src XElement Root element named XName. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Fanuc.FanucIfThenParsingSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Fanuc.FanucIfThenParsingSyntax.html",
    "title": "Class FanucIfThenParsingSyntax | HiAPI-C# 2025",
    "summary": "Class FanucIfThenParsingSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Fanuc Assembly HiMech.dll Parses the Fanuc Custom Macro B IF [<bool-expr>] THEN <body> single-block conditional phrase out of UnparsedText into a Parsing.FanucIfThen sub-object. Sibling to FanucGotoParsingSyntax — Fanuc spec only permits two IF-led control phrases (IF [...] GOTO <n> handled there, IF [...] THEN <stmt> handled here) so each form is matched phrase-level rather than composed from a generic IF combinator. Body shape. The body after THEN is conceptually a single statement that affects the current block only — no jump, no label scan. Almost always a Custom Macro B assignment (#nnn = <expr>); multiple assignments in the same body (#100 = 5. #101 = #100 + 1) are also accepted. The parsing syntax pre-extracts these via GrabTagAssignment(ref string, IEnumerable<string>, string, IEnumerable<string>, ExpressionPrefixParser) into Parsing.FanucIfThen.PendingAssignments as {tag: rhs-string} entries — that shape lets VariableEvaluatorSyntax's pass-2 tree walk substitute each RHS to a numeric in place, and lets FanucIfThenSyntax lift the resolved entries into Parsing.Assignments only when the gate condition fires (so unfired bodies leave no trace in the readers). Pipeline placement. This syntax must run before FanucGotoParsingSyntax — the bare IF-GOTO regex over there (^IF[..]GOTO n$) is anchored, but consuming IF-THEN here first keeps the two phrases textually disjoint and avoids any future regression if either regex is loosened. Also placed before TagAssignmentSyntax so a bare IF [...] THEN #100 = 5. is not first half-eaten as a plain assignment. Raw BodyText is retained verbatim on the parsing section regardless of whether the body parsed as assignments — it carries the round-trip view and lets the evaluation syntax warn (FanucIfThen--UnsupportedBody) if no PendingAssignments were produced on a truthy condition. public class FanucIfThenParsingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object FanucIfThenParsingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #Input: IF [#1 GT 0] THEN #100 = #500 + 1 #Output: { \"Parsing\": { \"FanucIfThen\": { \"Condition\": \"#1 GT 0\", \"BodyText\": \"#100 = #500 + 1\", \"PendingAssignments\": { \"#100\": \"#500 + 1\" } } } } Constructors FanucIfThenParsingSyntax() Parameterless instance for bundle composition (no XML state). public FanucIfThenParsingSyntax() FanucIfThenParsingSyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public FanucIfThenParsingSyntax(XElement src) Parameters src XElement Root element named XName. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Fanuc.FanucProgramNumberSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Fanuc.FanucProgramNumberSyntax.html",
    "title": "Class FanucProgramNumberSyntax | HiAPI-C# 2025",
    "summary": "Class FanucProgramNumberSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Fanuc Assembly HiMech.dll Detects a Fanuc-family program identifier header — O1234 or <O1234> — that follows a TapeBoundary line, and records it under FanucProgramNumber on the block JSON. The wrapping form (bare vs angle-bracketed) is preserved in Wrapper so the block can be emitted back to its original notation. public class FanucProgramNumberSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object FanucProgramNumberSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Bare O1234 on the first block of the stream (no #Previous:) — start-of-stream is itself a tape boundary per IsPreviousNodeTapeBoundary(LazyLinkedListNode<SyntaxPiece>), so the syntax fires; the consumed text leaves nothing behind: #BeforeBuild.UnparsedText: O1234 #AfterBuild: { \"FanucProgramNumber\": { \"Number\": \"1234\", \"Wrapper\": \"None\" } } Angle-bracketed <O5678> after an explicit TapeBoundary block (% on the prior line) — Wrapper records the surface form: #Previous: { \"TapeBoundary\": { \"Text\": \"\" } } #BeforeBuild.UnparsedText: <O5678> #AfterBuild: { \"FanucProgramNumber\": { \"Number\": \"5678\", \"Wrapper\": \"Angle\" } } O1234 followed by trailing text (e.g. an inline comment) — only the program-number header is consumed; the rest stays on UnparsedText for downstream syntaxes to handle: #Previous: { \"TapeBoundary\": { \"Text\": \"\" } } #BeforeBuild.UnparsedText: O1234 (PART-A) #AfterBuild: { \"UnparsedText\": \"(PART-A)\", \"FanucProgramNumber\": { \"Number\": \"1234\", \"Wrapper\": \"None\" } } Previous block is not a tape boundary (e.g. ordinary FanucProgramNumber already in the stream) — the guard rejects the block, leaving UnparsedText intact: #Previous: { \"FanucProgramNumber\": { \"Number\": \"1000\", \"Wrapper\": \"None\" } } #BeforeBuild.UnparsedText: O9999 #AfterBuild: { \"UnparsedText\": \"O9999\" } Constructors FanucProgramNumberSyntax() Parameterless instance for bundle composition (no XML state). public FanucProgramNumberSyntax() FanucProgramNumberSyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public FanucProgramNumberSyntax(XElement src) Parameters src XElement Root element named XName. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Fanuc.FanucWhileDoParsingSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Fanuc.FanucWhileDoParsingSyntax.html",
    "title": "Class FanucWhileDoParsingSyntax | HiAPI-C# 2025",
    "summary": "Class FanucWhileDoParsingSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Fanuc Assembly HiMech.dll Parses the two Fanuc Custom Macro B WHILE/END phrases out of UnparsedText into a Parsing.FanucWhileDo sub-object: WHILE [<bool-expr>] DO <m> — loop entry, writes { Term: \"WHILE...DO\", LoopId, Condition }. END <m> — loop terminator, writes { Term: \"END\", LoopId }. Pipeline placement. This syntax must run before TagAssignmentSyntax in the Parsing bundle — same lesson as FanucIfThenParsingSyntax: although the WHILE / END phrases per Fanuc spec do not coexist with assignments on the same block, the defensive ordering prevents a body fragment from being half-eaten as a stand-alone assignment if a non-spec NC file appears. LoopId is captured as an int directly (Fanuc spec restricts the m identifier to small literal integers 1–3 typical, no expression form). The WHILE's Condition is captured as a string and substituted in place by VariableEvaluatorSyntax's pass-2 tree walk; FanucWhileDoSyntax then reads it via the shared FanucConditionReader. public class FanucWhileDoParsingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object FanucWhileDoParsingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #Input: WHILE [#100 LT 3] DO 1 #Output: { \"Parsing\": { \"FanucWhileDo\": { \"Term\": \"WHILE...DO\", \"LoopId\": 1, \"Condition\": \"#100 LT 3\" } } } #Input: END 1 #Output: { \"Parsing\": { \"FanucWhileDo\": { \"Term\": \"END\", \"LoopId\": 1 } } } Constructors FanucWhileDoParsingSyntax() Parameterless instance for bundle composition (no XML state). public FanucWhileDoParsingSyntax() FanucWhileDoParsingSyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public FanucWhileDoParsingSyntax(XElement src) Parameters src XElement Root element named XName. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Fanuc.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Fanuc.html",
    "title": "Namespace Hi.NcParsers.ParsingSyntaxs.Fanuc | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.ParsingSyntaxs.Fanuc Classes FanucGotoParsingSyntax Parses Fanuc Custom Macro B GOTO phrases out of the remaining UnparsedText into a Parsing.FanucGoto sub-object. Two forms are recognised: GOTO <n> — unconditional jump. IF [<bool-expr>] GOTO <n> — conditional jump. IF [...] GOTO is matched as a single phrase, not as an IF syntax composed with a GOTO syntax — Fanuc only permits the two fixed forms (the other being IF [...] THEN <assignment>, out of scope here), so a phrase-level parser is more faithful and avoids parsing-ambiguity rabbit holes. <n> is captured as a raw token (literal like \"100\", variable like \"#1\", or bracketed expression like \"#[#2+5]\"). VariableEvaluatorSyntax substitutes the resolved literal back into the same field downstream; FanucGotoSyntax then parses the final string as an int. Storing as a string at parsing time mirrors how axis tags and canned-cycle params accept #N references and the evaluator rewrites them in place. Pipeline placement: after HeadIndexSyntax (so the leading N{seq} on a block like N50 GOTO 100 has already been consumed) and after QuoteCommentSyntax (so a parenthesised (GOTO 100) inside a comment never matches). The phrase consumes the entire remaining text on the block — Fanuc allows only the GOTO / IF-GOTO phrase after any preceding head index, no other instructions on the same block. FanucIfThenParsingSyntax Parses the Fanuc Custom Macro B IF [<bool-expr>] THEN <body> single-block conditional phrase out of UnparsedText into a Parsing.FanucIfThen sub-object. Sibling to FanucGotoParsingSyntax — Fanuc spec only permits two IF-led control phrases (IF [...] GOTO <n> handled there, IF [...] THEN <stmt> handled here) so each form is matched phrase-level rather than composed from a generic IF combinator. Body shape. The body after THEN is conceptually a single statement that affects the current block only — no jump, no label scan. Almost always a Custom Macro B assignment (#nnn = <expr>); multiple assignments in the same body (#100 = 5. #101 = #100 + 1) are also accepted. The parsing syntax pre-extracts these via GrabTagAssignment(ref string, IEnumerable<string>, string, IEnumerable<string>, ExpressionPrefixParser) into Parsing.FanucIfThen.PendingAssignments as {tag: rhs-string} entries — that shape lets VariableEvaluatorSyntax's pass-2 tree walk substitute each RHS to a numeric in place, and lets FanucIfThenSyntax lift the resolved entries into Parsing.Assignments only when the gate condition fires (so unfired bodies leave no trace in the readers). Pipeline placement. This syntax must run before FanucGotoParsingSyntax — the bare IF-GOTO regex over there (^IF[..]GOTO n$) is anchored, but consuming IF-THEN here first keeps the two phrases textually disjoint and avoids any future regression if either regex is loosened. Also placed before TagAssignmentSyntax so a bare IF [...] THEN #100 = 5. is not first half-eaten as a plain assignment. Raw BodyText is retained verbatim on the parsing section regardless of whether the body parsed as assignments — it carries the round-trip view and lets the evaluation syntax warn (FanucIfThen--UnsupportedBody) if no PendingAssignments were produced on a truthy condition. FanucProgramNumberSyntax Detects a Fanuc-family program identifier header — O1234 or <O1234> — that follows a TapeBoundary line, and records it under FanucProgramNumber on the block JSON. The wrapping form (bare vs angle-bracketed) is preserved in Wrapper so the block can be emitted back to its original notation. FanucWhileDoParsingSyntax Parses the two Fanuc Custom Macro B WHILE/END phrases out of UnparsedText into a Parsing.FanucWhileDo sub-object: WHILE [<bool-expr>] DO <m> — loop entry, writes { Term: \"WHILE...DO\", LoopId, Condition }. END <m> — loop terminator, writes { Term: \"END\", LoopId }. Pipeline placement. This syntax must run before TagAssignmentSyntax in the Parsing bundle — same lesson as FanucIfThenParsingSyntax: although the WHILE / END phrases per Fanuc spec do not coexist with assignments on the same block, the defensive ordering prevents a body fragment from being half-eaten as a stand-alone assignment if a non-spec NC file appears. LoopId is captured as an int directly (Fanuc spec restricts the m identifier to small literal integers 1–3 typical, no expression form). The WHILE's Condition is captured as a string and substituted in place by VariableEvaluatorSyntax's pass-2 tree walk; FanucWhileDoSyntax then reads it via the shared FanucConditionReader."
  },
  "api/Hi.NcParsers.ParsingSyntaxs.FlagSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.FlagSyntax.html",
    "title": "Class FlagSyntax | HiAPI-C# 2025",
    "summary": "Class FlagSyntax Namespace Hi.NcParsers.ParsingSyntaxs Assembly HiMech.dll Syntax of fully Match flag. public class FlagSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object FlagSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks The term Flag generally not accomanys with variable value. The term Tag generally accomanys with variable value. Constructors FlagSyntax(IEnumerable<string>, IEnumerable<string>) Creates syntax from in-memory path and flag lists (tests or programmatic setup). public FlagSyntax(IEnumerable<string> categoryPath, IEnumerable<string> flags) Parameters categoryPath IEnumerable<string> flags IEnumerable<string> FlagSyntax(XElement) Loads category path and flag list items from XML. public FlagSyntax(XElement src) Parameters src XElement Root element named XName. Properties AllowGluedFollower When true, a matched flag may be glued to a following letter token: the trailing guard relaxes from \\b to (?![0-9]), so a post-processed klartext run like FMAXM03M08 still yields FMAX (a digit follower keeps rejecting, so a flag never claims the head of a longer numbered word). Default false preserves the word-bounded match for every other brand list. public bool AllowGluedFollower { get; set; } Property Value bool CategoryPath JSON path segments (each Item) under which matched flags are stored. public List<string> CategoryPath { get; set; } Property Value List<string> FlagList NC tokens to detect and record as flags (exact match). public List<string> FlagList { get; set; } Property Value List<string> Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.FloatTagValueSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.FloatTagValueSyntax.html",
    "title": "Class FloatTagValueSyntax | HiAPI-C# 2025",
    "summary": "Class FloatTagValueSyntax Namespace Hi.NcParsers.ParsingSyntaxs Assembly HiMech.dll TagValueSyntax that parses numeric literal values to double. Variable text (e.g. Q2, #1, [#1+#2]) remains as string. public class FloatTagValueSyntax : TagValueSyntax, ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object TagValueSyntax FloatTagValueSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members TagValueSyntax.MakeXmlSource(string, string, bool) TagValueSyntax.VariableTag TagValueSyntax.CategoryPath TagValueSyntax.TagList TagValueSyntax.AllowEqualsForm TagValueSyntax.AllowSpacedValue TagValueSyntax.RhsDialect TagValueSyntax.Name TagValueSyntax.Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FloatTagValueSyntax(IEnumerable<string>, IEnumerable<string>, string) Initializes a new instance with the given category path, tag list, and variable-tag pattern. public FloatTagValueSyntax(IEnumerable<string> categoryPath, IEnumerable<string> tags, string variableTag) Parameters categoryPath IEnumerable<string> JSON path under Parsing where matches are written. tags IEnumerable<string> Single-letter tag names whose values are grabbed. variableTag string Regex/literal recognizing a variable reference as a value. FloatTagValueSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public FloatTagValueSyntax(XElement src) Parameters src XElement Source XML element. Properties XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToFloat(string) Parses a numeric literal to double; returns the original string for variable text. public static JsonNode ToFloat(string setup) Parameters setup string Returns JsonNode ToValueJsonNode(string) Converts a tag setup string value to a JsonNode. Override in derived classes for typed parsing (int, double). Variable text (e.g. Q2, #1, [#1+#2]) is kept as string. protected override JsonNode ToValueJsonNode(string setup) Parameters setup string Returns JsonNode"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.HeadIndexSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.HeadIndexSyntax.html",
    "title": "Class HeadIndexSyntax | HiAPI-C# 2025",
    "summary": "Class HeadIndexSyntax Namespace Hi.NcParsers.ParsingSyntaxs Assembly HiMech.dll Parses a leading block index (e.g. Heidenhain line numbers) after an optional HeadSymbol prefix. public class HeadIndexSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeadIndexSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild.UnparsedText: N100 X0 (with HeadSymbol=“N”) #AfterBuild: { \"UnparsedText\": \"X0\", \"IndexNote\": { \"Symbol\": \"N\", \"Number\": 100 } } #BeforeBuild.UnparsedText: N42 (lone head index, no trailing tokens; with HeadSymbol=“N”) #AfterBuild: { \"IndexNote\": { \"Symbol\": \"N\", \"Number\": 42 } } Constructors HeadIndexSyntax(string) Creates syntax with the given head symbol prefix (may be empty). public HeadIndexSyntax(string headSymbol) Parameters headSymbol string HeadIndexSyntax(XElement) Loads HeadSymbol from persisted XML. public HeadIndexSyntax(XElement src) Parameters src XElement Root element named XName. Properties HeadSymbol public string HeadSymbol { get; set; } Property Value string Remarks The Head Symbol can be not null empty string. NC Index from Heidenhain may have no head symbol. Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.CyclDefSyntaxs.HeidenhainDatumSettingSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.CyclDefSyntaxs.HeidenhainDatumSettingSyntax.html",
    "title": "Class HeidenhainDatumSettingSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainDatumSettingSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain.CyclDefSyntaxs Assembly HiMech.dll Heidenhain syntax of CYCL DEF 247 DATUM SETTING and its DIN/ISO twin G247 Q339=+N (both spellings stamp the same cycle-number record for the Logic-side datum-preset resolver). public class HeidenhainDatumSettingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainDatumSettingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainDatumSettingSyntax() Initializes a new instance with default settings. public HeidenhainDatumSettingSyntax() HeidenhainDatumSettingSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainDatumSettingSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string TagList Tags to grab as float-valued coordinates within the cycle body. public List<string> TagList { get; set; } Property Value List<string> XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.CyclDefSyntaxs.HeidenhainDatumShiftSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.CyclDefSyntaxs.HeidenhainDatumShiftSyntax.html",
    "title": "Class HeidenhainDatumShiftSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainDatumShiftSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain.CyclDefSyntaxs Assembly HiMech.dll Heidenhain syntax of CYCL DEF 7 DATUM SHIFT and its DIN/ISO twin G54 WITH axis words (G54 X+50 Y+50 shifts the datum, zero values cancel it — a declaration, never a motion block; the bare G54 spelling stays on the Fanuc-style work-offset select path). The klartext I-prefixed words (CYCL DEF 7.2 IY+5) are kept under their prefixed keys in the Parsing[“DATUM SHIFT”] record — a shift BY the value on top of the active shift, which HeidenhainCoordinateOffsetSyntax resolves; never the tool-position-relative PositioningOverride stamp. public class HeidenhainDatumShiftSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainDatumShiftSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainDatumShiftSyntax() Initializes a new instance with default settings. public HeidenhainDatumShiftSyntax() HeidenhainDatumShiftSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainDatumShiftSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string TagList Tags to grab as float-valued coordinates within the cycle body. The klartext I-prefixed forms are grabbed over the fixed axis set (AxisTagList), independent of this list. public List<string> TagList { get; set; } Property Value List<string> XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.CyclDefSyntaxs.HeidenhainMachiningCycleSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.CyclDefSyntaxs.HeidenhainMachiningCycleSyntax.html",
    "title": "Class HeidenhainMachiningCycleSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainMachiningCycleSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain.CyclDefSyntaxs Assembly HiMech.dll Captures the body of a machining CYCL DEF (every cycle number without a dedicated owner — the datum family 7/247 and the tolerance family 32 keep their own syntaxes) into a structured Parsing.MachiningCycle record: { Number, Title?, Params?, Args? }. Params — every Qnnn=value assignment in the head and body lines. Literal values are stored as JSON numbers (via ToFloat(string) — a string node would read as an unevaluated variable downstream); Q-reference values stay strings for the evaluator to substitute in place. Q mirror — each captured assignment is also mirrored into Parsing.Assignments (raw string RHS): on a real TNC the cycle definition genuinely assigns those Q parameters, and pre-P4 corpus behavior (each parameter line was its own sentence consumed by the bare-assignment capture) already routed them into the volatile Q store. The mirror keeps that store contract intact now that the ~-grouped sentence is claimed here first. Title — the non-assignment remainder of the head line (e.g. PLANFRAESEN). Args — any other non-assignment body remainder, swept into the record so residue (e.g. CYCL DEF 19.1 A90 B0 C105 rotary words) can never leak into axis captures — the PLANE-family precedent from P3. The ISO mapping and the armed/modal bookkeeping happen in HeidenhainCannedCycleSyntax. Multi-line capture is covered by regular unit tests rather than the conformance examples below (the conformance shorthand is single-line only). public class HeidenhainMachiningCycleSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainMachiningCycleSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainMachiningCycleSyntax() Initializes a new instance with default settings. public HeidenhainMachiningCycleSyntax() HeidenhainMachiningCycleSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainMachiningCycleSyntax(XElement src) Parameters src XElement Source XML element. Fields ArgsKey Record key of the swept non-assignment remainder. public const string ArgsKey = \"Args\" Field Value string MachiningCycleKey JSON key of the record under Parsing. public const string MachiningCycleKey = \"MachiningCycle\" Field Value string NumberKey Record key of the cycle number. public const string NumberKey = \"Number\" Field Value string ParamsKey Record key of the captured Q-parameter map. public const string ParamsKey = \"Params\" Field Value string TitleKey Record key of the cycle title text. public const string TitleKey = \"Title\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.CyclDefSyntaxs.HeidenhainMirrorCyclSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.CyclDefSyntaxs.HeidenhainMirrorCyclSyntax.html",
    "title": "Class HeidenhainMirrorCyclSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainMirrorCyclSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain.CyclDefSyntaxs Assembly HiMech.dll Structures the klartext CYCL DEF 8 MIRROR IMAGE cycle (grouped 8.0 MIRROR IMAGE / 8.1 X Y, or the single-line spelling) into the same Parsing.MirrorImageKey statement list its DIN/ISO twin G28 writes, so the shared HeidenhainMirrorTransformSyntax simulates both dialects through one code path. Runs after HeidenhainCyclDefSyntax (which contributes Parsing[“CYCL DEF”] = 8 + CyclHead) and ahead of HeidenhainMachiningCycleSyntax, whose generic capture would otherwise route the cycle to the unsupported-cycle path. The cycle body is the manual's bare axis letters (a bare 8.1 cancels the mirror). A body carrying anything else — a valued word, an unknown token — is not claimed at all: the block falls through to the generic machining-cycle capture and its HeidenhainCycl--Unsupported report, which is the correct fail-soft. Claiming it would silently reduce to an empty axis list, i.e. read a shape we do not understand as a mirror reset. public class HeidenhainMirrorCyclSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainMirrorCyclSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples The grouped two-axis form — the cycle keys are consumed and the statement joins the shared list (block text stays authoritative for round-trip emission): #BeforeBuild: { \"UnparsedText\": \"X Y\", \"Parsing\": { \"CYCL DEF\": 8, \"CyclHead\": \"MIRROR IMAGE\" } } #AfterBuild: { \"Parsing\": { \"MirrorImage\": [ { \"Axes\": [\"X\", \"Y\"] } ] } } A bare 8.1 line cancels the mirror — an empty axis list, the same shape the ISO bare G28 records: #BeforeBuild: { \"UnparsedText\": \"\", \"Parsing\": { \"CYCL DEF\": 8, \"CyclHead\": \"MIRROR IMAGE\" } } #AfterBuild: { \"Parsing\": { \"MirrorImage\": [ { \"Axes\": [] } ] } } Single-line spelling — the axis line landed in CyclHead instead of the body (the tolerance-cycle precedent): #BeforeBuild: { \"Parsing\": { \"CYCL DEF\": 8, \"CyclHead\": \"X\" } } #AfterBuild: { \"Parsing\": { \"MirrorImage\": [ { \"Axes\": [\"X\"] } ] } } A rotary letter is recorded like any other and left for the Logic gate to reject — the dialects must not disagree on scope: #BeforeBuild: { \"UnparsedText\": \"C\", \"Parsing\": { \"CYCL DEF\": 8, \"CyclHead\": \"MIRROR IMAGE\" } } #AfterBuild: { \"Parsing\": { \"MirrorImage\": [ { \"Axes\": [\"C\"] } ] } } A valued word is not the manual's mirror form: nothing is claimed, so the generic machining-cycle capture still reports the cycle unsupported instead of this syntax reading it as a reset: #BeforeBuild: { \"UnparsedText\": \"X+0\", \"Parsing\": { \"CYCL DEF\": 8, \"CyclHead\": \"MIRROR IMAGE\" } } #AfterBuild: { \"UnparsedText\": \"X+0\", \"Parsing\": { \"CYCL DEF\": 8, \"CyclHead\": \"MIRROR IMAGE\" } } Another cycle number is none of this syntax's business: #BeforeBuild: { \"UnparsedText\": \"T0.05\", \"Parsing\": { \"CYCL DEF\": 32, \"CyclHead\": \"TOLERANCE\" } } #AfterBuild: { \"UnparsedText\": \"T0.05\", \"Parsing\": { \"CYCL DEF\": 32, \"CyclHead\": \"TOLERANCE\" } } Constructors HeidenhainMirrorCyclSyntax() Initializes a new instance with default settings. public HeidenhainMirrorCyclSyntax() HeidenhainMirrorCyclSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainMirrorCyclSyntax(XElement src) Parameters src XElement Source XML element. Fields CyclNumber CYCL DEF number this syntax structures. public const int CyclNumber = 8 Field Value int TitleConst Title word of the cycle's .0 line. public const string TitleConst = \"MIRROR\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.CyclDefSyntaxs.HeidenhainToleranceCyclSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.CyclDefSyntaxs.HeidenhainToleranceCyclSyntax.html",
    "title": "Class HeidenhainToleranceCyclSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainToleranceCyclSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain.CyclDefSyntaxs Assembly HiMech.dll Structures the klartext CYCL DEF 32 TOLERANCE cycle (grouped 32.0 TOLERANCE / 32.1 T0.1 / 32.2 HSC-MODE:0 TA0.5 or the single-line forms) into Parsing.TOLERANCE { T?, HscMode?, Ta? } for HeidenhainPathSmoothingSyntax. Runs after HeidenhainCyclDefSyntax (which contributes Parsing[“CYCL DEF”] = 32 + CyclHead). A bare 32.0 line (no T) is a tolerance reset and records Bare: true. The glued corpus spelling 32.2HSC-MODE:0 leaves a digit-prefixed residue after the CyclDef prefix strip — the HSC grab tolerates it. public class HeidenhainToleranceCyclSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainToleranceCyclSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainToleranceCyclSyntax() Initializes a new instance with default settings. public HeidenhainToleranceCyclSyntax() HeidenhainToleranceCyclSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainToleranceCyclSyntax(XElement src) Parameters src XElement Source XML element. Fields CyclNumber CYCL DEF number this syntax structures. public const int CyclNumber = 32 Field Value int TitleConst Title word / Parsing record key. public const string TitleConst = \"TOLERANCE\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.CyclDefSyntaxs.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.CyclDefSyntaxs.html",
    "title": "Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain.CyclDefSyntaxs | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain.CyclDefSyntaxs Classes HeidenhainDatumSettingSyntax Heidenhain syntax of CYCL DEF 247 DATUM SETTING and its DIN/ISO twin G247 Q339=+N (both spellings stamp the same cycle-number record for the Logic-side datum-preset resolver). HeidenhainDatumShiftSyntax Heidenhain syntax of CYCL DEF 7 DATUM SHIFT and its DIN/ISO twin G54 WITH axis words (G54 X+50 Y+50 shifts the datum, zero values cancel it — a declaration, never a motion block; the bare G54 spelling stays on the Fanuc-style work-offset select path). The klartext I-prefixed words (CYCL DEF 7.2 IY+5) are kept under their prefixed keys in the Parsing[“DATUM SHIFT”] record — a shift BY the value on top of the active shift, which HeidenhainCoordinateOffsetSyntax resolves; never the tool-position-relative PositioningOverride stamp. HeidenhainMachiningCycleSyntax Captures the body of a machining CYCL DEF (every cycle number without a dedicated owner — the datum family 7/247 and the tolerance family 32 keep their own syntaxes) into a structured Parsing.MachiningCycle record: { Number, Title?, Params?, Args? }. Params — every Qnnn=value assignment in the head and body lines. Literal values are stored as JSON numbers (via ToFloat(string) — a string node would read as an unevaluated variable downstream); Q-reference values stay strings for the evaluator to substitute in place. Q mirror — each captured assignment is also mirrored into Parsing.Assignments (raw string RHS): on a real TNC the cycle definition genuinely assigns those Q parameters, and pre-P4 corpus behavior (each parameter line was its own sentence consumed by the bare-assignment capture) already routed them into the volatile Q store. The mirror keeps that store contract intact now that the ~-grouped sentence is claimed here first. Title — the non-assignment remainder of the head line (e.g. PLANFRAESEN). Args — any other non-assignment body remainder, swept into the record so residue (e.g. CYCL DEF 19.1 A90 B0 C105 rotary words) can never leak into axis captures — the PLANE-family precedent from P3. The ISO mapping and the armed/modal bookkeeping happen in HeidenhainCannedCycleSyntax. Multi-line capture is covered by regular unit tests rather than the conformance examples below (the conformance shorthand is single-line only). HeidenhainMirrorCyclSyntax Structures the klartext CYCL DEF 8 MIRROR IMAGE cycle (grouped 8.0 MIRROR IMAGE / 8.1 X Y, or the single-line spelling) into the same Parsing.MirrorImageKey statement list its DIN/ISO twin G28 writes, so the shared HeidenhainMirrorTransformSyntax simulates both dialects through one code path. Runs after HeidenhainCyclDefSyntax (which contributes Parsing[“CYCL DEF”] = 8 + CyclHead) and ahead of HeidenhainMachiningCycleSyntax, whose generic capture would otherwise route the cycle to the unsupported-cycle path. The cycle body is the manual's bare axis letters (a bare 8.1 cancels the mirror). A body carrying anything else — a valued word, an unknown token — is not claimed at all: the block falls through to the generic machining-cycle capture and its HeidenhainCycl--Unsupported report, which is the correct fail-soft. Claiming it would silently reduce to an empty axis list, i.e. read a shape we do not understand as a mirror reset. HeidenhainToleranceCyclSyntax Structures the klartext CYCL DEF 32 TOLERANCE cycle (grouped 32.0 TOLERANCE / 32.1 T0.1 / 32.2 HSC-MODE:0 TA0.5 or the single-line forms) into Parsing.TOLERANCE { T?, HscMode?, Ta? } for HeidenhainPathSmoothingSyntax. Runs after HeidenhainCyclDefSyntax (which contributes Parsing[“CYCL DEF”] = 32 + CyclHead). A bare 32.0 line (no T) is a tolerance reset and records Bare: true. The glued corpus spelling 32.2HSC-MODE:0 leaves a digit-prefixed residue after the CyclDef prefix strip — the HSC grab tolerates it."
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainBlkFormSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainBlkFormSyntax.html",
    "title": "Class HeidenhainBlkFormSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainBlkFormSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Assembly HiMech.dll Syntax for Heidenhain BLK FORM command (workpiece blank definition). public class HeidenhainBlkFormSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainBlkFormSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild.UnparsedText: BLK FORM 0.1 Z X+0 Y+0 Z-40 #AfterBuild: { \"Parsing\": { \"BLK FORM\": { \"Type\": \"0.1\", \"Axis\": \"Z\", \"X\": 0, \"Y\": 0, \"Z\": -40 } } } #BeforeBuild.UnparsedText: BLK FORM 0.2 X+100 Y+100 Z+0 #AfterBuild: { \"Parsing\": { \"BLK FORM\": { \"Type\": \"0.2\", \"X\": 100, \"Y\": 100, \"Z\": 0 } } } #BeforeBuild.UnparsedText: BLK FORM CYLINDER Z R50 L105 #AfterBuild: { \"Parsing\": { \"BLK FORM\": { \"Type\": \"CYLINDER\", \"Axis\": \"Z\", \"R\": 50, \"L\": 105 } } } Constructors HeidenhainBlkFormSyntax() Initializes a new instance with default settings. public HeidenhainBlkFormSyntax() HeidenhainBlkFormSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainBlkFormSyntax(XElement src) Parameters src XElement Source XML element. Fields BlkFormTagList Tags for BLK FORM coordinate/dimension values. public static readonly string[] BlkFormTagList Field Value string[] Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainCSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainCSyntax.html",
    "title": "Class HeidenhainCSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainCSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Assembly HiMech.dll Heidenhain circular-motion statement (C X+5.361 Y+23.064 DR-). Mirrors HeidenhainLSyntax: endpoint axis words promote to the Parsing root (shared Logic consumers), a “CArc”: true statement marker (deliberately NOT the bare C key — that is a rotary axis word which McAbcSyntax owns and consumes on rotary machines) gates HeidenhainCircularMotionSyntax, the rotation direction lands in Parsing.DR (\"-\" = CW = G02, \"+\" = CCW = G03) and radius-compensation words are captured like on L statements. The word-boundary head guard rejects CC/CT/CR/CP statements, and a value follower rejects a leading rotary-axis word — a DIN/ISO block like C-90. (modal C-axis positioning, the same mixed-dialect list) is an axis coordinate for the root tag capture, never a klartext arc statement head (klartext always separates the C head from its X/Y/DR words, so a sign/digit/dot follower cannot be an arc statement). Incremental endpoint words (C IX+20 IY+0 DR-) are captured like on L statements — plain axis keys plus the block-root PositioningOverride stamp, see HeidenhainIncrementalAxisWordUtil. public class HeidenhainCSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainCSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild.UnparsedText: C X+5.361 Y+23.064 DR- #AfterBuild: { \"Parsing\": { \"CArc\": true, \"DR\": \"-\", \"X\": 5.361, \"Y\": 23.064 } } DIN/ISO rotary-axis positioning — the value follower keeps the head gate shut; the block is left for the shared float tag capture: #BeforeBuild.UnparsedText: C-90.0 #AfterBuild: { \"UnparsedText\": \"C-90.0\" } Incremental endpoint — the arc end is a distance from the arc's own start; the stamp routes it through the shared resolve: #BeforeBuild.UnparsedText: C IX+20 IY+0 DR- #AfterBuild: { \"Parsing\": { \"CArc\": true, \"DR\": \"-\", \"X\": 20, \"Y\": 0 }, \"PositioningOverride\": { \"X\": \"Incremental\", \"Y\": \"Incremental\" } } Constructors HeidenhainCSyntax() Initializes a new instance with default settings. public HeidenhainCSyntax() HeidenhainCSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainCSyntax(XElement src) Parameters src XElement Source XML element. Fields DrKey Rotation-direction key on the Parsing root (\"+\" CCW / “-” CW). public const string DrKey = \"DR\" Field Value string StatementKey Statement-marker key on the Parsing root. Not the bare “C” — that key is the rotary C axis word consumed by the shared McAbcSyntax. public const string StatementKey = \"CArc\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainCallSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainCallSyntax.html",
    "title": "Class HeidenhainCallSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainCallSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Assembly HiMech.dll Syntax for Heidenhain CALL commands (CALL PGM and CALL LBL). public class HeidenhainCallSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainCallSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild.UnparsedText: CALL PGM SubProg #AfterBuild: { \"Parsing\": { \"CALL\": { \"Target\": \"PGM\", \"Name\": \"SubProg\" } } } #BeforeBuild.UnparsedText: CALL LBL 5 #AfterBuild: { \"Parsing\": { \"CALL\": { \"Target\": \"LBL\", \"Name\": \"5\" } } } #BeforeBuild.UnparsedText: CALL LBL MyLabel REP 3 #AfterBuild: { \"Parsing\": { \"CALL\": { \"Target\": \"LBL\", \"Name\": \"MyLabel\", \"REP\": \"3\" } } } #BeforeBuild.UnparsedText: CALL LBL “SLOW_FEED” (quotes are stripped from the captured name) #AfterBuild: { \"Parsing\": { \"CALL\": { \"Target\": \"LBL\", \"Name\": \"SLOW_FEED\" } } } #BeforeBuild.UnparsedText: L1,0 (the DIN/ISO call-once spelling — REP 0 is spelled by omission, keeping the evaluation's positive-literal REP rail authoritative) #AfterBuild: { \"Parsing\": { \"CALL\": { \"Target\": \"LBL\", \"Name\": \"1\" } } } #BeforeBuild.UnparsedText: L2,4 (the DIN/ISO program-section repeat — the count after the comma is the klartext REP) #AfterBuild: { \"Parsing\": { \"CALL\": { \"Target\": \"LBL\", \"Name\": \"2\", \"REP\": \"4\" } } } Constructors HeidenhainCallSyntax() Initializes a new instance with default settings. public HeidenhainCallSyntax() HeidenhainCallSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainCallSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainCcSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainCcSyntax.html",
    "title": "Class HeidenhainCcSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainCcSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Assembly HiMech.dll Heidenhain circle-center statement (CC X+12.7 Y+12.7). The coordinates land in the nested Parsing.CC record — deliberately not on the Parsing root, where ProgramXyzSyntax would mistake the center for a motion endpoint. The Logic-stage HeidenhainCircleCenterSyntax turns the record into the modal circle-center section consumed by the arc syntax. Must run before HeidenhainCSyntax in the bundle (the \\b guard keeps a C statement from matching CC and vice versa, but CC-first is the safe order). An incremental center (CC IX+0 IY+11) is a distance from the last programmed tool position, not from the previous center: the words land in the same nested record with the block-root PositioningOverride stamp (see HeidenhainIncrementalAxisWordUtil), and the Heidenhain IncrementalResolveSyntax instance walks the CC record so the center is absolute by the time the circle-center syntax freezes it. public class HeidenhainCcSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainCcSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild.UnparsedText: CC X+12.7 Y+12.7 #AfterBuild: { \"Parsing\": { \"CC\": { \"X\": 12.7, \"Y\": 12.7 } } } Incremental center — same record, plus the per-axis stamp; the block is not bare (it stated coordinates, they are just relative): #BeforeBuild.UnparsedText: CC IX+0 IY+11 #AfterBuild: { \"Parsing\": { \"CC\": { \"X\": 0, \"Y\": 11 } }, \"PositioningOverride\": { \"X\": \"Incremental\", \"Y\": \"Incremental\" } } Constructors HeidenhainCcSyntax() Initializes a new instance with default settings. public HeidenhainCcSyntax() HeidenhainCcSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainCcSyntax(XElement src) Parameters src XElement Source XML element. Fields BareKey Marker key written into the record when the CC block states no coordinates at all AND left nothing unread — the official klartext spelling for “use the last programmed position as the circle center”. Consumed by HeidenhainCircleCenterSyntax, which resolves the position at THIS block. The residue condition is load-bearing: a CC whose coordinates this parser cannot read (a malformed word, a spelling no grab here knows) also grabs nothing, and marking it bare would fabricate a center at the current position instead of leaving the arc to report that it has none. The incremental CC IX+.. IY+.. used to be that case; it is a stated center now. public const string BareKey = \"Bare\" Field Value string CenterTags The axis words a centre can state (the incremental grab is limited to these). public static readonly string[] CenterTags Field Value string[] KeyConst Key of the nested center record on Parsing. public const string KeyConst = \"CC\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainCyclCallSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainCyclCallSyntax.html",
    "title": "Class HeidenhainCyclCallSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainCyclCallSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Assembly HiMech.dll Captures the klartext cycle-call statement into a Parsing[“CYCL CALL”] record: CYCL CALL — { Bare: true }; any trailing M words stay in the text for the shared flag captures. CYCL CALL POS X±n Y±n Z±n … — { Pos: true } plus the axis words grabbed into the record (never onto the Parsing root: the POS coordinates are the call position — the X/Y feed the ISO cycle section, while the pre-position Z must not be mistaken for the hole-bottom Z slot). FMAX/F/M140 words stay in the text for their own captures. A klartext I-prefixed word (CYCL CALL POS IX+20 — the general \"I before an axis word\" rule; the manual prints no example) lands under the plain key like an L endpoint and stamps the block-root PositioningOverride through HeidenhainIncrementalAxisWordUtil; the cycle syntax resolves it on the spot, ahead of the shared resolve. The call is consumed by HeidenhainCannedCycleSyntax, which converts the stored cycle definition into a direct ISO cycle sub-section on this block. public class HeidenhainCyclCallSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainCyclCallSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Bare call — trailing M words stay for the shared flag capture: #BeforeBuild.UnparsedText: CYCL CALL M13 #AfterBuild: { \"UnparsedText\": \"M13\", \"Parsing\": { \"CYCL CALL\": { \"Bare\": true } } } Positional call — axis words land inside the record; FMAX stays: #BeforeBuild.UnparsedText: CYCL CALL POS X-14 Y+25 Z+0 FMAX #AfterBuild: { \"UnparsedText\": \"FMAX\", \"Parsing\": { \"CYCL CALL\": { \"Pos\": true, \"X\": -14, \"Y\": 25, \"Z\": 0 } } } Positional call with klartext incremental words — the values land under the plain keys (after the absolute words, in grab order) and the per-word stamp lands on the block root: #BeforeBuild.UnparsedText: CYCL CALL POS IX+20 Y+25 IZ-5 FMAX #AfterBuild: { \"UnparsedText\": \"FMAX\", \"Parsing\": { \"CYCL CALL\": { \"Pos\": true, \"Y\": 25, \"X\": 20, \"Z\": -5 } }, \"PositioningOverride\": { \"X\": \"Incremental\", \"Z\": \"Incremental\" } } Constructors HeidenhainCyclCallSyntax() Initializes a new instance with default settings. public HeidenhainCyclCallSyntax() HeidenhainCyclCallSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainCyclCallSyntax(XElement src) Parameters src XElement Source XML element. Fields BareKey Record key marking the bare (positionless) call form. public const string BareKey = \"Bare\" Field Value string CyclCallKey JSON key of the call record under Parsing. public const string CyclCallKey = \"CYCL CALL\" Field Value string PatKey Record key marking the CYCL CALL PAT (pattern) form. public const string PatKey = \"Pat\" Field Value string PosKey Record key marking the CYCL CALL POS form. public const string PosKey = \"Pos\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainCyclDefSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainCyclDefSyntax.html",
    "title": "Class HeidenhainCyclDefSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainCyclDefSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Assembly HiMech.dll Initialization Syntax of Heidenhain fixed head block for CYCL DEF . public class HeidenhainCyclDefSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainCyclDefSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainCyclDefSyntax() Initializes a new instance with default settings. public HeidenhainCyclDefSyntax() HeidenhainCyclDefSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainCyclDefSyntax(XElement src) Parameters src XElement Source XML element. Fields CyclDefConst JSON key under Parsing that holds the parsed cycle number (e.g. 247 for CYCL DEF 247). public const string CyclDefConst = \"CYCL DEF\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainFnAssignmentSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainFnAssignmentSyntax.html",
    "title": "Class HeidenhainFnAssignmentSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainFnAssignmentSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Assembly HiMech.dll Heidenhain FN variable assignment syntax. Extends TagAssignmentSyntax with FN opcode prefix. public class HeidenhainFnAssignmentSyntax : TagAssignmentSyntax, ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object TagAssignmentSyntax HeidenhainFnAssignmentSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members TagAssignmentSyntax.AssignmentsKey TagAssignmentSyntax.DefaultCategoryPath TagAssignmentSyntax.MakeXmlSource(string, string, bool) TagAssignmentSyntax.CategoryPath TagAssignmentSyntax.TagList TagAssignmentSyntax.VarPrefix TagAssignmentSyntax.TerminateWords TagAssignmentSyntax.RhsDialect TagAssignmentSyntax.Name TagAssignmentSyntax.ToAssignmentJsonNode(string) TagAssignmentSyntax.Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks FN 0: Q5 = +60 (assignment) FN 1: Q1 = -Q2 + -5 (addition) FN 2: Q1 = Q2 - Q3 (subtraction) FN 3: Q1 = Q2 * Q3 (multiplication) FN 4: Q1 = Q2 / Q3 (division) Constructors HeidenhainFnAssignmentSyntax() Initializes a new instance with default settings. The RHS is parser-delimited by the Heidenhain expression grammar (P2) so spaced arithmetic (FN 2: Q1 = Q1 - 1) and the FN 4/5 spellings (DIV, prefix SQRT) capture as one expression; XML from the pre-P2 era rehydrates with None and keeps its legacy lexical boundary. public HeidenhainFnAssignmentSyntax() HeidenhainFnAssignmentSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainFnAssignmentSyntax(XElement src) Parameters src XElement Source XML element. Properties XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory TryStripPrefix(ref string) Strips a brand-specific prefix from unparsedText before assignment parsing. Returns false to signal no match (skip this syntax). Base implementation does nothing (no prefix required). protected override bool TryStripPrefix(ref string unparsedText) Parameters unparsedText string Returns bool"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainFnFeatureSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainFnFeatureSyntax.html",
    "title": "Class HeidenhainFnFeatureSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainFnFeatureSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Assembly HiMech.dll Structured skip for the Heidenhain FN opcodes the simulation does not implement (FN 14 error display, FN 16 print, FN 18 SYSREAD, table/pallet opcodes …): the whole statement is consumed and a single HeidenhainFn–Unsupported warning names the opcode. Two opcode families pass through untouched: FN 0-5 belong to HeidenhainFnAssignmentSyntax (which runs earlier), and the jump family FN 9-12 belongs to HeidenhainGotoParsingSyntax (also earlier) — the pass-through here is the malformed-jump safety net: a jump line the owner's grammar rejects surfaces as visible residue instead of a fabricated skip. Claiming the statement here is load-bearing, not cosmetic: an FN 18 line like FN18: SYSREAD Q94= ID50 NR11 contains a Q94= token that the bare Q-assignment capture (later in the Parsing bundle) would otherwise grab, storing the garbage string ID50 into Q94. The target parameter must instead stay vacant so dependent expressions fail soft (VariableExpression--Unevaluated) — no fabricated values. public class HeidenhainFnFeatureSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainFnFeatureSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild.UnparsedText: FN18: SYSREAD Q94= ID50 NR11 #AfterBuild: {} Constructors HeidenhainFnFeatureSyntax() Default constructor. public HeidenhainFnFeatureSyntax() HeidenhainFnFeatureSyntax(XElement) Loads from an XML element produced by MakeXmlSource(string, string, bool). No state to deserialise. public HeidenhainFnFeatureSyntax(XElement src) Parameters src XElement Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainGotoParsingSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainGotoParsingSyntax.html",
    "title": "Class HeidenhainGotoParsingSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainGotoParsingSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Assembly HiMech.dll Captures the Heidenhain FN 9–12 conditional jump statement whole into Parsing.HeidenhainGoto. All four opcodes share one phrase shape (FN n: IF <value> <comparator> <value> GOTO LBL <label>); both the spaced standard spelling and the compressed post spelling (FN12:IF+Q94 LT+1GOTOLBL\"SLOW_FEED\" — glued opcode head, glued value/target run, quoted name label) are recognised. Pre-normalisation happens here, per the P2 expression-grammar decision (the Heidenhain dialect deliberately has no comparison layer): the comparator spelling collapses to the shared comparison words (EQU→EQ), and the two operands are captured as separate values — a pure numeric literal is typed numeric at capture (the P0 GetParsedDouble-string-trap discipline), a Q reference stays a string for VariableEvaluatorSyntax's pass-2 substitution. The comparison and the label redirect happen in HeidenhainGotoSyntax. Placement: whole-statement owner right after HeidenhainCallSyntax — before HeidenhainLblSyntax (whose definition regex already excludes the GOTO LBL spellings, but the jump owner claiming the full line first keeps the exclusion a backstop rather than a load-bearing gate) and before HeidenhainFnFeatureSyntax (whose FN 9–12 pass-through remains the malformed-jump safety net: a line this regex rejects surfaces as visible residue, never a fabricated skip). public class HeidenhainGotoParsingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainGotoParsingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Spaced standard spelling — the literal operand is typed numeric at capture, the Q operand stays a string for the evaluator: #BeforeBuild.UnparsedText: FN 12: IF +Q1 LT +5 GOTO LBL 5 #AfterBuild: { \"Parsing\": { \"HeidenhainGoto\": { \"Term\": \"FN12\", \"Op\": \"LT\", \"Lhs\": \"+Q1\", \"Rhs\": 5, \"Label\": \"5\" } } } Compressed post spelling (TongTai turbine form) — glued opcode head, glued value/target run, quoted name label (quotes stripped): #BeforeBuild.UnparsedText: FN12:IF+Q94 LT+1GOTOLBL\"SLOW_FEED\" #AfterBuild: { \"Parsing\": { \"HeidenhainGoto\": { \"Term\": \"FN12\", \"Op\": \"LT\", \"Lhs\": \"+Q94\", \"Rhs\": 1, \"Label\": \"SLOW_FEED\" } } } FN 9 — the klartext EQU spelling normalises to the shared EQ comparison word: #BeforeBuild.UnparsedText: FN 9: IF +Q1 EQU +Q3 GOTO LBL “END_MK” #AfterBuild: { \"Parsing\": { \"HeidenhainGoto\": { \"Term\": \"FN9\", \"Op\": \"EQ\", \"Lhs\": \"+Q1\", \"Rhs\": \"+Q3\", \"Label\": \"END_MK\" } } } FN 10 not-equal jump to a numeric label: #BeforeBuild.UnparsedText: FN 10: IF +Q5 NE +0 GOTO LBL 3 #AfterBuild: { \"Parsing\": { \"HeidenhainGoto\": { \"Term\": \"FN10\", \"Op\": \"NE\", \"Lhs\": \"+Q5\", \"Rhs\": 0, \"Label\": \"3\" } } } FN 11 greater-than jump: #BeforeBuild.UnparsedText: FN 11: IF +Q2 GT +400 GOTO LBL 99 #AfterBuild: { \"Parsing\": { \"HeidenhainGoto\": { \"Term\": \"FN11\", \"Op\": \"GT\", \"Lhs\": \"+Q2\", \"Rhs\": 400, \"Label\": \"99\" } } } Constructors HeidenhainGotoParsingSyntax() Parameterless instance (no XML state). public HeidenhainGotoParsingSyntax() HeidenhainGotoParsingSyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public HeidenhainGotoParsingSyntax(XElement src) Parameters src XElement Root element named XName. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainIncrementalAxisWordUtil.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainIncrementalAxisWordUtil.html",
    "title": "Class HeidenhainIncrementalAxisWordUtil | HiAPI-C# 2025",
    "summary": "Class HeidenhainIncrementalAxisWordUtil Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Assembly HiMech.dll The klartext I-prefixed incremental axis word — IX+20, IY-15, IZ+Q1, rotary IC+90: the same axis word as the absolute X+20, read as a distance from the last programmed position instead of a coordinate. Any word of a block may be incremental on its own (L X+60 IY-10 mixes both), which is exactly the per-word shape the shared PositioningOverride section models for the Siemens IC() wrapper. So the grab here writes the value under the plain axis key of the caller's section (Parsing.X for an L/C endpoint, Parsing.CC.X for a circle center, Parsing[“CYCL CALL”].X for a cycle-call position) and stamps “PositioningOverride”: { “X”: “Incremental” } on the block root; the conversion to absolute stays with the existing consumers — IncrementalResolveSyntax for linear axes (the Heidenhain instance also walks the CC record), McAbcSyntax for rotary axes, and HeidenhainCannedCycleSyntax on the spot for the words it consumes ahead of the resolve — and no second incremental mechanism exists. The one klartext I word that is NOT a distance from the tool position, the CYCL DEF 7 datum shift, deliberately does not use this helper (see HeidenhainDatumShiftSyntax). The plain axis grab (NcSyntaxUtil.GrabTagValue) cannot see the X inside IX: RegexFlagPrefix demands a word boundary, a digit or whitespace before the tag, and I is a word character. That guard is what keeps the plain grab from half-reading an incremental block (L X+60 IY-10 used to take X and drop the Y — a motion to the wrong place, not a missing one), so the incremental words are grabbed by their own two-letter tags (IX, IY, …) instead of relaxing the guard. The value grammar is the shared one (signed number, Q variable, bracket expression), and a glued run (LIX+20IY-15) parses like the absolute glued shape because the digit alternative of the prefix guard admits the second word. public static class HeidenhainIncrementalAxisWordUtil Inheritance object HeidenhainIncrementalAxisWordUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields Prefix The klartext incremental prefix letter. public const string Prefix = \"I\" Field Value string Methods GrabIncrementalAxisWords(JsonObject, JsonObject, IEnumerable<string>, ref string, IEnumerable<string>) Grabs every I-prefixed incremental word of axisTags from unparsedText, writes each value under its plain axis key of the object at sectionPath below parsing (parsed via ToFloat(string), like the absolute words) and stamps an Incremental entry per axis into the block-root PositioningOverride section of block. No words → nothing is written (no empty override section appears). public static void GrabIncrementalAxisWords(JsonObject block, JsonObject parsing, IEnumerable<string> sectionPath, ref string unparsedText, IEnumerable<string> axisTags) Parameters block JsonObject Block-root JSON object (owner of the override section). parsing JsonObject The block's Parsing object. sectionPath IEnumerable<string> Path below parsing that receives the axis values (empty = the Parsing root). unparsedText string Block text; the grabbed words are removed. axisTags IEnumerable<string> Plain axis tags to look for behind the prefix (the caller's own tag list)."
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainLSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainLSyntax.html",
    "title": "Class HeidenhainLSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainLSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Assembly HiMech.dll Heidenhain linear movement (the leading L) syntax. Strips the leading L — spaced (L X+10) or glued directly to an axis/F word (LX+153.933Y+4.196A-77.516, the dominant shape of post-processed turbine files) — writes the Parsing.L = true statement marker, and grabs axis-tag values for any of AxisTagList (X, Y, Z, U, V, W, A, B, C) that appear afterwards as {axis}{signed-value} pairs; values are parsed as floats via ToFloat(string). LN/LP/LBL lines are excluded by the gate's lookahead: a glued axis letter only counts when followed by a sign, digit, dot or Q variable, so the B of LBL (followed by another L) never matches. Glued M words (LM09) are accepted — stripping the L exposes the M word for the numbered-flag syntax; the richer LM140/LM128 statements never reach this gate because their dedicated owners run earlier in the Heidenhain Parsing bundle. Axis words land on the root of Parsing (not nested under L) so the shared Logic consumers — ProgramXyzSyntax, McAbcSyntax, MachineCoordSelectSyntax, IncrementalResolveSyntax — read them without per-brand path configuration. The L marker is consumed by HeidenhainMotionModeSyntax which maps the statement (plus a one-shot FMAX flag) onto the shared G00/G01 motion-mode vocabulary. The radius-compensation words RL/RR/R0 are captured as boolean records on the Parsing root; the Logic-stage HeidenhainRadiusCompSyntax maps them onto the shared G41/G42/G40 vocabulary consumed by the radius compensation pass. Incremental axis words (L IX+20 IY-15, mixed with absolute ones at will) land under the same plain axis keys, with a per-axis \"PositioningOverride\": { \"X\": \"Incremental\" } stamp on the block root for the shared resolve consumers — see HeidenhainIncrementalAxisWordUtil. The glued gate admits the prefixed spelling too (LIX+20). public class HeidenhainLSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainLSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild.UnparsedText: L X+10 Y+20 Z-5 #AfterBuild: { \"Parsing\": { \"L\": true, \"X\": 10, \"Y\": 20, \"Z\": -5 } } #BeforeBuild.UnparsedText: L A+45 B-15 #AfterBuild: { \"Parsing\": { \"L\": true, \"A\": 45, \"B\": -15 } } #BeforeBuild.UnparsedText: LX+153.933Y+4.196Z+387.616A-77.516C-10.365 #AfterBuild: { \"Parsing\": { \"L\": true, \"X\": 153.933, \"Y\": 4.196, \"Z\": 387.616, \"A\": -77.516, \"C\": -10.365 } } #BeforeBuild.UnparsedText: LZ+387.616R0FMAX #AfterBuild: { \"UnparsedText\": \"FMAX\", \"Parsing\": { \"L\": true, \"Z\": 387.616, \"R0\": true } } Incremental words (the manual's own example shape): the values land under the plain axis keys and every incremental axis is stamped on the block-root override section; nothing is left unread: #BeforeBuild.UnparsedText: L IX+20 IY-15 #AfterBuild: { \"Parsing\": { \"L\": true, \"X\": 20, \"Y\": -15 }, \"PositioningOverride\": { \"X\": \"Incremental\", \"Y\": \"Incremental\" } } Mixed block — only the incremental axis carries the stamp; the absolute X follows the modal positioning as before: #BeforeBuild.UnparsedText: L X+60 IY-10 #AfterBuild: { \"Parsing\": { \"L\": true, \"X\": 60, \"Y\": -10 }, \"PositioningOverride\": { \"Y\": \"Incremental\" } } Glued incremental run — the gate admits the prefixed axis letter and the second word is reached through the digit before it: #BeforeBuild.UnparsedText: LIX+20IY-15 #AfterBuild: { \"Parsing\": { \"L\": true, \"X\": 20, \"Y\": -15 }, \"PositioningOverride\": { \"X\": \"Incremental\", \"Y\": \"Incremental\" } } Constructors HeidenhainLSyntax() Initializes a new instance with default settings. public HeidenhainLSyntax() HeidenhainLSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainLSyntax(XElement src) Parameters src XElement Source XML element. Fields CompWords Radius-compensation words captured as boolean Parsing-root records. public static readonly string[] CompWords Field Value string[] StatementKey Key of the statement marker written to the root of Parsing (“L”: true); consumed by HeidenhainMotionModeSyntax. public const string StatementKey = \"L\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string TagList Axis tags grabbed as float-valued coordinates after the leading L. public List<string> TagList { get; set; } Property Value List<string> XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainLblSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainLblSyntax.html",
    "title": "Class HeidenhainLblSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainLblSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Assembly HiMech.dll Syntax for Heidenhain LBL command (label definition). Label can be a number (1-65535) or a text name (e.g., “MyLabel”). LBL 0 is reserved for end of subprogram. Only a DEFINITION is captured: CALL LBL (any spacing) and the FN 9–12 jump spellings (GOTO LBL n, glued GOTOLBL) are excluded — this syntax doubles as the label-scan probe of the P4 call machinery, where mistaking a jump line (or the call line itself) for a definition splices the wrong program section. public class HeidenhainLblSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainLblSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild.UnparsedText: LBL 1 #AfterBuild: { \"Parsing\": { \"LBL\": { \"Name\": \"1\" } } } #BeforeBuild.UnparsedText: LBL MyLabel #AfterBuild: { \"Parsing\": { \"LBL\": { \"Name\": \"MyLabel\" } } } #BeforeBuild.UnparsedText: LBL 0 (LBL 0 is the end-of-subprogram sentinel) #AfterBuild: { \"Parsing\": { \"LBL\": { \"Name\": \"0\" } } } #BeforeBuild.UnparsedText: LBL “SLOW_FEED” (quotes are stripped from the captured name) #AfterBuild: { \"Parsing\": { \"LBL\": { \"Name\": \"SLOW_FEED\" } } } #BeforeBuild.UnparsedText: FN 12: IF +Q1 LT +5 GOTO LBL 5 (a jump target, not a definition — the line is left whole for the FN jump family) #AfterBuild: { \"UnparsedText\": \"FN 12: IF +Q1 LT +5 GOTO LBL 5\" } #BeforeBuild.UnparsedText: G98 L1 (the DIN/ISO definition twin — the G98/L pair is claimed together, so no G98 flag leaks to the numbered-flag capture) #AfterBuild: { \"Parsing\": { \"LBL\": { \"Name\": \"1\" } } } Constructors HeidenhainLblSyntax() Initializes a new instance with default settings. public HeidenhainLblSyntax() HeidenhainLblSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainLblSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainLnSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainLnSyntax.html",
    "title": "Class HeidenhainLnSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainLnSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Assembly HiMech.dll Heidenhain LN (surface-normal block) syntax — the CAM-generated straight line carrying the endpoint plus up to two normalized vectors, in the manual's fixed element order X,Y,Z → NX,NY,NZ → TX,TY,TZ: the surface-normal vector NX/NY/NZ (the 3D tool-compensation direction) and the optional tool vector TX/TY/TZ (the tool-axis orientation, acted on only under M128 / FUNCTION TCPM). Strips the leading LN — spaced or glued straight onto an axis or vector word — writes the shared StatementKey statement marker (an LN block is a feed-rate linear move, so the shared motion-mode mapping serves it unchanged), sweeps the six vector components into the nested Parsing.LN record, and grabs endpoint axis words and RL/RR/R0 onto the Parsing root exactly like HeidenhainLSyntax. The Parsing.LN record — created even when the block carries no vector words, so the LN identity always reaches the Logic stage — is consumed by HeidenhainLnOrientationSyntax, which applies the manual's posture rules and writes the brand-agnostic ToolOrientation/SurfaceNormal sections. Vector words are grabbed before the root axis words as ordering hygiene; correctness does not depend on it — RegexFlagPrefix rejects a tag preceded by a letter, so a bare X can never claim the X of NX. Runs ahead of HeidenhainLSyntax in the bundle; the L gate's lookahead already excludes LN, so this is ordering hygiene as well, not a claim race. Incremental endpoint words (LN IX+20 IY-15 …, mixed with absolute ones at will) land under the same plain axis keys with the per-axis \"PositioningOverride\": { \"Y\": \"Incremental\" } stamp on the block root, exactly like HeidenhainLSyntax — see HeidenhainIncrementalAxisWordUtil. The manual states the I prefix as a general rule for programmed positions and gives the LN endpoint no exception (its syntax table says only \"coordinates of the straight-line end point\"), so the endpoint follows that rule; the vector words have no incremental form. The glued gate admits the prefixed spelling too (LNIX+20). public class HeidenhainLnSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainLnSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Full CAM shape — endpoint, surface normal, tool vector, R0: #BeforeBuild.UnparsedText: LN X+31.737 Y+21.954 Z+33.165 NX+0.2637581 NY+0.0908784 NZ-0.960348 TX+0 TY+0.6558846 TZ+0.7548612 R0 #AfterBuild: { \"Parsing\": { \"L\": true, \"LN\": { \"NX\": 0.2637581, \"NY\": 0.0908784, \"NZ\": -0.960348, \"TX\": 0, \"TY\": 0.6558846, \"TZ\": 0.7548612 }, \"X\": 31.737, \"Y\": 21.954, \"Z\": 33.165, \"R0\": true } } Glued post shape, tool vector only (“LN with T, no N” is legal — peripheral milling); the FMAX residue stays for the flag syntax: #BeforeBuild.UnparsedText: LNX+10Y+20Z+5TX+0TY+0TZ+1R0FMAX #AfterBuild: { \"UnparsedText\": \"FMAX\", \"Parsing\": { \"L\": true, \"LN\": { \"TX\": 0, \"TY\": 0, \"TZ\": 1 }, \"X\": 10, \"Y\": 20, \"Z\": 5, \"R0\": true } } Surface normal only (posture falls to N under TCPM); the F word stays for the shared feed capture: #BeforeBuild.UnparsedText: LN X+0 Y+0 Z+0 NX+0 NY+0 NZ+1 F1000 #AfterBuild: { \"UnparsedText\": \"F1000\", \"Parsing\": { \"L\": true, \"LN\": { \"NX\": 0, \"NY\": 0, \"NZ\": 1 }, \"X\": 0, \"Y\": 0, \"Z\": 0 } } No vector words — the empty record still marks the block as LN for the Logic consumer: #BeforeBuild.UnparsedText: LN X+10 Y+20 Z+5 R0 #AfterBuild: { \"Parsing\": { \"L\": true, \"LN\": {}, \"X\": 10, \"Y\": 20, \"Z\": 5, \"R0\": true } } Incremental endpoint words — the manual's general I-prefix rule on the LN endpoint: the values land under the plain axis keys, the block-root override stamps only the incremental axes, and the vector record is untouched: #BeforeBuild.UnparsedText: LN X+31.737 IY+21.954 IZ-5 NX+0.2637581 NY+0.0908784 NZ-0.960348 R0 #AfterBuild: { \"Parsing\": { \"L\": true, \"LN\": { \"NX\": 0.2637581, \"NY\": 0.0908784, \"NZ\": -0.960348 }, \"X\": 31.737, \"Y\": 21.954, \"Z\": -5, \"R0\": true }, \"PositioningOverride\": { \"Y\": \"Incremental\", \"Z\": \"Incremental\" } } Constructors HeidenhainLnSyntax() Initializes a new instance with default settings. public HeidenhainLnSyntax() HeidenhainLnSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainLnSyntax(XElement src) Parameters src XElement Source XML element. Fields KeyConst Key of the nested vector record written under Parsing; consumed by HeidenhainLnOrientationSyntax. public const string KeyConst = \"LN\" Field Value string NormalTags Surface-normal component tags (the 3D-compensation direction). public static readonly string[] NormalTags Field Value string[] ToolVectorTags Tool-vector component tags (the tool-axis orientation). public static readonly string[] ToolVectorTags Field Value string[] Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainM128Syntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainM128Syntax.html",
    "title": "Class HeidenhainM128Syntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainM128Syntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Assembly HiMech.dll Captures the klartext M128 word (RTCP on) together with its optional feed-limit argument (M128 F6000.) into Parsing.M128 { F? }. Must run before the shared F tag-value syntax — the F belongs to M128 (feed limit for compensating movements), and letting it reach the Parsing root would pollute the modal feedrate (HardNc has exactly this defect). Accepted spellings: the leading/glued L statement (LM128, mirroring the M140 sibling), the fully glued M128F6000, and a Q-parameter feed limit (M128 FQ8, 1.H corpus) captured as the string token for the evaluator pass to resolve. M129 (RTCP off) carries no argument and stays on the shared numbered-flag path. public class HeidenhainM128Syntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainM128Syntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Bare form — the Bare marker keeps the record from being swept by intermediate CleanupParsing passes (empty objects are pruned; Siemens frame-statement precedent): #BeforeBuild.UnparsedText: M128 #AfterBuild: { \"Parsing\": { \"M128\": { \"Bare\": true } } } With feed-limit argument (trailing-dot corpus form): #BeforeBuild.UnparsedText: M128 F6000. #AfterBuild: { \"Parsing\": { \"M128\": { \"F\": 6000 } } } Glued L statement + fully glued feed limit: #BeforeBuild.UnparsedText: LM128F6000 #AfterBuild: { \"Parsing\": { \"M128\": { \"F\": 6000 } } } Q-parameter feed limit (kept as the raw token; the evaluator pass substitutes it when the Q value is known): #BeforeBuild.UnparsedText: M128 FQ8 #AfterBuild: { \"Parsing\": { \"M128\": { \"F\": \"Q8\" } } } Constructors HeidenhainM128Syntax() Initializes a new instance with default settings. public HeidenhainM128Syntax() HeidenhainM128Syntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainM128Syntax(XElement src) Parameters src XElement Source XML element. Fields KeyConst Key of the record written to Parsing. public const string KeyConst = \"M128\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainM140Syntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainM140Syntax.html",
    "title": "Class HeidenhainM140Syntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainM140Syntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Assembly HiMech.dll Captures the klartext M140 MB tool-axis retract statement into Parsing.M140 { MB, F? }. MB MAX retracts to the traverse limit (recorded as the string “MAX”); MB+n retracts by n mm along the tool axis. Handles the corpus forms M140 MB+50 F6000, L M140 MB MAX (M word carried on an L statement) and the glued LM140 MB MAX (TongTai post). Must run before HeidenhainLSyntax (it claims the whole retract statement including a leading L) and before the shared F tag-value syntax (the F is the retract feed). public class HeidenhainM140Syntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainM140Syntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Distance form with retract feed: #BeforeBuild.UnparsedText: M140 MB+50 F6000 #AfterBuild: { \"Parsing\": { \"M140\": { \"MB\": 50, \"F\": 6000 } } } Glued L + MAX form (retract to the traverse limit): #BeforeBuild.UnparsedText: LM140 MB MAX #AfterBuild: { \"Parsing\": { \"M140\": { \"MB\": \"MAX\" } } } Constructors HeidenhainM140Syntax() Initializes a new instance with default settings. public HeidenhainM140Syntax() HeidenhainM140Syntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainM140Syntax(XElement src) Parameters src XElement Source XML element. Fields KeyConst Key of the record written to Parsing. public const string KeyConst = \"M140\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainMirrorImageSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainMirrorImageSyntax.html",
    "title": "Class HeidenhainMirrorImageSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainMirrorImageSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Assembly HiMech.dll Heidenhain DIN/ISO G28 = MIRROR IMAGE (the CYCL DEF 8 twin; basic course 62192: G28 X flips the X sign about the current datum, G28 X Y flips both, bare G28 resets) — the exact opposite of the Fanuc reference-point return the shared G28Syntax would read it as. Claims the whole statement (code plus trailing axis words) ahead of the generic kit and records each statement under Parsing.MirrorImageKey for the Logic-stage HeidenhainMirrorTransformSyntax, which simulates the mirror as a ProgramToMcTransform entry. Axis words are the manual's bare letters; a glued numeric or Q-variable follower (G28 X0 Y0 — the Fanuc idiom a mislabeled .I file could carry — or G28 XQ1) is claimed too so the value can never fall through to the root tag captures as a ghost coordinate, and the statement is stamped ValuedKey so the Logic stage keeps it recognized-but-not-simulated (mirroring on the Fanuc-shaped form would wreck a mislabeled reference-return file). A bare axis letter glued to another word (G28 CC…) stops the claim run — the leftover surfaces through the residue sentinels instead of being guessed at. public class HeidenhainMirrorImageSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainMirrorImageSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Course 62192 single-axis form — statement claimed whole and recorded for the Logic-stage transform writer: #BeforeBuild.UnparsedText: G28 X #AfterBuild: { \"Parsing\": { \"MirrorImage\": [ { \"Axes\": [\"X\"] } ] } } Two-axis form: #BeforeBuild.UnparsedText: G28 X Y #AfterBuild: { \"Parsing\": { \"MirrorImage\": [ { \"Axes\": [\"X\", \"Y\"] } ] } } Bare reset form — an empty axis list: #BeforeBuild.UnparsedText: G28 #AfterBuild: { \"Parsing\": { \"MirrorImage\": [ { \"Axes\": [] } ] } } Other words on the block survive the surgical claim: #BeforeBuild.UnparsedText: G90 G28 X #AfterBuild: { \"UnparsedText\": \"G90\", \"Parsing\": { \"MirrorImage\": [ { \"Axes\": [\"X\"] } ] } } The Fanuc-shaped valued idiom — axis values are claimed with their words so no ghost coordinate reaches the root tag captures, and the statement carries the Valued stamp that keeps the Logic stage from arming a mirror off it: #BeforeBuild.UnparsedText: G91 G28 X0 Y0 Z0 #AfterBuild: { \"UnparsedText\": \"G91\", \"Parsing\": { \"MirrorImage\": [ { \"Axes\": [\"X\", \"Y\", \"Z\"], \"Valued\": true } ] } } Digit follower keeps the gate shut (not a G28 word): #BeforeBuild.UnparsedText: G284 X #AfterBuild: { \"UnparsedText\": \"G284 X\" } A glued Q-variable follower is claimed with its word — unclaimed it would parse cleanly through the root tag captures (a silent ghost coordinate, invisible even to the residue sentinels): #BeforeBuild.UnparsedText: G91 G28 XQ1 #AfterBuild: { \"UnparsedText\": \"G91\", \"Parsing\": { \"MirrorImage\": [ { \"Axes\": [\"X\"], \"Valued\": true } ] } } Multiple G28 statements on one block are each claimed and recorded in source order (the Logic stage applies them sequentially — each statement replaces the mirror set): #BeforeBuild.UnparsedText: G28 X G28 Y #AfterBuild: { \"Parsing\": { \"MirrorImage\": [ { \"Axes\": [\"X\"] }, { \"Axes\": [\"Y\"] } ] } } Constructors HeidenhainMirrorImageSyntax() Initializes a new instance with default settings. public HeidenhainMirrorImageSyntax() HeidenhainMirrorImageSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainMirrorImageSyntax(XElement src) Parameters src XElement Source XML element. Fields AxesKey Per-statement key: the axis letters, in source order (empty = bare reset). public const string AxesKey = \"Axes\" Field Value string MirrorImageKey Key of the statement list this syntax records under Parsing: a JsonArray with one entry per claimed G28 statement, in source order. Consumed by HeidenhainMirrorTransformSyntax. public const string MirrorImageKey = \"MirrorImage\" Field Value string ValuedKey Per-statement key: present (true) when any axis word carried a glued value — the Fanuc-shaped idiom the Logic stage must not arm a mirror off. public const string ValuedKey = \"Valued\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainPlaneSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainPlaneSyntax.html",
    "title": "Class HeidenhainPlaneSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainPlaneSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Assembly HiMech.dll Syntax for the Heidenhain PLANE statement family. Fully structured (simulated by the Logic-stage tilt consumer): PLANE RESET [STAY|MOVE|TURN] PLANE SPATIAL SPA SPB SPC [SEQ±] [COORD ROT|TABLE ROT] [MOVE [DIST..] [F..]|TURN|STAY] Recognized (captured with the same option set, simulated as recognized-but-not-simulated by the Logic consumer): PLANE PROJECTED PROPR PROMIN ROT ... PLANE VECTOR BX BY BZ NX NY NZ ... (corpus: 1.H) PLANE EULER/POINTS/RELATIV/AXIAL ... — the mode word is captured and the unmodeled argument text is swept verbatim into the record's Args so no token can leak to the shared tag captures (e.g. a PLANE AXIAL B+45 B word must never become a rotary axis move). Must run before the shared F tag-value syntax: the F of MOVE DIST100 F8000 is the repositioning feed and would otherwise pollute the modal feedrate (house.H corpus form; HardNc has exactly this defect). public class HeidenhainPlaneSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainPlaneSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild.UnparsedText: PLANE SPATIAL SPA+30 SPB+0 SPC-10 SEQ+ COORD ROT TURN #AfterBuild: { \"Parsing\": { \"PLANE\": { \"Mode\": \"SPATIAL\", \"SPA\": 30, \"SPB\": 0, \"SPC\": -10, \"SEQ\": \"+\", \"Rot\": \"COORD\", \"Positioning\": \"TURN\" } } } #BeforeBuild.UnparsedText: PLANE PROJECTED PROPR+30 PROMIN+0 ROT+45 SEQ- TABLE ROT MOVE #AfterBuild: { \"Parsing\": { \"PLANE\": { \"Mode\": \"PROJECTED\", \"PROPR\": 30, \"PROMIN\": 0, \"ROT\": 45, \"SEQ\": \"-\", \"Rot\": \"TABLE\", \"Positioning\": \"MOVE\" } } } #BeforeBuild.UnparsedText: PLANE RESET STAY #AfterBuild: { \"Parsing\": { \"PLANE\": { \"Mode\": \"RESET\", \"Positioning\": \"STAY\" } } } The house.H MOVE form — DIST is glued to its value and the F is the repositioning feed (claimed here, kept out of the modal feedrate): #BeforeBuild.UnparsedText: PLANE SPATIAL SPA+0 SPB-45 SPC+0 MOVE DIST100 F8000 COORD ROT #AfterBuild: { \"Parsing\": { \"PLANE\": { \"Mode\": \"SPATIAL\", \"SPA\": 0, \"SPB\": -45, \"SPC\": 0, \"Rot\": \"COORD\", \"Positioning\": \"MOVE\", \"DIST\": 100, \"F\": 8000 } } } The TongTai turbine form — SEQ- glued to TABLE: #BeforeBuild.UnparsedText: PLANE SPATIAL SPA-77.516 SPB+0 SPC-10.365 STAY SEQ-TABLE ROT #AfterBuild: { \"Parsing\": { \"PLANE\": { \"Mode\": \"SPATIAL\", \"SPA\": -77.516, \"SPB\": 0, \"SPC\": -10.365, \"SEQ\": \"-\", \"Rot\": \"TABLE\", \"Positioning\": \"STAY\" } } } PLANE VECTOR (1.H corpus form) — base and normal vectors captured: #BeforeBuild.UnparsedText: PLANE VECTOR BX1 BY0 BZ0 NX0 NY0 NZ1 STAY SEQ+ TABLE ROT #AfterBuild: { \"Parsing\": { \"PLANE\": { \"Mode\": \"VECTOR\", \"BX\": 1, \"BY\": 0, \"BZ\": 0, \"NX\": 0, \"NY\": 0, \"NZ\": 1, \"SEQ\": \"+\", \"Rot\": \"TABLE\", \"Positioning\": \"STAY\" } } } Unmodeled mode — the argument text is swept into Args so no token leaks: #BeforeBuild.UnparsedText: PLANE AXIAL B+45 TURN #AfterBuild: { \"Parsing\": { \"PLANE\": { \"Mode\": \"AXIAL\", \"Positioning\": \"TURN\", \"Args\": \"B+45\" } } } Constructors HeidenhainPlaneSyntax() Initializes a new instance with default settings. public HeidenhainPlaneSyntax() HeidenhainPlaneSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainPlaneSyntax(XElement src) Parameters src XElement Source XML element. Fields ArgsKey Record key holding the swept argument text of unmodeled PLANE modes. public const string ArgsKey = \"Args\" Field Value string KeyConst Key of the record written to Parsing. public const string KeyConst = \"PLANE\" Field Value string ModeKey Record key for the mode word (SPATIAL/RESET/VECTOR/...). public const string ModeKey = \"Mode\" Field Value string PositioningKey Record key for the positioning word (“MOVE”/“TURN”/“STAY”). public const string PositioningKey = \"Positioning\" Field Value string ProjectedTagList Projected tags for PLANE PROJECTED command. PROPR: projection angle, PROMIN: minimum angle, ROT: rotation of tilted plane. public static readonly string[] ProjectedTagList Field Value string[] RotKey Record key for the rotation strategy (“COORD” or “TABLE”). public const string RotKey = \"Rot\" Field Value string SeqKey Record key for the SEQ solution preference (\"+\" or \"-\"). public const string SeqKey = \"SEQ\" Field Value string SpatialTagList Spatial axis tags for PLANE SPATIAL command. public static readonly string[] SpatialTagList Field Value string[] UnmodeledModeList PLANE modes captured as recognized-but-unmodeled: the mode word is recorded and the remaining argument text is swept into ArgsKey. public static readonly string[] UnmodeledModeList Field Value string[] VectorTagList Base-vector and normal-vector tags for PLANE VECTOR command. public static readonly string[] VectorTagList Field Value string[] Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainProgramSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainProgramSyntax.html",
    "title": "Class HeidenhainProgramSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainProgramSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Assembly HiMech.dll Syntax for Heidenhain BEGIN PGM and END PGM commands. public class HeidenhainProgramSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainProgramSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild.UnparsedText: BEGIN PGM DEMO MM #AfterBuild: { \"Parsing\": { \"PGM\": { \"Command\": \"BEGIN\", \"Name\": \"DEMO\", \"Unit\": \"MM\" } } } #BeforeBuild.UnparsedText: END PGM DEMO MM #AfterBuild: { \"Parsing\": { \"PGM\": { \"Command\": \"END\", \"Name\": \"DEMO\", \"Unit\": \"MM\" } } } Constructors HeidenhainProgramSyntax() Initializes a new instance with default settings. public HeidenhainProgramSyntax() HeidenhainProgramSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainProgramSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainTcpmSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainTcpmSyntax.html",
    "title": "Class HeidenhainTcpmSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainTcpmSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Assembly HiMech.dll Captures the modern-TNC RTCP statement pair into Parsing.TCPM: FUNCTION TCPM [args] (RTCP on — the M128 successor) and FUNCTION RESET TCPM (RTCP off). The behavior-tuning argument words (F TCP / F CONT / AXIS POS / AXIS SPAT / PATHCTRL AXIS / PATHCTRL VECTOR) are corpus-zero and swept verbatim into the record's Args — recognized-but-not-simulated (the Logic RTCP consumer warns); activation/deactivation itself is simulated. Must run before the shared F tag-value syntax so an argument like F TCP can never be misread as a feed word. public class HeidenhainTcpmSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainTcpmSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Bare activation: #BeforeBuild.UnparsedText: FUNCTION TCPM #AfterBuild: { \"Parsing\": { \"TCPM\": { \"Bare\": true } } } Activation with behavior arguments (recorded, not simulated): #BeforeBuild.UnparsedText: FUNCTION TCPM F TCP AXIS POS PATHCTRL AXIS #AfterBuild: { \"Parsing\": { \"TCPM\": { \"Args\": \"F TCP AXIS POS PATHCTRL AXIS\" } } } Deactivation: #BeforeBuild.UnparsedText: FUNCTION RESET TCPM #AfterBuild: { \"Parsing\": { \"TCPM\": { \"Reset\": true } } } Constructors HeidenhainTcpmSyntax() Initializes a new instance with default settings. public HeidenhainTcpmSyntax() HeidenhainTcpmSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainTcpmSyntax(XElement src) Parameters src XElement Source XML element. Fields ArgsKey Record key holding the swept behavior-argument text. public const string ArgsKey = \"Args\" Field Value string KeyConst Key of the record written to Parsing. public const string KeyConst = \"TCPM\" Field Value string ResetKey Record key marking the FUNCTION RESET TCPM (off) form. public const string ResetKey = \"Reset\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainTildeTrimSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainTildeTrimSyntax.html",
    "title": "Class HeidenhainTildeTrimSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainTildeTrimSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Assembly HiMech.dll Strips the TNC ~ line-continuation markers from a grouped sentence's UnparsedText. The raw BlockText keeps them (write-back authority); parsing only needs the joined lines. Both corpus spellings are removed — \"… ;STRATEGIE ~\" (space before, line tail) and \"DATUM SETTING~\" (glued). Placed at the head of the Parsing bundle, before the comment strippers, so a trailing ~ after a ; comment never lands in the recorded comment text. public class HeidenhainTildeTrimSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainTildeTrimSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild.UnparsedText: CYCL DEF 247 DATUM SETTING~ #AfterBuild: { \"UnparsedText\": \"CYCL DEF 247 DATUM SETTING\" } Constructors HeidenhainTildeTrimSyntax() Initializes a new instance with default settings. public HeidenhainTildeTrimSyntax() HeidenhainTildeTrimSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainTildeTrimSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainToolCallSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.HeidenhainToolCallSyntax.html",
    "title": "Class HeidenhainToolCallSyntax | HiAPI-C# 2025",
    "summary": "Class HeidenhainToolCallSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Assembly HiMech.dll Syntax for Heidenhain TOOL CALL command. Handles: TOOL CALL [ToolId|“ToolName”] [X|Y|Z] [S…] [DL…] [DR…] public class HeidenhainToolCallSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object HeidenhainToolCallSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild.UnparsedText: TOOL CALL 1 Z S5000 #AfterBuild: { \"Parsing\": { \"TOOL CALL\": { \"Axis\": \"Z\", \"S\": \"5000\", \"T\": \"1\" } } } #BeforeBuild.UnparsedText: TOOL CALL “MyTool” Z S3000 DL+0.5 DR-0.1 #AfterBuild: { \"Parsing\": { \"TOOL CALL\": { \"Axis\": \"Z\", \"S\": \"3000\", \"DL\": \"+0.5\", \"DR\": \"-0.1\", \"T\": \"MyTool\" } } } Constructors HeidenhainToolCallSyntax() Initializes a new instance with default settings. public HeidenhainToolCallSyntax() HeidenhainToolCallSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public HeidenhainToolCallSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Heidenhain.html",
    "title": "Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.ParsingSyntaxs.Heidenhain Classes HeidenhainBlkFormSyntax Syntax for Heidenhain BLK FORM command (workpiece blank definition). HeidenhainCSyntax Heidenhain circular-motion statement (C X+5.361 Y+23.064 DR-). Mirrors HeidenhainLSyntax: endpoint axis words promote to the Parsing root (shared Logic consumers), a “CArc”: true statement marker (deliberately NOT the bare C key — that is a rotary axis word which McAbcSyntax owns and consumes on rotary machines) gates HeidenhainCircularMotionSyntax, the rotation direction lands in Parsing.DR (\"-\" = CW = G02, \"+\" = CCW = G03) and radius-compensation words are captured like on L statements. The word-boundary head guard rejects CC/CT/CR/CP statements, and a value follower rejects a leading rotary-axis word — a DIN/ISO block like C-90. (modal C-axis positioning, the same mixed-dialect list) is an axis coordinate for the root tag capture, never a klartext arc statement head (klartext always separates the C head from its X/Y/DR words, so a sign/digit/dot follower cannot be an arc statement). Incremental endpoint words (C IX+20 IY+0 DR-) are captured like on L statements — plain axis keys plus the block-root PositioningOverride stamp, see HeidenhainIncrementalAxisWordUtil. HeidenhainCallSyntax Syntax for Heidenhain CALL commands (CALL PGM and CALL LBL). HeidenhainCcSyntax Heidenhain circle-center statement (CC X+12.7 Y+12.7). The coordinates land in the nested Parsing.CC record — deliberately not on the Parsing root, where ProgramXyzSyntax would mistake the center for a motion endpoint. The Logic-stage HeidenhainCircleCenterSyntax turns the record into the modal circle-center section consumed by the arc syntax. Must run before HeidenhainCSyntax in the bundle (the \\b guard keeps a C statement from matching CC and vice versa, but CC-first is the safe order). An incremental center (CC IX+0 IY+11) is a distance from the last programmed tool position, not from the previous center: the words land in the same nested record with the block-root PositioningOverride stamp (see HeidenhainIncrementalAxisWordUtil), and the Heidenhain IncrementalResolveSyntax instance walks the CC record so the center is absolute by the time the circle-center syntax freezes it. HeidenhainCyclCallSyntax Captures the klartext cycle-call statement into a Parsing[“CYCL CALL”] record: CYCL CALL — { Bare: true }; any trailing M words stay in the text for the shared flag captures. CYCL CALL POS X±n Y±n Z±n … — { Pos: true } plus the axis words grabbed into the record (never onto the Parsing root: the POS coordinates are the call position — the X/Y feed the ISO cycle section, while the pre-position Z must not be mistaken for the hole-bottom Z slot). FMAX/F/M140 words stay in the text for their own captures. A klartext I-prefixed word (CYCL CALL POS IX+20 — the general \"I before an axis word\" rule; the manual prints no example) lands under the plain key like an L endpoint and stamps the block-root PositioningOverride through HeidenhainIncrementalAxisWordUtil; the cycle syntax resolves it on the spot, ahead of the shared resolve. The call is consumed by HeidenhainCannedCycleSyntax, which converts the stored cycle definition into a direct ISO cycle sub-section on this block. HeidenhainCyclDefSyntax Initialization Syntax of Heidenhain fixed head block for CYCL DEF . HeidenhainFnAssignmentSyntax Heidenhain FN variable assignment syntax. Extends TagAssignmentSyntax with FN opcode prefix. HeidenhainFnFeatureSyntax Structured skip for the Heidenhain FN opcodes the simulation does not implement (FN 14 error display, FN 16 print, FN 18 SYSREAD, table/pallet opcodes …): the whole statement is consumed and a single HeidenhainFn–Unsupported warning names the opcode. Two opcode families pass through untouched: FN 0-5 belong to HeidenhainFnAssignmentSyntax (which runs earlier), and the jump family FN 9-12 belongs to HeidenhainGotoParsingSyntax (also earlier) — the pass-through here is the malformed-jump safety net: a jump line the owner's grammar rejects surfaces as visible residue instead of a fabricated skip. Claiming the statement here is load-bearing, not cosmetic: an FN 18 line like FN18: SYSREAD Q94= ID50 NR11 contains a Q94= token that the bare Q-assignment capture (later in the Parsing bundle) would otherwise grab, storing the garbage string ID50 into Q94. The target parameter must instead stay vacant so dependent expressions fail soft (VariableExpression--Unevaluated) — no fabricated values. HeidenhainGotoParsingSyntax Captures the Heidenhain FN 9–12 conditional jump statement whole into Parsing.HeidenhainGoto. All four opcodes share one phrase shape (FN n: IF <value> <comparator> <value> GOTO LBL <label>); both the spaced standard spelling and the compressed post spelling (FN12:IF+Q94 LT+1GOTOLBL\"SLOW_FEED\" — glued opcode head, glued value/target run, quoted name label) are recognised. Pre-normalisation happens here, per the P2 expression-grammar decision (the Heidenhain dialect deliberately has no comparison layer): the comparator spelling collapses to the shared comparison words (EQU→EQ), and the two operands are captured as separate values — a pure numeric literal is typed numeric at capture (the P0 GetParsedDouble-string-trap discipline), a Q reference stays a string for VariableEvaluatorSyntax's pass-2 substitution. The comparison and the label redirect happen in HeidenhainGotoSyntax. Placement: whole-statement owner right after HeidenhainCallSyntax — before HeidenhainLblSyntax (whose definition regex already excludes the GOTO LBL spellings, but the jump owner claiming the full line first keeps the exclusion a backstop rather than a load-bearing gate) and before HeidenhainFnFeatureSyntax (whose FN 9–12 pass-through remains the malformed-jump safety net: a line this regex rejects surfaces as visible residue, never a fabricated skip). HeidenhainIncrementalAxisWordUtil The klartext I-prefixed incremental axis word — IX+20, IY-15, IZ+Q1, rotary IC+90: the same axis word as the absolute X+20, read as a distance from the last programmed position instead of a coordinate. Any word of a block may be incremental on its own (L X+60 IY-10 mixes both), which is exactly the per-word shape the shared PositioningOverride section models for the Siemens IC() wrapper. So the grab here writes the value under the plain axis key of the caller's section (Parsing.X for an L/C endpoint, Parsing.CC.X for a circle center, Parsing[“CYCL CALL”].X for a cycle-call position) and stamps “PositioningOverride”: { “X”: “Incremental” } on the block root; the conversion to absolute stays with the existing consumers — IncrementalResolveSyntax for linear axes (the Heidenhain instance also walks the CC record), McAbcSyntax for rotary axes, and HeidenhainCannedCycleSyntax on the spot for the words it consumes ahead of the resolve — and no second incremental mechanism exists. The one klartext I word that is NOT a distance from the tool position, the CYCL DEF 7 datum shift, deliberately does not use this helper (see HeidenhainDatumShiftSyntax). The plain axis grab (NcSyntaxUtil.GrabTagValue) cannot see the X inside IX: RegexFlagPrefix demands a word boundary, a digit or whitespace before the tag, and I is a word character. That guard is what keeps the plain grab from half-reading an incremental block (L X+60 IY-10 used to take X and drop the Y — a motion to the wrong place, not a missing one), so the incremental words are grabbed by their own two-letter tags (IX, IY, …) instead of relaxing the guard. The value grammar is the shared one (signed number, Q variable, bracket expression), and a glued run (LIX+20IY-15) parses like the absolute glued shape because the digit alternative of the prefix guard admits the second word. HeidenhainLSyntax Heidenhain linear movement (the leading L) syntax. Strips the leading L — spaced (L X+10) or glued directly to an axis/F word (LX+153.933Y+4.196A-77.516, the dominant shape of post-processed turbine files) — writes the Parsing.L = true statement marker, and grabs axis-tag values for any of AxisTagList (X, Y, Z, U, V, W, A, B, C) that appear afterwards as {axis}{signed-value} pairs; values are parsed as floats via ToFloat(string). LN/LP/LBL lines are excluded by the gate's lookahead: a glued axis letter only counts when followed by a sign, digit, dot or Q variable, so the B of LBL (followed by another L) never matches. Glued M words (LM09) are accepted — stripping the L exposes the M word for the numbered-flag syntax; the richer LM140/LM128 statements never reach this gate because their dedicated owners run earlier in the Heidenhain Parsing bundle. Axis words land on the root of Parsing (not nested under L) so the shared Logic consumers — ProgramXyzSyntax, McAbcSyntax, MachineCoordSelectSyntax, IncrementalResolveSyntax — read them without per-brand path configuration. The L marker is consumed by HeidenhainMotionModeSyntax which maps the statement (plus a one-shot FMAX flag) onto the shared G00/G01 motion-mode vocabulary. The radius-compensation words RL/RR/R0 are captured as boolean records on the Parsing root; the Logic-stage HeidenhainRadiusCompSyntax maps them onto the shared G41/G42/G40 vocabulary consumed by the radius compensation pass. Incremental axis words (L IX+20 IY-15, mixed with absolute ones at will) land under the same plain axis keys, with a per-axis \"PositioningOverride\": { \"X\": \"Incremental\" } stamp on the block root for the shared resolve consumers — see HeidenhainIncrementalAxisWordUtil. The glued gate admits the prefixed spelling too (LIX+20). HeidenhainLblSyntax Syntax for Heidenhain LBL command (label definition). Label can be a number (1-65535) or a text name (e.g., “MyLabel”). LBL 0 is reserved for end of subprogram. Only a DEFINITION is captured: CALL LBL (any spacing) and the FN 9–12 jump spellings (GOTO LBL n, glued GOTOLBL) are excluded — this syntax doubles as the label-scan probe of the P4 call machinery, where mistaking a jump line (or the call line itself) for a definition splices the wrong program section. HeidenhainLnSyntax Heidenhain LN (surface-normal block) syntax — the CAM-generated straight line carrying the endpoint plus up to two normalized vectors, in the manual's fixed element order X,Y,Z → NX,NY,NZ → TX,TY,TZ: the surface-normal vector NX/NY/NZ (the 3D tool-compensation direction) and the optional tool vector TX/TY/TZ (the tool-axis orientation, acted on only under M128 / FUNCTION TCPM). Strips the leading LN — spaced or glued straight onto an axis or vector word — writes the shared StatementKey statement marker (an LN block is a feed-rate linear move, so the shared motion-mode mapping serves it unchanged), sweeps the six vector components into the nested Parsing.LN record, and grabs endpoint axis words and RL/RR/R0 onto the Parsing root exactly like HeidenhainLSyntax. The Parsing.LN record — created even when the block carries no vector words, so the LN identity always reaches the Logic stage — is consumed by HeidenhainLnOrientationSyntax, which applies the manual's posture rules and writes the brand-agnostic ToolOrientation/SurfaceNormal sections. Vector words are grabbed before the root axis words as ordering hygiene; correctness does not depend on it — RegexFlagPrefix rejects a tag preceded by a letter, so a bare X can never claim the X of NX. Runs ahead of HeidenhainLSyntax in the bundle; the L gate's lookahead already excludes LN, so this is ordering hygiene as well, not a claim race. Incremental endpoint words (LN IX+20 IY-15 …, mixed with absolute ones at will) land under the same plain axis keys with the per-axis \"PositioningOverride\": { \"Y\": \"Incremental\" } stamp on the block root, exactly like HeidenhainLSyntax — see HeidenhainIncrementalAxisWordUtil. The manual states the I prefix as a general rule for programmed positions and gives the LN endpoint no exception (its syntax table says only \"coordinates of the straight-line end point\"), so the endpoint follows that rule; the vector words have no incremental form. The glued gate admits the prefixed spelling too (LNIX+20). HeidenhainM128Syntax Captures the klartext M128 word (RTCP on) together with its optional feed-limit argument (M128 F6000.) into Parsing.M128 { F? }. Must run before the shared F tag-value syntax — the F belongs to M128 (feed limit for compensating movements), and letting it reach the Parsing root would pollute the modal feedrate (HardNc has exactly this defect). Accepted spellings: the leading/glued L statement (LM128, mirroring the M140 sibling), the fully glued M128F6000, and a Q-parameter feed limit (M128 FQ8, 1.H corpus) captured as the string token for the evaluator pass to resolve. M129 (RTCP off) carries no argument and stays on the shared numbered-flag path. HeidenhainM140Syntax Captures the klartext M140 MB tool-axis retract statement into Parsing.M140 { MB, F? }. MB MAX retracts to the traverse limit (recorded as the string “MAX”); MB+n retracts by n mm along the tool axis. Handles the corpus forms M140 MB+50 F6000, L M140 MB MAX (M word carried on an L statement) and the glued LM140 MB MAX (TongTai post). Must run before HeidenhainLSyntax (it claims the whole retract statement including a leading L) and before the shared F tag-value syntax (the F is the retract feed). HeidenhainMirrorImageSyntax Heidenhain DIN/ISO G28 = MIRROR IMAGE (the CYCL DEF 8 twin; basic course 62192: G28 X flips the X sign about the current datum, G28 X Y flips both, bare G28 resets) — the exact opposite of the Fanuc reference-point return the shared G28Syntax would read it as. Claims the whole statement (code plus trailing axis words) ahead of the generic kit and records each statement under Parsing.MirrorImageKey for the Logic-stage HeidenhainMirrorTransformSyntax, which simulates the mirror as a ProgramToMcTransform entry. Axis words are the manual's bare letters; a glued numeric or Q-variable follower (G28 X0 Y0 — the Fanuc idiom a mislabeled .I file could carry — or G28 XQ1) is claimed too so the value can never fall through to the root tag captures as a ghost coordinate, and the statement is stamped ValuedKey so the Logic stage keeps it recognized-but-not-simulated (mirroring on the Fanuc-shaped form would wreck a mislabeled reference-return file). A bare axis letter glued to another word (G28 CC…) stops the claim run — the leftover surfaces through the residue sentinels instead of being guessed at. HeidenhainPlaneSyntax Syntax for the Heidenhain PLANE statement family. Fully structured (simulated by the Logic-stage tilt consumer): PLANE RESET [STAY|MOVE|TURN] PLANE SPATIAL SPA SPB SPC [SEQ±] [COORD ROT|TABLE ROT] [MOVE [DIST..] [F..]|TURN|STAY] Recognized (captured with the same option set, simulated as recognized-but-not-simulated by the Logic consumer): PLANE PROJECTED PROPR PROMIN ROT ... PLANE VECTOR BX BY BZ NX NY NZ ... (corpus: 1.H) PLANE EULER/POINTS/RELATIV/AXIAL ... — the mode word is captured and the unmodeled argument text is swept verbatim into the record's Args so no token can leak to the shared tag captures (e.g. a PLANE AXIAL B+45 B word must never become a rotary axis move). Must run before the shared F tag-value syntax: the F of MOVE DIST100 F8000 is the repositioning feed and would otherwise pollute the modal feedrate (house.H corpus form; HardNc has exactly this defect). HeidenhainProgramSyntax Syntax for Heidenhain BEGIN PGM and END PGM commands. HeidenhainTcpmSyntax Captures the modern-TNC RTCP statement pair into Parsing.TCPM: FUNCTION TCPM [args] (RTCP on — the M128 successor) and FUNCTION RESET TCPM (RTCP off). The behavior-tuning argument words (F TCP / F CONT / AXIS POS / AXIS SPAT / PATHCTRL AXIS / PATHCTRL VECTOR) are corpus-zero and swept verbatim into the record's Args — recognized-but-not-simulated (the Logic RTCP consumer warns); activation/deactivation itself is simulated. Must run before the shared F tag-value syntax so an argument like F TCP can never be misread as a feed word. HeidenhainTildeTrimSyntax Strips the TNC ~ line-continuation markers from a grouped sentence's UnparsedText. The raw BlockText keeps them (write-back authority); parsing only needs the joined lines. Both corpus spellings are removed — \"… ;STRATEGIE ~\" (space before, line tail) and \"DATUM SETTING~\" (glued). Placed at the head of the Parsing bundle, before the comment strippers, so a trailing ~ after a ; comment never lands in the recorded comment text. HeidenhainToolCallSyntax Syntax for Heidenhain TOOL CALL command. Handles: TOOL CALL [ToolId|“ToolName”] [X|Y|Z] [S…] [DL…] [DR…]"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.IntegerTagValueSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.IntegerTagValueSyntax.html",
    "title": "Class IntegerTagValueSyntax | HiAPI-C# 2025",
    "summary": "Class IntegerTagValueSyntax Namespace Hi.NcParsers.ParsingSyntaxs Assembly HiMech.dll TagValueSyntax that parses numeric literal values to int. Variable text (e.g. Q2, #1, [#1+#2]) remains as string. public class IntegerTagValueSyntax : TagValueSyntax, ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object TagValueSyntax IntegerTagValueSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members TagValueSyntax.MakeXmlSource(string, string, bool) TagValueSyntax.VariableTag TagValueSyntax.CategoryPath TagValueSyntax.TagList TagValueSyntax.AllowEqualsForm TagValueSyntax.AllowSpacedValue TagValueSyntax.RhsDialect TagValueSyntax.Name TagValueSyntax.Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors IntegerTagValueSyntax(IEnumerable<string>, IEnumerable<string>, string) Initializes a new instance with the given category path, tag list, and variable-tag pattern. public IntegerTagValueSyntax(IEnumerable<string> categoryPath, IEnumerable<string> tags, string variableTag) Parameters categoryPath IEnumerable<string> JSON path under Parsing where matches are written. tags IEnumerable<string> Single-letter tag names whose values are grabbed. variableTag string Regex/literal recognizing a variable reference as a value. IntegerTagValueSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public IntegerTagValueSyntax(XElement src) Parameters src XElement Source XML element. Properties XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToInteger(string) Parses a numeric literal to int; returns the original string for variable text. public static JsonNode ToInteger(string setup) Parameters setup string Returns JsonNode ToValueJsonNode(string) Converts a tag setup string value to a JsonNode. Override in derived classes for typed parsing (int, double). Variable text (e.g. Q2, #1, [#1+#2]) is kept as string. protected override JsonNode ToValueJsonNode(string setup) Parameters setup string Returns JsonNode"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.NamedVarAssignmentSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.NamedVarAssignmentSyntax.html",
    "title": "Class NamedVarAssignmentSyntax | HiAPI-C# 2025",
    "summary": "Class NamedVarAssignmentSyntax Namespace Hi.NcParsers.ParsingSyntaxs Assembly HiMech.dll Assignment syntax for named (identifier-style) variables with = sign. Handles variables that are multi-character identifiers rather than {prefix}{digits}. public class NamedVarAssignmentSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object NamedVarAssignmentSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild.UnparsedText: _X_HOME=500.0 #AfterBuild: { \"Parsing\": { \"Assignments\": { \"_X_HOME\": \"500.0\" } } } #BeforeBuild.UnparsedText: _A=5 X=100 (the RHS stops at the next assignment-looking token; single-letter X= is not an identifier here and is left for the tag-value syntaxes) #AfterBuild: { \"UnparsedText\": \"X=100\", \"Parsing\": { \"Assignments\": { \"_A\": \"5\" } } } Remarks Siemens GUD: _X_HOME = 100, _MY_VAR = R1 + R2 Siemens LUD: DEF REAL MY_LOCAL; MY_LOCAL = 50 Unlike TagAssignmentSyntax which captures only the numbered {prefix}{digits} family (#1, R1, Q5), this identifier grammar is broader and also matches letter+digits tokens such as R1. The overlap is benign by construction: both assignment syntaxes route to the same Parsing.Assignments subtree with the same JSON shape, and a preset must give both the same TerminateWords; their RHS boundary rules are likewise aligned (any following token= stops the expression). A token captured by either therefore lands as the exact same JSON, so the relative ordering of the two syntaxes does not affect output. Identifiers must be at least 2 characters so single-letter axis addresses (X=100) stay with the tag-value syntaxes. Constructors NamedVarAssignmentSyntax(IEnumerable<string>, IEnumerable<string>, string) Initializes a new instance with the given category path, optional terminator keywords, and an identifier regex pattern. public NamedVarAssignmentSyntax(IEnumerable<string> categoryPath, IEnumerable<string> terminateWords = null, string identPattern = \"[A-Za-z_]\\\\w+\") Parameters categoryPath IEnumerable<string> JSON path under Parsing where assignments are written. Pass null to use DefaultCategoryPath (Parsing.Assignments). Pass an empty collection only if assignments should land at the Parsing root. terminateWords IEnumerable<string> Optional keywords that end the right-hand expression. identPattern string Regex matching the variable identifier; defaults to DefaultIdentPattern. NamedVarAssignmentSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public NamedVarAssignmentSyntax(XElement src) Parameters src XElement Source XML element. Fields DefaultIdentPattern Default identifier regex (at least 2 characters; first char letter or underscore). The 2-character minimum keeps single-letter axis addresses (X=100) with the tag-value syntaxes. Letter+digits tokens (R1) also match — that overlap with TagAssignmentSyntax is benign by construction (see the class remarks). Used when IdentPattern is not overridden. public const string DefaultIdentPattern = \"[A-Za-z_]\\\\w+\" Field Value string Properties CategoryPath JSON path under Parsing where matched assignments are written. public List<string> CategoryPath { get; set; } Property Value List<string> DefaultCategoryPath Default CategoryPath assigned when the caller passes null (or omits the <CategoryPath> element in saved XML). Routes assignment outputs into Parsing.Assignments — the same subtree as DefaultCategoryPath — so variable-reading syntaxes can target a single well-defined location. public static IReadOnlyList<string> DefaultCategoryPath { get; } Property Value IReadOnlyList<string> IdentPattern Regex pattern for matching variable identifiers. Default: [A-Za-z_]\\w+ (at least 2 characters). public string IdentPattern { get; set; } Property Value string Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string RhsDialect Expression grammar delimiting the RHS (parser-delimited capture): when set, the longest valid expression prefix ends the RHS — superseding TerminateWords on matches where a prefix parses. Default None keeps the legacy lexical boundary. Must stay in sync with the value on RhsDialect in the same preset (the P0 behavior-alignment contract). public NcExpressionDialect RhsDialect { get; set; } Property Value NcExpressionDialect TerminateWords Optional words (e.g. block-end keywords) that terminate the right-hand expression so the remainder is left in UnparsedText. public List<string> TerminateWords { get; set; } Property Value List<string> XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToAssignmentJsonNode(string) Converts an assignment expression string to a JsonNode. Override in derived classes for typed parsing. protected virtual JsonNode ToAssignmentJsonNode(string setup) Parameters setup string Returns JsonNode"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.NumberedFlagSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.NumberedFlagSyntax.html",
    "title": "Class NumberedFlagSyntax | HiAPI-C# 2025",
    "summary": "Class NumberedFlagSyntax Namespace Hi.NcParsers.ParsingSyntaxs Assembly HiMech.dll Syntax for numbered flags (prefix + number) with optional decimal support. NumberedFlagSyntax often should place after something like ParameterizedFlagSyntax. Since NumberedFlagSyntax is easy to eat those kind of flags. Single-digit integer codes are zero-padded to canonical 2-digit form (e.g. M6 → M06, G0 → G00, M3 → M03) so that downstream logic syntaxes comparing against IsoKeywords constants (which are always 2-digit form like M06) can match Fanuc-style omitted-leading-zero codes. Two-digit and decimal codes are kept as-is. public class NumberedFlagSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object NumberedFlagSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks Examples of stored canonical flags: Single-digit integer codes, padded: G0 → G00, M3 → M03 Two-digit or longer integer codes, unchanged: G54, M30 Decimal codes, unchanged: G54.1 (Fanuc extended work coordinates) Note: Parameters like P2 in G54.1P2 should be handled by TagSetupSyntax separately. Constructors NumberedFlagSyntax(IEnumerable<string>, IEnumerable<string>, bool) Creates a new NumberedFlagSyntax instance. public NumberedFlagSyntax(IEnumerable<string> categoryPath, IEnumerable<string> codePrefixes, bool allowDecimal = true) Parameters categoryPath IEnumerable<string> JSON path for storing matched codes. codePrefixes IEnumerable<string> Code prefixes to match (e.g., [“G”, “M”]). allowDecimal bool Whether to allow decimal numbers. NumberedFlagSyntax(XElement) Loads category path, code prefixes, and decimal policy from XML. public NumberedFlagSyntax(XElement src) Parameters src XElement Root element named XName. Properties AllowDecimal Whether to allow decimal numbers (e.g., G54.1). public bool AllowDecimal { get; set; } Property Value bool CategoryPath Category path for storing matched codes in JSON. public List<string> CategoryPath { get; set; } Property Value List<string> CodePrefixes Code prefixes to match (e.g., [“G”, “M”]). public List<string> CodePrefixes { get; set; } Property Value List<string> Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.ParameterizedFlagSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.ParameterizedFlagSyntax.html",
    "title": "Class ParameterizedFlagSyntax | HiAPI-C# 2025",
    "summary": "Class ParameterizedFlagSyntax Namespace Hi.NcParsers.ParsingSyntaxs Assembly HiMech.dll Syntax for flags with attached parameters (e.g., G54.1P1, G10L2P1). This is essentially a combination of main flag matching (like NumberedFlagSyntax) plus scoped TagValueSyntax for the parameters after the main flag. Note that the ParameterizedFlagSyntax often should be applied before NumberedFlagSyntax since NumberedFlagSyntax may eat the text that ParameterizedFlagSyntax should handle. public class ParameterizedFlagSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object ParameterizedFlagSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples The cases below run the Fanuc-family G54p1Syntax instance (CodePrefixes = [“G54.1”], IntParamPrefixes = [“P”], ParamGatedAliases = {“G54” → “G54.1”}, TerminateWords = [“G”, “M”]). The consumed span is cut out of the text as-is, so the residue keeps the spaces that surrounded the code and its P word — the spaced and the glued spellings differ only there. Canonical spelling with a space (G54.1 P48) — captured as an integer P under Parsing.G54.1, the rest of the block left for the later syntaxes: #BeforeBuild: { \"UnparsedText\": \"G0 G90 G54.1 P48 X0. Y0.\" } #AfterBuild: { \"UnparsedText\": \"G0 G90 X0. Y0.\", \"Parsing\": { \"G54.1\": { \"P\": 48 } } } Canonical spelling glued (G54.1P48, glued axis words too): #BeforeBuild: { \"UnparsedText\": \"G00 G90 G54.1P48 X0.Y0.\" } #AfterBuild: { \"UnparsedText\": \"G00 G90 X0.Y0.\", \"Parsing\": { \"G54.1\": { \"P\": 48 } } } The alias spelling with a space — a customer post's block, verbatim — lands under the canonical key exactly like the first case: #BeforeBuild: { \"UnparsedText\": \"G0 G90 G54 P48 X0. Y0.\" } #AfterBuild: { \"UnparsedText\": \"G0 G90 X0. Y0.\", \"Parsing\": { \"G54.1\": { \"P\": 48 } } } The alias spelling glued (G54P48), the same post's other habit, in the same file: #BeforeBuild: { \"UnparsedText\": \"G00 G90 G54P48 X0.Y0.\" } #AfterBuild: { \"UnparsedText\": \"G00 G90 X0.Y0.\", \"Parsing\": { \"G54.1\": { \"P\": 48 } } } A bare G54 (no P word anywhere in its scope) is not this flag: the alias grabs nothing, consumes nothing, and the block is left for NumberedFlagSyntax to read the plain G54 flag — no Parsing object is created: #BeforeBuild: { \"UnparsedText\": \"G00 G90 G54 X-24.048 Y-52.446\" } #AfterBuild: { \"UnparsedText\": \"G00 G90 G54 X-24.048 Y-52.446\" } A lower-case program: the key is the configured spelling (\"G54.1\") and the parameter tag is upper-cased, while the untouched residue keeps its case: #BeforeBuild: { \"UnparsedText\": \"g0 g90 g54 p4 x0. y0.\" } #AfterBuild: { \"UnparsedText\": \"g0 g90 x0. y0.\", \"Parsing\": { \"G54.1\": { \"P\": 4 } } } Remarks Parameters can be stored as typed values via FloatParamPrefixes and IntParamPrefixes (set via property initializer): ParamPrefixes — stored as string (text, for variables like #1, Q2) FloatParamPrefixes — stored as double when parseable, string otherwise IntParamPrefixes — stored as int when parseable, string otherwise Examples: G54.1P1 → {\"G54.1\": {\"P\": \"1\"}} (text) G68.2 X0 I180 → {\"G68.2\": {\"X\": 0.0, \"I\": 180.0}} (float via property initializer) G54.1P#1 → {\"G54.1\": {\"P\": \"#1\"}} (Fanuc variable, kept as string) G54.1PQ1 → {\"G54.1\": {\"P\": \"Q1\"}} (Heidenhain variable) The stored key is the code's configured spelling (the CodePrefixes entry that matched, or the canonical code an alias maps to), not the text as written: the match is case-insensitive, so a lower-case program (g54.1 p4) still lands under \"G54.1\" where the logic syntaxes look it up. A spelling that only means this flag when a parameter follows — Fanuc's G54 Pn for the additional work coordinate system, where a bare G54 is the ordinary work-offset flag — is declared in ParamGatedAliases rather than CodePrefixes. An alias hit that grabs no parameter is left in the text untouched for the later syntaxes; an alias hit with a parameter is stored under its canonical code, indistinguishable from the canonical spelling. A canonical code that grabs no parameter (a bare G43 whose H is omitted, a bare G41 resuming the modal D) is likewise left in the text and lands in Parsing.Flags through the trailing NumberedFlagSyntax. It is never stored as an empty object: CleanupParsing strips empty objects, and VariableEvaluatorSyntax runs one on every block, so an empty {\"G43\": {}} would vanish before the logic syntax that owns it ran. Consumers therefore look for their code both as a parameter object and as a flag. Constructors ParameterizedFlagSyntax(IEnumerable<string>, IEnumerable<string>, IEnumerable<string>, string, IEnumerable<string>) Creates a new ParameterizedFlagSyntax instance. Use property initializers for FloatParamPrefixes, IntParamPrefixes and ParamGatedAliases. public ParameterizedFlagSyntax(IEnumerable<string> categoryPath, IEnumerable<string> codePrefixes, IEnumerable<string> paramPrefixes, string varPrefix, IEnumerable<string> terminateWords = null) Parameters categoryPath IEnumerable<string> JSON path for storing matched codes. codePrefixes IEnumerable<string> Full code prefixes to match (e.g., [“G54.1”, “G10”]). paramPrefixes IEnumerable<string> Parameter prefixes to extract (e.g., [“P”, “L”]). varPrefix string Variable prefix (e.g., “#” for Fanuc, “Q” for Heidenhain). terminateWords IEnumerable<string> Words that stop parameter extraction. ParameterizedFlagSyntax(XElement) Loads all prefix lists, aliases, variable prefix, and terminator words from XML. public ParameterizedFlagSyntax(XElement src) Parameters src XElement Root element named XName. Properties CategoryPath Category path for storing matched codes in JSON. public List<string> CategoryPath { get; set; } Property Value List<string> CodePrefixes Full code prefixes to match (e.g., [“G54.1”, “G10”]). public List<string> CodePrefixes { get; set; } Property Value List<string> FloatParamPrefixes Parameter prefixes stored as double when parseable, string otherwise (for variable references). Set via property initializer for typed G-code parameters. public List<string> FloatParamPrefixes { get; set; } Property Value List<string> IntParamPrefixes Parameter prefixes stored as int when parseable, string otherwise (for variable references). Set via property initializer for typed G-code parameters. public List<string> IntParamPrefixes { get; set; } Property Value List<string> Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string ParamGatedAliases Alternative spellings that denote one of the CodePrefixes only when at least one parameter follows: key = the spelling as written in NC text, value = the canonical code the capture is stored under. Matched case-insensitively. A hit that grabs no parameter is left in the text for the later syntaxes — the spelling keeps its own meaning there (Fanuc's G54 Pn is the additional work coordinate system, a bare G54 the ordinary work-offset flag). Serialized as <ParamGatedAliases><Entry Key=“G54”>G54.1</Entry>, omitted when empty. public Dictionary<string, string> ParamGatedAliases { get; set; } Property Value Dictionary<string, string> ParamPrefixes Parameter prefixes to extract as text string (e.g., [“P”, “L”, “H”]). Multiple parameters can be attached to one code. public List<string> ParamPrefixes { get; set; } Property Value List<string> TerminateWords Words that terminate parameter extraction (e.g., [“G”, “M”, “X”, “Y”, “Z”]). Extraction stops when encountering these prefixes followed by a number. public List<string> TerminateWords { get; set; } Property Value List<string> VarPrefix Variable prefix for macro variables (e.g., “#” for Fanuc, “Q” for Heidenhain). public string VarPrefix { get; set; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.ShrinkIfNoDecimalPointSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.ShrinkIfNoDecimalPointSyntax.html",
    "title": "Class ShrinkIfNoDecimalPointSyntax | HiAPI-C# 2025",
    "summary": "Class ShrinkIfNoDecimalPointSyntax Namespace Hi.NcParsers.ParsingSyntaxs Assembly HiMech.dll Applies the “conventional type” decimal-point interpretation to coordinate values in UnparsedText. When a tag value has no decimal point (e.g. Y20), it is shrunk by the implied decimal places: Y20 → Y0.020 (3 decimal places). Values that already contain a decimal point are left unchanged. Place inside BundleSyntax before FloatTagValueSyntax so the modified text is parsed correctly by subsequent syntaxes. public class ShrinkIfNoDecimalPointSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object ShrinkIfNoDecimalPointSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks Modern CNC controllers default to “calculator type” where Y20 = Y20.0. This syntax is only needed for legacy “conventional type” configurations where Y20 = Y0.020 (Fanuc DPI=0, etc.). Properties ImpliedDecimalPlaces Number of implied decimal places when no decimal point is present. 3 → 0.001 (mm), 4 → 0.0001 (inch). public int ImpliedDecimalPlaces { get; set; } Property Value int Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string Tags Tags to check for missing decimal points. Default: X, Y, Z. public List<string> Tags { get; set; } Property Value List<string> XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensCallStatementSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensCallStatementSyntax.html",
    "title": "Class SiemensCallStatementSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensCallStatementSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Siemens Assembly HiMech.dll Captures a whole-line Siemens subprogram-call statement into Parsing.SiemensCall for SiemensSubProgramCallSyntax to resolve (inline the file) or safe-skip (structured warning, zero motion). Two shapes are owned: Parenthesized call, any identifier — HQ_FC(1,50,75,160), L_39(0.000,0.000), HH_ROBOT(2) → { \"Name\": \"HQ_FC\", \"Args\": [\"1\",\"50\",…] }. The argument grammar (complete quoted runs admitted, quote-aware comma split) is SiemensCycleCallSyntax's, reused verbatim. Bare-word call — L9810, L_ZYM91, HH_ROBOTOFF, with an optional repeat count L123 P3 → { \"Name\": \"L123\", \"P\": 3 }. Restricted to L-leading or underscore-bearing identifiers on purpose: this syntax runs ahead of FlagSyntax and a generic bare-identifier capture would steal TRAORI-class words before their consumers ever saw them — the same underscore heuristic NamedIdentPattern blessed for assignments (corpus named entities all carry an underscore; controller vocabulary never does). On real Sinumerik any bare identifier can be a by-name call; widening further is a corpus-driven follow-up. Placement: last of the dedicated statement owners and still before SiemensQuotedStatementSyntax — quoted arguments must reach this capture (paired quotes ride inside the args body; a line whose quotes do not pair falls through whole to the quarantine). ExcludedNames keeps this catch-all from re-owning statements that belong elsewhere (default: WRITE stays with the quoted-statement quarantine; control-flow words are reserved for their future syntaxes). Whole-line anchored: a call mixed with other tokens (L9810 M8) does not match and stays visible in the unparsed warning. public class SiemensCallStatementSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensCallStatementSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples OEM cycle call with positional args: #BeforeBuild.UnparsedText: HQ_FC(1,50,75,160) #AfterBuild: { \"Parsing\": { \"SiemensCall\": { \"Name\": \"HQ_FC\", \"Args\": [\"1\", \"50\", \"75\", \"160\"] } } } Bare L-number call (Renishaw style): #BeforeBuild.UnparsedText: L9810 #AfterBuild: { \"Parsing\": { \"SiemensCall\": { \"Name\": \"L9810\" } } } L-call with repeat count: #BeforeBuild.UnparsedText: L123 P3 #AfterBuild: { \"Parsing\": { \"SiemensCall\": { \"Name\": \"L123\", \"P\": 3 } } } Underscore-bearing bare identifier (OEM switch subprogram): #BeforeBuild.UnparsedText: HH_ROBOTOFF #AfterBuild: { \"Parsing\": { \"SiemensCall\": { \"Name\": \"HH_ROBOTOFF\" } } } A plain bare identifier (no L prefix, no underscore) is NOT a call shape here — left for the flag word table and the visible unparsed warning: #BeforeBuild.UnparsedText: TOFRAME #AfterBuild: { \"UnparsedText\": \"TOFRAME\" } An excluded name falls through whole (WRITE belongs to the quoted-statement quarantine): #BeforeBuild.UnparsedText: WRITE(VAR,“file”,“text”) #AfterBuild: { \"UnparsedText\": \"WRITE(VAR,\\\"file\\\",\\\"text\\\")\" } Constructors SiemensCallStatementSyntax() Parameterless instance with default settings. public SiemensCallStatementSyntax() SiemensCallStatementSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public SiemensCallStatementSyntax(XElement src) Parameters src XElement Source XML element. Properties ExcludedNames Identifiers this catch-all must never treat as a call — matched case-insensitively against the callee name. See the class remarks for the default rationale. public List<string> ExcludedNames { get; set; } Property Value List<string> Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensCycleCallSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensCycleCallSyntax.html",
    "title": "Class SiemensCycleCallSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensCycleCallSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Siemens Assembly HiMech.dll Captures whitelisted Siemens cycle calls of the shape NAME(arg1,arg2,…) (or the bare NAME form) from the unparsed line text into a Parsing.NAME sub-object holding the verbatim positional argument strings: CYCLE832(0.05,_ORI_FINISH,0.8) → Parsing.CYCLE832 = { “Args”: [“0.05”, “_ORI_FINISH”, “0.8”] }. Empty slots (,,) stay as empty strings; NAME() yields an empty Args array; a bare NAME yields { “Bare”: true } (a marker — empty sub-objects would be swept by intermediate CleanupParsing calls before the consumer runs). A brand Logic syntax consumes the sub-object (e.g. SiemensPathSmoothingSyntax for CYCLE832, SiemensCycle800TiltSyntax for CYCLE800). Strictly whitelist-based (CycleNames, default CYCLE832 + CYCLE800) — a generic WORD(args) capture would eat OEM/unknown calls (HQ_FC(...), L_39(...)) whose safe-skip handling is a separate work item, and every unlisted call deliberately stays whole in UnparsedText for the visible UnparsedText--Remaining warning. Must be placed early in the Parsing bundle — before the assignment and tag-value syntaxes: argument tokens standing after ( or , (_ORI_FINISH, or axis-letter shapes like V1) would otherwise be shredded by NamedVarAssignmentSyntax / tag-value captures. Quoted arguments are supported for CYCLE800's swivel-data-record name (CYCLE800(1,\"TC1\",…)): the args body admits complete \"…\" runs (which may hide ) or ,) and the comma split is quote-aware; quotes are kept verbatim in the captured arg string so the consumer distinguishes \"0\" (name) from 0 (number). A line whose quotes do not pair falls through whole to SiemensQuotedStatementSyntax's quarantine. public class SiemensCycleCallSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensCycleCallSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Full arm call with an identifier argument: #BeforeBuild.UnparsedText: CYCLE832(0.05,_ORI_FINISH,0.8) #AfterBuild: { \"Parsing\": { \"CYCLE832\": { \"Args\": [\"0.05\", \"_ORI_FINISH\", \"0.8\"] } } } Cancel form with empty parentheses: #BeforeBuild.UnparsedText: CYCLE832() #AfterBuild: { \"Parsing\": { \"CYCLE832\": { \"Args\": [] } } } Leading-dot tolerance and numeric mode (older post shape), mixed line: #BeforeBuild.UnparsedText: N21 CYCLE832(.03,1,1) #AfterBuild: { \"UnparsedText\": \"N21\", \"Parsing\": { \"CYCLE832\": { \"Args\": [\".03\", \"1\", \"1\"] } } } CYCLE800 with a quoted swivel-data-record name — the quoted run is one argument (quotes preserved for the consumer) and the remaining positional args split normally: #BeforeBuild.UnparsedText: CYCLE800(1,“R_DATA”,0,57,0,0,0,20.0116,4.5217,0,0,0,0,-1,0) #AfterBuild: { \"Parsing\": { \"CYCLE800\": { \"Args\": [ \"1\", \"\\\"R_DATA\\\"\", \"0\", \"57\", \"0\", \"0\", \"0\", \"20.0116\", \"4.5217\", \"0\", \"0\", \"0\", \"0\", \"-1\", \"0\" ] } } } A comma inside the quoted name does not split — the quoted run stays one argument (the reason the split is quote-aware at all): #BeforeBuild.UnparsedText: CYCLE800(1,“A,B”,0,57) #AfterBuild: { \"Parsing\": { \"CYCLE800\": { \"Args\": [\"1\", \"\\\"A,B\\\"\", \"0\", \"57\"] } } } Constructors SiemensCycleCallSyntax() Initializes a new instance with default settings. public SiemensCycleCallSyntax() SiemensCycleCallSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public SiemensCycleCallSyntax(XElement src) Parameters src XElement Source XML element. Fields ArgsKey Sub-object key holding the verbatim positional argument strings. public const string ArgsKey = \"Args\" Field Value string BareKey Marker key for the bare (parenthesis-less) call form — keeps the sub-object non-empty so CleanupParsing sweeps by earlier Logic syntaxes cannot drop the signal. public const string BareKey = \"Bare\" Field Value string Properties CycleNames Cycle names this syntax captures. Whitelist only — every unlisted call stays whole in UnparsedText (see class remarks). public List<string> CycleNames { get; set; } Property Value List<string> Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensDefStatementSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensDefStatementSyntax.html",
    "title": "Class SiemensDefStatementSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensDefStatementSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Siemens Assembly HiMech.dll Consumes Sinumerik variable declarations (DEF REAL _X_HOME=155.5, _SAFE_Z / DEF INT N_ST=3) and lowers each declared name into Parsing.Assignments: initialised names carry their initialiser expression text (the Evaluation bundle resolves and routes it into Vars.Named like any named assignment), bare names carry “0” — Sinumerik default-initialises numeric types to zero, so a later G0 Z=_SAFE_Z reads 0 instead of failing vacant. Must run before NamedVarAssignmentSyntax in the Parsing bundle: on a DEF line that syntax would capture _X_HOME=155.5 but strand DEF REAL (and the comma list) as unparsed residue. Initialiser expressions are delimited by the SiemensExpressionParser longest-valid-prefix rule, so parenthesised arithmetic and whitespace survive; a non-numeric type or unparsable initialiser leaves the whole statement untouched (visible as residue) rather than half-consuming it. BOOL/CHAR initialise to 0 like INT; STRING declarations are not lowered (string values have no numeric store) — the statement is consumed whole so it cannot shed ghost tokens. The declaration itself leaves no Parsing record: the lowered Assignments entries carry the entire semantic payload, and an inert record would only re-surface as an Unconsumed residue. public class SiemensDefStatementSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensDefStatementSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild.UnparsedText: DEF REAL _X_HOME=155.5, _SAFE_Z #AfterBuild: { \"Parsing\": { \"Assignments\": { \"_X_HOME\": \"155.5\", \"_SAFE_Z\": \"0\" } } } Constructors SiemensDefStatementSyntax() Default constructor. public SiemensDefStatementSyntax() SiemensDefStatementSyntax(XElement) Loads from an XML element produced by MakeXmlSource(string, string, bool). No state to deserialise. public SiemensDefStatementSyntax(XElement src) Parameters src XElement Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensFrameStatementSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensFrameStatementSyntax.html",
    "title": "Class SiemensFrameStatementSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensFrameStatementSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Siemens Assembly HiMech.dll Captures a whole Siemens frame statement (TRANS/ATRANS/ROT/AROT/ ROTS/AROTS/CROTS/SCALE/ASCALE/MIRROR/AMIRROR, bare or with arguments) into a Parsing.<keyword> sub-object. Sinumerik requires frame instructions in a block of their own, so the whole remaining line belongs to the statement. The consumed keywords (TRANS/ATRANS/ROT/AROT/ROTS/AROTS — see SiemensProgrammableFrameSyntax) are captured structured: each argument token becomes a sub-key — glued axis words (X0, Y90.) and equals forms (RPL=45, Z=R5) both supported. Literal values are stored as JSON numbers; non-literal right-hand sides stay strings so VariableEvaluatorSyntax resolves them in the Evaluation stage (AROT Z=R5 → Parsing.AROT = { \"Z\": \"R5\" }). A token outside the modeled grammar makes the whole statement fall back to the verbatim StatementKey capture — never a half-consumed line. The remaining keywords (CROTS/SCALE/ASCALE/MIRROR/AMIRROR — zero corpus occurrences, no simulation) keep the verbatim { \"Statement\": \"<args>\" } quarantine; the Logic consumer reports them as recognized-but-not-simulated. Either way the axis words are kept out of reach of the quote/context-blind tag-value syntaxes below, which would otherwise mint them into Parsing.X/Y/Z and let ProgramXyzSyntax turn a frame statement into a very real ghost rapid. Deferred-but-unmodeled must mean \"no transform yet\", never \"extra motion\". Must be placed early in the Parsing bundle — after BlockSkipSyntax, before every assignment / tag-value syntax (the ROT RPL=45 shape would otherwise feed NamedVarAssignmentSyntax). public class SiemensFrameStatementSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensFrameStatementSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Translation with arguments — structured capture, literal axis words become JSON numbers: #BeforeBuild.UnparsedText: TRANS X0 Y0 Z0 #AfterBuild: { \"Parsing\": { \"TRANS\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } } } Bare cancel form — marker instead of an empty sub-object (empty sub-objects would be swept by intermediate CleanupParsing calls, silently dropping the cancel signal): #BeforeBuild.UnparsedText: ROT #AfterBuild: { \"Parsing\": { \"ROT\": { \"Bare\": true } } } Additive rotation — corpus shape: #BeforeBuild.UnparsedText: AROT Y90. #AfterBuild: { \"Parsing\": { \"AROT\": { \"Y\": 90 } } } In-plane rotation via the equals form: #BeforeBuild.UnparsedText: ROT RPL=45 #AfterBuild: { \"Parsing\": { \"ROT\": { \"RPL\": 45 } } } Non-literal right-hand side stays a string for the Evaluation-stage variable evaluator: #BeforeBuild.UnparsedText: AROT Z=R5 #AfterBuild: { \"Parsing\": { \"AROT\": { \"Z\": \"R5\" } } } Unmodeled keyword keeps the verbatim quarantine (record-only): #BeforeBuild.UnparsedText: SCALE X2 Y2 #AfterBuild: { \"Parsing\": { \"SCALE\": { \"Statement\": \"X2 Y2\" } } } A token outside the modeled grammar (here an unknown key) makes the whole statement fall back to the verbatim capture — no axis is half-consumed and the residue stays visible: #BeforeBuild.UnparsedText: TRANS X10 CFINE=2 #AfterBuild: { \"Parsing\": { \"TRANS\": { \"Statement\": \"X10 CFINE=2\" } } } Solid-angle rotation — structured like the plain rotation family (the pair orients a plane; the Logic consumer owns the pair math): #BeforeBuild.UnparsedText: ROTS X30 Y40 #AfterBuild: { \"Parsing\": { \"ROTS\": { \"X\": 30, \"Y\": 40 } } } CROTS (database-frame reference, not simulated) is captured but stays on the verbatim quarantine: #BeforeBuild.UnparsedText: CROTS X30 Y40 #AfterBuild: { \"Parsing\": { \"CROTS\": { \"Statement\": \"X30 Y40\" } } } Constructors SiemensFrameStatementSyntax() Initializes a new instance with default settings. public SiemensFrameStatementSyntax() SiemensFrameStatementSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public SiemensFrameStatementSyntax(XElement src) Parameters src XElement Source XML element. Fields BareKey Marker key for the bare (argument-less, i.e. cancel) form — keeps the sub-object non-empty so intermediate CleanupParsing sweeps cannot drop the signal. public const string BareKey = \"Bare\" Field Value string StatementKey Sub-object key holding the verbatim statement arguments (fallback / record-only shape). public const string StatementKey = \"Statement\" Field Value string StructuredKeywords Keywords whose arguments are captured structured (axis sub-keys) because SiemensProgrammableFrameSyntax consumes them. The remaining Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensFrameStatementSyntax.FrameRegex keywords stay on the verbatim StatementKey capture (record-only). public static readonly string[] StructuredKeywords Field Value string[] Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensGotoParsingSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensGotoParsingSyntax.html",
    "title": "Class SiemensGotoParsingSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensGotoParsingSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Siemens Assembly HiMech.dll Captures Siemens GOTOF/GOTOB jump statements whole into Parsing.SiemensGoto. Four forms are recognised, mirroring the Fanuc phrase-level split (IF ... GOTO is one phrase, not an IF composed with a GOTO): GOTOF <label> / GOTOB <label> — unconditional forward / backward jump. IF <cond> GOTOF <label> / IF <cond> GOTOB <label> — the Sinumerik single-line conditional jump (no brackets around the condition). Placement: inside the whole-statement owner group, after SiemensRepeatParsingSyntax and before SiemensIfParsingSyntax — the IF-jump forms carry a strictly longer prefix than the block IF <cond> phrase, so this owner must win first (the block-IF owner also refuses GOTOF/GOTOB tails defensively). Must run before the assignment syntaxes: IF R1==1 GOTOF LBL1 would otherwise be shredded by the assignment capture (its LHS grammar matches R1 and the first = of ==). The label is captured as written (LBL1, MARKE_A, or an N<num> block number — both are legal Sinumerik jump targets). The condition string is left for VariableEvaluatorSyntax's pass-2 tree walk; SiemensGotoSyntax consumes the section. public class SiemensGotoParsingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensGotoParsingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Bare forward jump: #BeforeBuild.UnparsedText: GOTOF LBL1 #AfterBuild: { \"Parsing\": { \"SiemensGoto\": { \"Term\": \"GOTOF\", \"Label\": \"LBL1\" } } } Bare backward jump to an underscore label: #BeforeBuild.UnparsedText: GOTOB MARKE_A #AfterBuild: { \"Parsing\": { \"SiemensGoto\": { \"Term\": \"GOTOB\", \"Label\": \"MARKE_A\" } } } Single-line conditional forward jump — the condition keeps its Sinumerik spelling for the evaluator: #BeforeBuild.UnparsedText: IF R1==1 GOTOF LBL2 #AfterBuild: { \"Parsing\": { \"SiemensGoto\": { \"Term\": \"IF...GOTOF\", \"Label\": \"LBL2\", \"Condition\": \"R1==1\" } } } Conditional backward jump with a comparison condition: #BeforeBuild.UnparsedText: IF R10<5 GOTOB START_MK #AfterBuild: { \"Parsing\": { \"SiemensGoto\": { \"Term\": \"IF...GOTOB\", \"Label\": \"START_MK\", \"Condition\": \"R10<5\" } } } Constructors SiemensGotoParsingSyntax() Parameterless instance (no XML state). public SiemensGotoParsingSyntax() SiemensGotoParsingSyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public SiemensGotoParsingSyntax(XElement src) Parameters src XElement Root element named XName. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensIfParsingSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensIfParsingSyntax.html",
    "title": "Class SiemensIfParsingSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensIfParsingSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Siemens Assembly HiMech.dll Captures the Siemens block-conditional phrases whole into Parsing.SiemensIf: IF <cond> (no brackets on Sinumerik), ELSE, ENDIF. The single-line jump form (IF <cond> GOTOF <label>) belongs to SiemensGotoParsingSyntax, which runs immediately before this owner; a GOTOF/GOTOB tail is additionally refused here so an ordering drift degrades to a visible unparsed warning instead of a silently mis-captured block-IF (the Fanuc (?!GOTO\\b) precedent). Placement: whole-statement owner group, before the assignment syntaxes — a condition like R1==1 would otherwise be shredded by the assignment capture (LHS grammar matches R1 plus the first =). The condition string is left for VariableEvaluatorSyntax's pass-2 walk; SiemensIfSyntax consumes the section and decides the branch. public class SiemensIfParsingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensIfParsingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Block-conditional entry — the condition keeps its Sinumerik spelling: #BeforeBuild.UnparsedText: IF R1==1 #AfterBuild: { \"Parsing\": { \"SiemensIf\": { \"Term\": \"IF\", \"Condition\": \"R1==1\" } } } Alternative branch separator: #BeforeBuild.UnparsedText: ELSE #AfterBuild: { \"Parsing\": { \"SiemensIf\": { \"Term\": \"ELSE\" } } } Terminator: #BeforeBuild.UnparsedText: ENDIF #AfterBuild: { \"Parsing\": { \"SiemensIf\": { \"Term\": \"ENDIF\" } } } A single-line jump is NOT captured here — it belongs to the GOTO owner (this pin guards the ordering-drift defence): #BeforeBuild.UnparsedText: IF R1==1 GOTOF LBL1 #AfterBuild: { \"UnparsedText\": \"IF R1==1 GOTOF LBL1\" } The glued parenthesised spelling is owned too — the parenthesised condition goes to the evaluator verbatim: #BeforeBuild.UnparsedText: IF(R1==1) #AfterBuild: { \"Parsing\": { \"SiemensIf\": { \"Term\": \"IF\", \"Condition\": \"(R1==1)\" } } } Constructors SiemensIfParsingSyntax() Parameterless instance (no XML state). public SiemensIfParsingSyntax() SiemensIfParsingSyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public SiemensIfParsingSyntax(XElement src) Parameters src XElement Root element named XName. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensLabelSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensLabelSyntax.html",
    "title": "Class SiemensLabelSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensLabelSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Siemens Assembly HiMech.dll Consumes a Siemens label at block start (LBL1: — identifier followed by a colon, optionally after the N head index) into a block-root SiemensLabel record. Labels are passive jump targets: in the normal flow the record is pure bookkeeping (no motion, no state), while SiemensRepeatSyntax uses this same syntax as its LabelScanUtil probe and matches candidates on SiemensLabel.Name. Writing the record at the block root (not under Parsing) keeps the passive token out of UnconsumedCheckSyntax's audit without needing a Logic-layer consumer — mirroring how SiemensDefStatementSyntax leaves no Parsing.Def entry behind. Anchored at the start of the remaining unparsed text, so a label buried mid-line is not captured (Sinumerik allows one label per block, at block start). Text after the colon stays in UnparsedText for the rest of the pipeline — LBL1: G1 X0 executes its trailing motion normally. The probe usage requires this syntax to stay self-sufficient: it reads only UnparsedText and never touches the dependency list. public class SiemensLabelSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensLabelSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Plain label line (trailing whitespace tolerated): #BeforeBuild.UnparsedText: LBL1: #AfterBuild: { \"SiemensLabel\": { \"Name\": \"LBL1\" } } Label with trailing code — the remainder stays for the pipeline: #BeforeBuild.UnparsedText: MARK_A: G1 X0 #AfterBuild: { \"UnparsedText\": \"G1 X0\", \"SiemensLabel\": { \"Name\": \"MARK_A\" } } A colon further into the line is not a label — nothing is captured: #BeforeBuild.UnparsedText: G1 X0 LBL1: #AfterBuild: { \"UnparsedText\": \"G1 X0 LBL1:\" } Constructors SiemensLabelSyntax() Parameterless instance (no XML state). public SiemensLabelSyntax() SiemensLabelSyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public SiemensLabelSyntax(XElement src) Parameters src XElement Root element named XName. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensLoopParsingSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensLoopParsingSyntax.html",
    "title": "Class SiemensLoopParsingSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensLoopParsingSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Siemens Assembly HiMech.dll Captures the Siemens loop-construct phrases whole, one Parsing section per construct family: WHILE <cond> / ENDWHILE → Parsing.SiemensWhile. FOR <var> = <start> TO <end> / ENDFOR → Parsing.SiemensFor. The start expression is stored as a single-entry Init map keyed by the variable name — the evaluator's pass-2 tree walk rewrites values only, never keys, so the loop variable's name survives even when it collides with a set named variable. Literal start/end bounds are written as numeric JSON values directly (writer decides the node type); expressions stay strings for the evaluator. bare REPEAT / UNTIL <cond> → Parsing.SiemensRepeatUntil. Only the label-less form is taken — REPEAT LBL1 ... is the P4 section repeat owned by SiemensRepeatParsingSyntax, which runs earlier in the statement group. LOOP / ENDLOOP → Parsing.SiemensLoop. Placement: whole-statement owner group, after SiemensGotoParsingSyntax / SiemensIfParsingSyntax and before the assignment syntaxes — FOR R1=0 TO 10 would otherwise be shredded by the assignment capture (R1=0 is a legal assignment shape and the TO 10 tail strands). SiemensLoopSyntax consumes all four sections against its shared loop-frame stack. public class SiemensLoopParsingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensLoopParsingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Pre-test loop entry — the condition keeps its Sinumerik spelling: #BeforeBuild.UnparsedText: WHILE R1<=5 #AfterBuild: { \"Parsing\": { \"SiemensWhile\": { \"Term\": \"WHILE\", \"Condition\": \"R1<=5\" } } } Pre-test loop terminator: #BeforeBuild.UnparsedText: ENDWHILE #AfterBuild: { \"Parsing\": { \"SiemensWhile\": { \"Term\": \"ENDWHILE\" } } } Counting loop with literal bounds — literals are written numeric: #BeforeBuild.UnparsedText: FOR R1 = 0 TO 10 #AfterBuild: { \"Parsing\": { \"SiemensFor\": { \"Term\": \"FOR\", \"Init\": { \"R1\": 0 }, \"End\": 10 } } } Counting loop with expression bounds — expressions stay strings for the evaluator: #BeforeBuild.UnparsedText: FOR R2=R5 TO R6+1 #AfterBuild: { \"Parsing\": { \"SiemensFor\": { \"Term\": \"FOR\", \"Init\": { \"R2\": \"R5\" }, \"End\": \"R6+1\" } } } Post-test loop entry (bare form only — the labelled REPEAT is the P4 section repeat): #BeforeBuild.UnparsedText: REPEAT #AfterBuild: { \"Parsing\": { \"SiemensRepeatUntil\": { \"Term\": \"REPEAT\" } } } Post-test loop exit condition: #BeforeBuild.UnparsedText: UNTIL R3>100 #AfterBuild: { \"Parsing\": { \"SiemensRepeatUntil\": { \"Term\": \"UNTIL\", \"Condition\": \"R3>100\" } } } Endless loop entry: #BeforeBuild.UnparsedText: LOOP #AfterBuild: { \"Parsing\": { \"SiemensLoop\": { \"Term\": \"LOOP\" } } } Endless loop terminator: #BeforeBuild.UnparsedText: ENDLOOP #AfterBuild: { \"Parsing\": { \"SiemensLoop\": { \"Term\": \"ENDLOOP\" } } } Constructors SiemensLoopParsingSyntax() Parameterless instance (no XML state). public SiemensLoopParsingSyntax() SiemensLoopParsingSyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public SiemensLoopParsingSyntax(XElement src) Parameters src XElement Root element named XName. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensMcallSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensMcallSyntax.html",
    "title": "Class SiemensMcallSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensMcallSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Siemens Assembly HiMech.dll Captures a Siemens MCALL modal-call statement whole into a Parsing.MCALL sub-object: MCALL CYCLE81(500.,327.9137,0.5,324.564,,,0,1,0) → { “CycleName”: “CYCLE81”, “Args”: [\"500.\", …] }; a bare MCALL (modal cancel) → { “Bare”: true }; a parenthesis-less callee (MCALL L123) keeps CycleName without Args. The Logic consumer (SiemensModalCycleSyntax) maps the supported CYCLE8x family onto the shared canned-cycle modal machinery and warns on everything else. Whole-statement owner: MCALL lines are standalone in the corpus, and owning the full statement keeps the cycle's positional arguments away from the assignment / tag-value syntaxes (same shredding hazard as SiemensCycleCallSyntax, whose argument grammar — including complete quoted runs — is reused verbatim). Must run before SiemensCycleCallSyntax: a whitelisted cycle name after MCALL would otherwise be captured bare-of-context and strand the MCALLL word. A line mixing MCALL with other tokens does not match and falls through whole to the visible unparsed warning. public class SiemensMcallSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensMcallSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Modal drilling-cycle arm (Operate 9-arg extension form): #BeforeBuild.UnparsedText: MCALL CYCLE81(500.,327.9137,0.5,324.564,,,0,1,0) #AfterBuild: { \"Parsing\": { \"MCALL\": { \"CycleName\": \"CYCLE81\", \"Args\": [\"500.\", \"327.9137\", \"0.5\", \"324.564\", \"\", \"\", \"0\", \"1\", \"0\"] } } } Bare cancel: #BeforeBuild.UnparsedText: MCALL #AfterBuild: { \"Parsing\": { \"MCALL\": { \"Bare\": true } } } Parenthesis-less callee (recorded; the Logic consumer warns): #BeforeBuild.UnparsedText: MCALL L123 #AfterBuild: { \"Parsing\": { \"MCALL\": { \"CycleName\": \"L123\" } } } Constructors SiemensMcallSyntax() Parameterless instance (no XML state). public SiemensMcallSyntax() SiemensMcallSyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public SiemensMcallSyntax(XElement src) Parameters src XElement Root element named XName. Fields CycleNameKey Sub-object key holding the modal callee's name. public const string CycleNameKey = \"CycleName\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensMsgSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensMsgSyntax.html",
    "title": "Class SiemensMsgSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensMsgSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Siemens Assembly HiMech.dll Consumes a Siemens MSG(“text”) operator display call (or the bare MSG() clear form) from the unparsed line text into a block-root Msg section, and surfaces the text as a Msg–Display system message. Must be placed before every assignment / tag-value / flag syntax in the Parsing bundle (right after TailCommentSyntax / BlockSkipSyntax): the quoted argument routinely contains NC-shaped tokens (MSG(\"TOOL=5\"), MSG(\"G54 OK\"), MSG(\"T20 R8.000 CR:2.500\")) which the quote-blind consumers downstream would otherwise shred into ghost assignments, flags, or axis words. Consuming the whole call here removes that hazard structurally — the planned fix recorded on NcSyntaxUtil's assignment RHS-boundary notes. Only the two literal forms are consumed: MSG(\"...\") and MSG(). Non-literal arguments (string concatenation MSG(\"A\"<<R1), variable interpolation) are deliberately left whole in UnparsedText for the visible UnparsedText--Remaining warning — half-eating them would silently lose content. public class SiemensMsgSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensMsgSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Plain display message — whole call consumed, text recorded: #BeforeBuild.UnparsedText: MSG(“ROUGHING”) #AfterBuild: { \"Msg\": { \"Text\": \"ROUGHING\" } } Bare clear form — section recorded without Text: #BeforeBuild.UnparsedText: MSG() #AfterBuild: { \"Msg\": {} } Mixed line — the surrounding motion words stay parseable; quoted NC-shaped tokens (TOOL=5) never reach the assignment syntaxes: #BeforeBuild.UnparsedText: G01 X10 MSG(“TOOL=5”) #AfterBuild: { \"UnparsedText\": \"G01 X10\", \"Msg\": { \"Text\": \"TOOL=5\" } } Constructors SiemensMsgSyntax() Initializes a new instance with default settings. public SiemensMsgSyntax() SiemensMsgSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public SiemensMsgSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensProcSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensProcSyntax.html",
    "title": "Class SiemensProcSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensProcSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Siemens Assembly HiMech.dll Consumes a Siemens PROC subprogram declaration header (PROC MY_SUB, PROC CONTOUR(REAL X, INT N) SAVE DISPLOF) whole into a block-root SiemensProc record. The header carries no executable state for the simulation — parameter binding to caller arguments is a later work item — but leaving it unparsed would shred the parameter list into ghost axis words the moment the tag-value syntaxes run, so the whole statement is owned here. The verbatim remainder after the name is preserved on Statement for cache-dump readers. Writes at the block root (no Parsing entry) following the SiemensDefStatementSyntax precedent — a record with no Logic consumer must not land in the UnconsumedCheckSyntax audit tree. Anchored at statement start: Sinumerik requires PROC to be the first statement of a subprogram file, so a mid-line PROC is left alone (visible unparsed warning). public class SiemensProcSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensProcSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Bare declaration: #BeforeBuild.UnparsedText: PROC MY_SUB #AfterBuild: { \"SiemensProc\": { \"Name\": \"MY_SUB\" } } Declaration with parameter list and attributes — remainder kept verbatim: #BeforeBuild.UnparsedText: PROC CONTOUR(REAL LENGTH, INT COUNT) SAVE DISPLOF #AfterBuild: { \"SiemensProc\": { \"Name\": \"CONTOUR\", \"Statement\": \"(REAL LENGTH, INT COUNT) SAVE DISPLOF\" } } Constructors SiemensProcSyntax() Parameterless instance (no XML state). public SiemensProcSyntax() SiemensProcSyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public SiemensProcSyntax(XElement src) Parameters src XElement Root element named XName. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensQuotedStatementSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensQuotedStatementSyntax.html",
    "title": "Class SiemensQuotedStatementSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensQuotedStatementSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Siemens Assembly HiMech.dll Quote guard: any line text still carrying a double quote after the literal-form consumers (SiemensMsgSyntax, SiemensToolCallSyntax, SiemensCycleCallSyntax) have run is quarantined whole into Parsing.QuotedStatement = { “Statement”: “<verbatim>” } — WRITE(ERROR,“CUTTIME”,“T5 X100”), string-concatenation MSG(\"...\"<<R1), quoted-argument cycles not yet whitelisted. Every quote-blind syntax below (flags, numbered flags, tag values, assignments) opens a token boundary at the quote→letter transition, so without this guard the string contents get minted into REAL parser state: \"G54\" inside a WRITE argument silently switches the active work offset, \"T5 X100\" mints a ghost tool call plus a ghost motion. Quarantining keeps the whole statement visible as one Parsing--Unconsumed entry (QuotedStatement.Statement) with zero state changes — the same deferred-not-corrupted contract as SiemensFrameStatementSyntax. Proper consumers (WRITE, CYCLE800 quoted args) replace this guard per statement family later. Trade-off, deliberate: on an exotic mixed block the guard also takes the co-resident plain words (a motion word sharing the block with an unconsumed quoted call goes into the quarantine too). Losing them is visible in the warning text; minting false state would be silent — never trade the first for the second. Corpus quoted statements (WRITE, non-literal MSG) are standalone blocks. public class SiemensQuotedStatementSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensQuotedStatementSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples WRITE with quoted arguments — quarantined whole; nothing reaches the tag-value syntaxes: #BeforeBuild.UnparsedText: WRITE(ERROR,“CUTTIME”,“T5 X100”) #AfterBuild: { \"Parsing\": { \"QuotedStatement\": { \"Statement\": \"WRITE(ERROR,\\\"CUTTIME\\\",\\\"T5 X100\\\")\" } } } Non-literal MSG (string concatenation) — the literal-form SiemensMsgSyntax deliberately skipped it, so the guard takes it: #BeforeBuild.UnparsedText: MSG(“G54 REACHED”<<R1) #AfterBuild: { \"Parsing\": { \"QuotedStatement\": { \"Statement\": \"MSG(\\\"G54 REACHED\\\"<<R1)\" } } } Constructors SiemensQuotedStatementSyntax() Initializes a new instance with default settings. public SiemensQuotedStatementSyntax() SiemensQuotedStatementSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public SiemensQuotedStatementSyntax(XElement src) Parameters src XElement Source XML element. Fields SectionKey Parsing key the quarantined statement is stored under. public const string SectionKey = \"QuotedStatement\" Field Value string StatementKey Sub-object key holding the verbatim statement text. public const string StatementKey = \"Statement\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensRepeatParsingSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensRepeatParsingSyntax.html",
    "title": "Class SiemensRepeatParsingSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensRepeatParsingSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Siemens Assembly HiMech.dll Captures a Siemens REPEAT statement whole into Parsing.SiemensRepeat: REPEAT LBL1 LBL0 → { “Start”: “LBL1”, “End”: “LBL0” }, with an optional trailing repetition count (P=3 or P3). The Evaluation consumer (SiemensRepeatSyntax) re-runs the label-bounded section. The single-label form (REPEAT LBL1 — repeat from the label back to the REPEAT line) is captured with End absent; the consumer currently warns it unsupported (corpus count: zero). Whole-statement owner, anchored at statement start — mixing REPEAT with other tokens on one block does not match and falls through whole to the visible unparsed warning. The end-label alternative refuses a P+digits word so REPEAT LBL1 P3 reads as start-label + count, not as an end label named P3. public class SiemensRepeatParsingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensRepeatParsingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples The corpus shape — two labels, no count: #BeforeBuild.UnparsedText: REPEAT LBL1 LBL0 #AfterBuild: { \"Parsing\": { \"SiemensRepeat\": { \"Start\": \"LBL1\", \"End\": \"LBL0\" } } } Two labels with a repetition count: #BeforeBuild.UnparsedText: REPEAT MARK_A MARK_B P=3 #AfterBuild: { \"Parsing\": { \"SiemensRepeat\": { \"Start\": \"MARK_A\", \"End\": \"MARK_B\", \"P\": 3 } } } Single-label form with a P-count — P3 is the count, not an end label: #BeforeBuild.UnparsedText: REPEAT LBL1 P3 #AfterBuild: { \"Parsing\": { \"SiemensRepeat\": { \"Start\": \"LBL1\", \"P\": 3 } } } Constructors SiemensRepeatParsingSyntax() Parameterless instance (no XML state). public SiemensRepeatParsingSyntax() SiemensRepeatParsingSyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public SiemensRepeatParsingSyntax(XElement src) Parameters src XElement Root element named XName. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensToolCallSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Siemens.SiemensToolCallSyntax.html",
    "title": "Class SiemensToolCallSyntax | HiAPI-C# 2025",
    "summary": "Class SiemensToolCallSyntax Namespace Hi.NcParsers.ParsingSyntaxs.Siemens Assembly HiMech.dll Consumes the Siemens string tool call T=“name” from the unparsed line text into Parsing.T as a string value (quotes stripped). Numeric concatenated calls (T5) stay with the preset's IntegerTagValueSyntax; ToolChangeSyntax accepts either shape. Must be placed before every tag-value syntax in the Parsing bundle: tool names routinely contain NC-shaped tokens (T=\"D16R3Z6\" — quote-blind consumers would mint ghost Parsing.D/Parsing.Z entries out of the name; (?<=[0-9]) and quote→letter \\b boundaries in RegexFlagPrefix both open inside the string). Same structural-consumption rationale as SiemensMsgSyntax. A second T=\"...\" behind a ; comment (T=\"M6LWXD-1301\";T=\"M6LWX\", real corpus shape) never reaches this syntax — the quote-aware TailCommentSyntax runs earlier and strips it. Tool names are matched verbatim, including non-ASCII bytes from legacy code pages. public class SiemensToolCallSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object SiemensToolCallSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples String tool name with embedded NC-shaped tokens — consumed whole, no ghost D/Z entries: #BeforeBuild.UnparsedText: T=“D16R3Z6” #AfterBuild: { \"Parsing\": { \"T\": \"D16R3Z6\" } } Mixed line — surrounding words stay for later syntaxes: #BeforeBuild.UnparsedText: T=“6V” M6 #AfterBuild: { \"UnparsedText\": \"M6\", \"Parsing\": { \"T\": \"6V\" } } Constructors SiemensToolCallSyntax() Initializes a new instance with default settings. public SiemensToolCallSyntax() SiemensToolCallSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public SiemensToolCallSyntax(XElement src) Parameters src XElement Source XML element. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.Siemens.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.Siemens.html",
    "title": "Namespace Hi.NcParsers.ParsingSyntaxs.Siemens | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.ParsingSyntaxs.Siemens Classes SiemensCallStatementSyntax Captures a whole-line Siemens subprogram-call statement into Parsing.SiemensCall for SiemensSubProgramCallSyntax to resolve (inline the file) or safe-skip (structured warning, zero motion). Two shapes are owned: Parenthesized call, any identifier — HQ_FC(1,50,75,160), L_39(0.000,0.000), HH_ROBOT(2) → { \"Name\": \"HQ_FC\", \"Args\": [\"1\",\"50\",…] }. The argument grammar (complete quoted runs admitted, quote-aware comma split) is SiemensCycleCallSyntax's, reused verbatim. Bare-word call — L9810, L_ZYM91, HH_ROBOTOFF, with an optional repeat count L123 P3 → { \"Name\": \"L123\", \"P\": 3 }. Restricted to L-leading or underscore-bearing identifiers on purpose: this syntax runs ahead of FlagSyntax and a generic bare-identifier capture would steal TRAORI-class words before their consumers ever saw them — the same underscore heuristic NamedIdentPattern blessed for assignments (corpus named entities all carry an underscore; controller vocabulary never does). On real Sinumerik any bare identifier can be a by-name call; widening further is a corpus-driven follow-up. Placement: last of the dedicated statement owners and still before SiemensQuotedStatementSyntax — quoted arguments must reach this capture (paired quotes ride inside the args body; a line whose quotes do not pair falls through whole to the quarantine). ExcludedNames keeps this catch-all from re-owning statements that belong elsewhere (default: WRITE stays with the quoted-statement quarantine; control-flow words are reserved for their future syntaxes). Whole-line anchored: a call mixed with other tokens (L9810 M8) does not match and stays visible in the unparsed warning. SiemensCycleCallSyntax Captures whitelisted Siemens cycle calls of the shape NAME(arg1,arg2,…) (or the bare NAME form) from the unparsed line text into a Parsing.NAME sub-object holding the verbatim positional argument strings: CYCLE832(0.05,_ORI_FINISH,0.8) → Parsing.CYCLE832 = { “Args”: [“0.05”, “_ORI_FINISH”, “0.8”] }. Empty slots (,,) stay as empty strings; NAME() yields an empty Args array; a bare NAME yields { “Bare”: true } (a marker — empty sub-objects would be swept by intermediate CleanupParsing calls before the consumer runs). A brand Logic syntax consumes the sub-object (e.g. SiemensPathSmoothingSyntax for CYCLE832, SiemensCycle800TiltSyntax for CYCLE800). Strictly whitelist-based (CycleNames, default CYCLE832 + CYCLE800) — a generic WORD(args) capture would eat OEM/unknown calls (HQ_FC(...), L_39(...)) whose safe-skip handling is a separate work item, and every unlisted call deliberately stays whole in UnparsedText for the visible UnparsedText--Remaining warning. Must be placed early in the Parsing bundle — before the assignment and tag-value syntaxes: argument tokens standing after ( or , (_ORI_FINISH, or axis-letter shapes like V1) would otherwise be shredded by NamedVarAssignmentSyntax / tag-value captures. Quoted arguments are supported for CYCLE800's swivel-data-record name (CYCLE800(1,\"TC1\",…)): the args body admits complete \"…\" runs (which may hide ) or ,) and the comma split is quote-aware; quotes are kept verbatim in the captured arg string so the consumer distinguishes \"0\" (name) from 0 (number). A line whose quotes do not pair falls through whole to SiemensQuotedStatementSyntax's quarantine. SiemensDefStatementSyntax Consumes Sinumerik variable declarations (DEF REAL _X_HOME=155.5, _SAFE_Z / DEF INT N_ST=3) and lowers each declared name into Parsing.Assignments: initialised names carry their initialiser expression text (the Evaluation bundle resolves and routes it into Vars.Named like any named assignment), bare names carry “0” — Sinumerik default-initialises numeric types to zero, so a later G0 Z=_SAFE_Z reads 0 instead of failing vacant. Must run before NamedVarAssignmentSyntax in the Parsing bundle: on a DEF line that syntax would capture _X_HOME=155.5 but strand DEF REAL (and the comma list) as unparsed residue. Initialiser expressions are delimited by the SiemensExpressionParser longest-valid-prefix rule, so parenthesised arithmetic and whitespace survive; a non-numeric type or unparsable initialiser leaves the whole statement untouched (visible as residue) rather than half-consuming it. BOOL/CHAR initialise to 0 like INT; STRING declarations are not lowered (string values have no numeric store) — the statement is consumed whole so it cannot shed ghost tokens. The declaration itself leaves no Parsing record: the lowered Assignments entries carry the entire semantic payload, and an inert record would only re-surface as an Unconsumed residue. SiemensFrameStatementSyntax Captures a whole Siemens frame statement (TRANS/ATRANS/ROT/AROT/ ROTS/AROTS/CROTS/SCALE/ASCALE/MIRROR/AMIRROR, bare or with arguments) into a Parsing.<keyword> sub-object. Sinumerik requires frame instructions in a block of their own, so the whole remaining line belongs to the statement. The consumed keywords (TRANS/ATRANS/ROT/AROT/ROTS/AROTS — see SiemensProgrammableFrameSyntax) are captured structured: each argument token becomes a sub-key — glued axis words (X0, Y90.) and equals forms (RPL=45, Z=R5) both supported. Literal values are stored as JSON numbers; non-literal right-hand sides stay strings so VariableEvaluatorSyntax resolves them in the Evaluation stage (AROT Z=R5 → Parsing.AROT = { \"Z\": \"R5\" }). A token outside the modeled grammar makes the whole statement fall back to the verbatim StatementKey capture — never a half-consumed line. The remaining keywords (CROTS/SCALE/ASCALE/MIRROR/AMIRROR — zero corpus occurrences, no simulation) keep the verbatim { \"Statement\": \"<args>\" } quarantine; the Logic consumer reports them as recognized-but-not-simulated. Either way the axis words are kept out of reach of the quote/context-blind tag-value syntaxes below, which would otherwise mint them into Parsing.X/Y/Z and let ProgramXyzSyntax turn a frame statement into a very real ghost rapid. Deferred-but-unmodeled must mean \"no transform yet\", never \"extra motion\". Must be placed early in the Parsing bundle — after BlockSkipSyntax, before every assignment / tag-value syntax (the ROT RPL=45 shape would otherwise feed NamedVarAssignmentSyntax). SiemensGotoParsingSyntax Captures Siemens GOTOF/GOTOB jump statements whole into Parsing.SiemensGoto. Four forms are recognised, mirroring the Fanuc phrase-level split (IF ... GOTO is one phrase, not an IF composed with a GOTO): GOTOF <label> / GOTOB <label> — unconditional forward / backward jump. IF <cond> GOTOF <label> / IF <cond> GOTOB <label> — the Sinumerik single-line conditional jump (no brackets around the condition). Placement: inside the whole-statement owner group, after SiemensRepeatParsingSyntax and before SiemensIfParsingSyntax — the IF-jump forms carry a strictly longer prefix than the block IF <cond> phrase, so this owner must win first (the block-IF owner also refuses GOTOF/GOTOB tails defensively). Must run before the assignment syntaxes: IF R1==1 GOTOF LBL1 would otherwise be shredded by the assignment capture (its LHS grammar matches R1 and the first = of ==). The label is captured as written (LBL1, MARKE_A, or an N<num> block number — both are legal Sinumerik jump targets). The condition string is left for VariableEvaluatorSyntax's pass-2 tree walk; SiemensGotoSyntax consumes the section. SiemensIfParsingSyntax Captures the Siemens block-conditional phrases whole into Parsing.SiemensIf: IF <cond> (no brackets on Sinumerik), ELSE, ENDIF. The single-line jump form (IF <cond> GOTOF <label>) belongs to SiemensGotoParsingSyntax, which runs immediately before this owner; a GOTOF/GOTOB tail is additionally refused here so an ordering drift degrades to a visible unparsed warning instead of a silently mis-captured block-IF (the Fanuc (?!GOTO\\b) precedent). Placement: whole-statement owner group, before the assignment syntaxes — a condition like R1==1 would otherwise be shredded by the assignment capture (LHS grammar matches R1 plus the first =). The condition string is left for VariableEvaluatorSyntax's pass-2 walk; SiemensIfSyntax consumes the section and decides the branch. SiemensLabelSyntax Consumes a Siemens label at block start (LBL1: — identifier followed by a colon, optionally after the N head index) into a block-root SiemensLabel record. Labels are passive jump targets: in the normal flow the record is pure bookkeeping (no motion, no state), while SiemensRepeatSyntax uses this same syntax as its LabelScanUtil probe and matches candidates on SiemensLabel.Name. Writing the record at the block root (not under Parsing) keeps the passive token out of UnconsumedCheckSyntax's audit without needing a Logic-layer consumer — mirroring how SiemensDefStatementSyntax leaves no Parsing.Def entry behind. Anchored at the start of the remaining unparsed text, so a label buried mid-line is not captured (Sinumerik allows one label per block, at block start). Text after the colon stays in UnparsedText for the rest of the pipeline — LBL1: G1 X0 executes its trailing motion normally. The probe usage requires this syntax to stay self-sufficient: it reads only UnparsedText and never touches the dependency list. SiemensLoopParsingSyntax Captures the Siemens loop-construct phrases whole, one Parsing section per construct family: WHILE <cond> / ENDWHILE → Parsing.SiemensWhile. FOR <var> = <start> TO <end> / ENDFOR → Parsing.SiemensFor. The start expression is stored as a single-entry Init map keyed by the variable name — the evaluator's pass-2 tree walk rewrites values only, never keys, so the loop variable's name survives even when it collides with a set named variable. Literal start/end bounds are written as numeric JSON values directly (writer decides the node type); expressions stay strings for the evaluator. bare REPEAT / UNTIL <cond> → Parsing.SiemensRepeatUntil. Only the label-less form is taken — REPEAT LBL1 ... is the P4 section repeat owned by SiemensRepeatParsingSyntax, which runs earlier in the statement group. LOOP / ENDLOOP → Parsing.SiemensLoop. Placement: whole-statement owner group, after SiemensGotoParsingSyntax / SiemensIfParsingSyntax and before the assignment syntaxes — FOR R1=0 TO 10 would otherwise be shredded by the assignment capture (R1=0 is a legal assignment shape and the TO 10 tail strands). SiemensLoopSyntax consumes all four sections against its shared loop-frame stack. SiemensMcallSyntax Captures a Siemens MCALL modal-call statement whole into a Parsing.MCALL sub-object: MCALL CYCLE81(500.,327.9137,0.5,324.564,,,0,1,0) → { “CycleName”: “CYCLE81”, “Args”: [\"500.\", …] }; a bare MCALL (modal cancel) → { “Bare”: true }; a parenthesis-less callee (MCALL L123) keeps CycleName without Args. The Logic consumer (SiemensModalCycleSyntax) maps the supported CYCLE8x family onto the shared canned-cycle modal machinery and warns on everything else. Whole-statement owner: MCALL lines are standalone in the corpus, and owning the full statement keeps the cycle's positional arguments away from the assignment / tag-value syntaxes (same shredding hazard as SiemensCycleCallSyntax, whose argument grammar — including complete quoted runs — is reused verbatim). Must run before SiemensCycleCallSyntax: a whitelisted cycle name after MCALL would otherwise be captured bare-of-context and strand the MCALLL word. A line mixing MCALL with other tokens does not match and falls through whole to the visible unparsed warning. SiemensMsgSyntax Consumes a Siemens MSG(“text”) operator display call (or the bare MSG() clear form) from the unparsed line text into a block-root Msg section, and surfaces the text as a Msg–Display system message. Must be placed before every assignment / tag-value / flag syntax in the Parsing bundle (right after TailCommentSyntax / BlockSkipSyntax): the quoted argument routinely contains NC-shaped tokens (MSG(\"TOOL=5\"), MSG(\"G54 OK\"), MSG(\"T20 R8.000 CR:2.500\")) which the quote-blind consumers downstream would otherwise shred into ghost assignments, flags, or axis words. Consuming the whole call here removes that hazard structurally — the planned fix recorded on NcSyntaxUtil's assignment RHS-boundary notes. Only the two literal forms are consumed: MSG(\"...\") and MSG(). Non-literal arguments (string concatenation MSG(\"A\"<<R1), variable interpolation) are deliberately left whole in UnparsedText for the visible UnparsedText--Remaining warning — half-eating them would silently lose content. SiemensProcSyntax Consumes a Siemens PROC subprogram declaration header (PROC MY_SUB, PROC CONTOUR(REAL X, INT N) SAVE DISPLOF) whole into a block-root SiemensProc record. The header carries no executable state for the simulation — parameter binding to caller arguments is a later work item — but leaving it unparsed would shred the parameter list into ghost axis words the moment the tag-value syntaxes run, so the whole statement is owned here. The verbatim remainder after the name is preserved on Statement for cache-dump readers. Writes at the block root (no Parsing entry) following the SiemensDefStatementSyntax precedent — a record with no Logic consumer must not land in the UnconsumedCheckSyntax audit tree. Anchored at statement start: Sinumerik requires PROC to be the first statement of a subprogram file, so a mid-line PROC is left alone (visible unparsed warning). SiemensQuotedStatementSyntax Quote guard: any line text still carrying a double quote after the literal-form consumers (SiemensMsgSyntax, SiemensToolCallSyntax, SiemensCycleCallSyntax) have run is quarantined whole into Parsing.QuotedStatement = { “Statement”: “<verbatim>” } — WRITE(ERROR,“CUTTIME”,“T5 X100”), string-concatenation MSG(\"...\"<<R1), quoted-argument cycles not yet whitelisted. Every quote-blind syntax below (flags, numbered flags, tag values, assignments) opens a token boundary at the quote→letter transition, so without this guard the string contents get minted into REAL parser state: \"G54\" inside a WRITE argument silently switches the active work offset, \"T5 X100\" mints a ghost tool call plus a ghost motion. Quarantining keeps the whole statement visible as one Parsing--Unconsumed entry (QuotedStatement.Statement) with zero state changes — the same deferred-not-corrupted contract as SiemensFrameStatementSyntax. Proper consumers (WRITE, CYCLE800 quoted args) replace this guard per statement family later. Trade-off, deliberate: on an exotic mixed block the guard also takes the co-resident plain words (a motion word sharing the block with an unconsumed quoted call goes into the quarantine too). Losing them is visible in the warning text; minting false state would be silent — never trade the first for the second. Corpus quoted statements (WRITE, non-literal MSG) are standalone blocks. SiemensRepeatParsingSyntax Captures a Siemens REPEAT statement whole into Parsing.SiemensRepeat: REPEAT LBL1 LBL0 → { “Start”: “LBL1”, “End”: “LBL0” }, with an optional trailing repetition count (P=3 or P3). The Evaluation consumer (SiemensRepeatSyntax) re-runs the label-bounded section. The single-label form (REPEAT LBL1 — repeat from the label back to the REPEAT line) is captured with End absent; the consumer currently warns it unsupported (corpus count: zero). Whole-statement owner, anchored at statement start — mixing REPEAT with other tokens on one block does not match and falls through whole to the visible unparsed warning. The end-label alternative refuses a P+digits word so REPEAT LBL1 P3 reads as start-label + count, not as an end label named P3. SiemensToolCallSyntax Consumes the Siemens string tool call T=“name” from the unparsed line text into Parsing.T as a string value (quotes stripped). Numeric concatenated calls (T5) stay with the preset's IntegerTagValueSyntax; ToolChangeSyntax accepts either shape. Must be placed before every tag-value syntax in the Parsing bundle: tool names routinely contain NC-shaped tokens (T=\"D16R3Z6\" — quote-blind consumers would mint ghost Parsing.D/Parsing.Z entries out of the name; (?<=[0-9]) and quote→letter \\b boundaries in RegexFlagPrefix both open inside the string). Same structural-consumption rationale as SiemensMsgSyntax. A second T=\"...\" behind a ; comment (T=\"M6LWXD-1301\";T=\"M6LWX\", real corpus shape) never reaches this syntax — the quote-aware TailCommentSyntax runs earlier and strips it. Tool names are matched verbatim, including non-ASCII bytes from legacy code pages."
  },
  "api/Hi.NcParsers.ParsingSyntaxs.TagAssignmentSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.TagAssignmentSyntax.html",
    "title": "Class TagAssignmentSyntax | HiAPI-C# 2025",
    "summary": "Class TagAssignmentSyntax Namespace Hi.NcParsers.ParsingSyntaxs Assembly HiMech.dll Assignment syntax with = sign. Unlike TagValueSyntax which handles concatenated tag-value pairs (no = sign), this class handles explicit assignment statements. public class TagAssignmentSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object TagAssignmentSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Derived HeidenhainFnAssignmentSyntax Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild.UnparsedText: #100=5.0 (Fanuc, VarPrefix=\"#\", TagList=[]) #AfterBuild: { \"Parsing\": { \"Assignments\": { \"#100\": \"5.0\" } } } #BeforeBuild.UnparsedText: R1=100.5 (Siemens, VarPrefix=“R”, TagList=[]) #AfterBuild: { \"Parsing\": { \"Assignments\": { \"R1\": \"100.5\" } } } #BeforeBuild.UnparsedText: R1=5 _A=6 (mixed line — R1's RHS stops at the next assignment-looking token; the named assignment is left for NamedVarAssignmentSyntax) #AfterBuild: { \"UnparsedText\": \"_A=6\", \"Parsing\": { \"Assignments\": { \"R1\": \"5\" } } } Remarks Fanuc: #1 = 100, #100 = [#1 + #2] Siemens: R1 = 100, R1 = R2 + R3 Heidenhain: via derived HeidenhainFnAssignmentSyntax which adds FN prefix handling Wraps GrabTagAssignment(ref string, IEnumerable<string>, string, IEnumerable<string>, ExpressionPrefixParser) as an INcSyntax. Captures only the numbered {prefix}{digits} family; symbolic identifiers (e.g. _X_HOME) are the job of NamedVarAssignmentSyntax, whose broader identifier grammar also matches letter+digits tokens such as R1. That overlap is benign by construction: both route to the same Parsing.Assignments subtree with the same JSON shape (Assignments.<tag> = \"<expr>\"), share the same RHS boundary rule, and a preset must give both the same TerminateWords — so a token captured by either lands identically and the two syntaxes' relative order does not affect output. A controller with only numbered variables (Fanuc #) uses this syntax alone; NamedVarAssignmentSyntax cannot capture #-prefixed tokens. Constructors TagAssignmentSyntax(IEnumerable<string>, IEnumerable<string>, string, IEnumerable<string>) Creates an assignment syntax. Pass null for categoryPath to use DefaultCategoryPath (Parsing.Assignments). Pass an empty collection only if assignments should land at the Parsing root. public TagAssignmentSyntax(IEnumerable<string> categoryPath, IEnumerable<string> tags, string varPrefix, IEnumerable<string> terminateWords = null) Parameters categoryPath IEnumerable<string> tags IEnumerable<string> varPrefix string terminateWords IEnumerable<string> TagAssignmentSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public TagAssignmentSyntax(XElement src) Parameters src XElement Source XML element. Fields AssignmentsKey Parsing sub-object key holding captured assignments — the shared landing spot of TagAssignmentSyntax, NamedVarAssignmentSyntax and SiemensDefStatementSyntax, and the read surface of the Evaluation-stage variable readers. public const string AssignmentsKey = \"Assignments\" Field Value string Properties CategoryPath JSON path under Parsing where matched assignments are written. public List<string> CategoryPath { get; set; } Property Value List<string> DefaultCategoryPath Default CategoryPath assigned when the caller passes null (or omits the <CategoryPath> element in saved XML). Routes assignment outputs into Parsing.Assignments so that variable-reading syntaxes can target a single well-defined subtree. public static IReadOnlyList<string> DefaultCategoryPath { get; } Property Value IReadOnlyList<string> Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string RhsDialect Expression grammar delimiting the RHS (parser-delimited capture): when set, the longest valid expression prefix ends the RHS — superseding TerminateWords on matches where a prefix parses — so spaced arithmetic and a following non-expression word split correctly. Default None keeps the legacy lexical boundary. Presets that set this on one assignment syntax must set it on NamedVarAssignmentSyntax too (the P0 behavior-alignment contract). public NcExpressionDialect RhsDialect { get; set; } Property Value NcExpressionDialect TagList Numeric tag suffixes accepted (e.g. 1, 100) when paired with VarPrefix. public List<string> TagList { get; set; } Property Value List<string> TerminateWords Optional keywords that terminate the right-hand expression so the remainder is left in UnparsedText. public List<string> TerminateWords { get; set; } Property Value List<string> VarPrefix Variable prefix (e.g. #, R, Q) preceding the numeric tag. public string VarPrefix { get; set; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public virtual XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToAssignmentJsonNode(string) Converts an assignment expression string to a JsonNode. Override in derived classes for typed parsing. protected virtual JsonNode ToAssignmentJsonNode(string setup) Parameters setup string Returns JsonNode TryStripPrefix(ref string) Strips a brand-specific prefix from unparsedText before assignment parsing. Returns false to signal no match (skip this syntax). Base implementation does nothing (no prefix required). protected virtual bool TryStripPrefix(ref string unparsedText) Parameters unparsedText string Returns bool"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.TagValueSyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.TagValueSyntax.html",
    "title": "Class TagValueSyntax | HiAPI-C# 2025",
    "summary": "Class TagValueSyntax Namespace Hi.NcParsers.ParsingSyntaxs Assembly HiMech.dll Concatenated tag-value syntax (no = sign), glued by default. ex. Heidenhain: L X+Q2 Y33.4 FQ1 ISO: X100.3Y3.3 With AllowEqualsForm also the Siemens address=value form: Siemens: X=100 Z=R63+150 With AllowSpacedValue also the detached spelling: Heidenhain: L Z-22.5 F 20000 A word that occurs twice on one block keeps its FIRST value in the scalar slot; the later occurrences are listed under RepeatedWordsKey for a consumer that gives them a meaning (the Mazak dual tool word T10 T2 M06 — see ToolChangeSyntax). This is HardNc's first-match grab; a last-wins overwrite would load the pre-selected tool instead of the called one. public class TagValueSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object TagValueSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Derived FloatTagValueSyntax IntegerTagValueSyntax Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild.UnparsedText: G01 X100.3Y3.3 (with TagList=[“X”,“Y”,“Z”], VariableTag=\"#\") #AfterBuild: { \"UnparsedText\": \"G01\", \"Parsing\": { \"X\": \"100.3\", \"Y\": \"3.3\" } } #BeforeBuild.UnparsedText: X=100 Y50 (same TagList, with AllowEqualsForm=true — Siemens address=value and concatenated forms mix on one block) #AfterBuild: { \"Parsing\": { \"X\": \"100\", \"Y\": \"50\" } } #BeforeBuild.UnparsedText: T10 T2 M06 (with TagList=[“T”] — the dual tool word: the first T is the tool M06 loads, the second is pre-selected; the scalar keeps the first, the repeat is listed) #AfterBuild: { \"UnparsedText\": \"M06\", \"Parsing\": { \"T\": \"10\", \"RepeatedWords\": { \"T\": [\"2\"] } } } Constructors TagValueSyntax(IEnumerable<string>, IEnumerable<string>, string) Initializes a new instance with the given category path, tag list, and variable-tag pattern. public TagValueSyntax(IEnumerable<string> categoryPath, IEnumerable<string> tags, string variableTag) Parameters categoryPath IEnumerable<string> JSON path under Parsing where matches are written. tags IEnumerable<string> Single-letter tag names whose values are grabbed. variableTag string Regex/literal recognizing a variable reference as a value. TagValueSyntax(XElement) Initializes a new instance by deserializing from the given XML element. public TagValueSyntax(XElement src) Parameters src XElement Source XML element. Properties AllowEqualsForm When true, also accepts the Siemens address=value form (X=100, Z=R63+150, F=R103) via GrabTagEqualsValue(ref string, IEnumerable<string>, ExpressionPrefixParser), in addition to the concatenated form. Default false — Fanuc/ISO/Heidenhain presets keep the concatenated-only grammar. public bool AllowEqualsForm { get; set; } Property Value bool AllowSpacedValue When true, whitespace may separate a tag from its value (F 20000 — the Heidenhain detached feed word; a real post family writes 103 such lines in one file). The value grammar must still match right after the whitespace run, so F MAX or F X+10 stay unclaimed. Default false — every other brand keeps the glued-only grammar. public bool AllowSpacedValue { get; set; } Property Value bool CategoryPath JSON path under Parsing where matched tag-values are written. public List<string> CategoryPath { get; set; } Property Value List<string> Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string RhsDialect Expression grammar delimiting the equals-form RHS (parser-delimited capture): the longest valid expression prefix after = is the value, so spaced arithmetic (Z=R63 + 150) and balanced call parentheses survive while a glued following word stays unparsed. Default None keeps the legacy non-whitespace-run capture. Only meaningful with AllowEqualsForm. public NcExpressionDialect RhsDialect { get; set; } Property Value NcExpressionDialect TagList Single-letter tag names whose values are grabbed (e.g. X, Y, Z, F). public List<string> TagList { get; set; } Property Value List<string> VariableTag Regex (or literal) that recognizes a variable reference token (e.g. Q2, #1, [#1+#2]) as the value of a tag. public string VariableTag { get; set; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public virtual XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToValueJsonNode(string) Converts a tag setup string value to a JsonNode. Override in derived classes for typed parsing (int, double). Variable text (e.g. Q2, #1, [#1+#2]) is kept as string. protected virtual JsonNode ToValueJsonNode(string setup) Parameters setup string Returns JsonNode"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.TapeBoundarySyntax.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.TapeBoundarySyntax.html",
    "title": "Class TapeBoundarySyntax | HiAPI-C# 2025",
    "summary": "Class TapeBoundarySyntax Namespace Hi.NcParsers.ParsingSyntaxs Assembly HiMech.dll Detects the % tape leader / trailer at the start of a block and records it under TapeBoundary on the block JSON. Universal across ISO controllers (Fanuc, Mazak, Syntec, Siemens) — a brand's program-identifier header (e.g. Fanuc O1234) is a separate concern handled by its own brand-specific syntax. public class TapeBoundarySyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object TapeBoundarySyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild.UnparsedText: % #AfterBuild: { \"TapeBoundary\": { \"Text\": \"\" } } #BeforeBuild.UnparsedText: %foo #AfterBuild: { \"TapeBoundary\": { \"Text\": \"foo\" } } #BeforeBuild.UnparsedText: % header text #AfterBuild: { \"TapeBoundary\": { \"Text\": \"header text\" } } Constructors TapeBoundarySyntax() Parameterless instance for bundle composition (no XML state). public TapeBoundarySyntax() TapeBoundarySyntax(XElement) XML ctor (no child elements; reserved for forward compatibility). public TapeBoundarySyntax(XElement src) Parameters src XElement Root element named XName. Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress IsPreviousNodeTapeBoundary(LazyLinkedListNode<SyntaxPiece>) Returns true if the previous block carries a TapeBoundary section, or if there is no previous block at all (start-of-stream is itself a tape boundary). Brand-specific program-identifier syntaxes use this to decide whether the current block can host a program-number header. public static bool IsPreviousNodeTapeBoundary(LazyLinkedListNode<SyntaxPiece> node) Parameters node LazyLinkedListNode<SyntaxPiece> Returns bool MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.ParsingSyntaxs.html": {
    "href": "api/Hi.NcParsers.ParsingSyntaxs.html",
    "title": "Namespace Hi.NcParsers.ParsingSyntaxs | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.ParsingSyntaxs Classes BlockSkipSyntax Parses the ISO 6983 / Fanuc Block Delete (a.k.a. Block Skip) prefix / or /N (N = 1..9) at the head of an NC block. Behaviour: No leading / → no-op, no BlockSkip section is written. / with IBlockSkipConfig layer OFF (or the dependency absent) → prefix is consumed, BlockSkip Symbol/Layer recorded for audit, Body stays null; the rest of the block stays in UnparsedText and parses normally. / with layer ON → the remaining block text is moved from UnparsedText into Body and UnparsedText is cleared. Downstream parsing syntaxes see no NC text so they emit nothing; semantics therefore produce no act. Must run after comment / CsScript syntaxes so that comments (and CsScript embedded in comments) continue to take effect regardless of the skip switch. CsScriptSyntax Extracts C# script markers from the oral content of a comment. PreMarker marks a script that runs before the NC block; PostMarker marks a script that runs after. The symbols are configurable and serialized to XML. FlagSyntax Syntax of fully Match flag. FloatTagValueSyntax TagValueSyntax that parses numeric literal values to double. Variable text (e.g. Q2, #1, [#1+#2]) remains as string. HeadIndexSyntax Parses a leading block index (e.g. Heidenhain line numbers) after an optional HeadSymbol prefix. IntegerTagValueSyntax TagValueSyntax that parses numeric literal values to int. Variable text (e.g. Q2, #1, [#1+#2]) remains as string. NamedVarAssignmentSyntax Assignment syntax for named (identifier-style) variables with = sign. Handles variables that are multi-character identifiers rather than {prefix}{digits}. NumberedFlagSyntax Syntax for numbered flags (prefix + number) with optional decimal support. NumberedFlagSyntax often should place after something like ParameterizedFlagSyntax. Since NumberedFlagSyntax is easy to eat those kind of flags. Single-digit integer codes are zero-padded to canonical 2-digit form (e.g. M6 → M06, G0 → G00, M3 → M03) so that downstream logic syntaxes comparing against IsoKeywords constants (which are always 2-digit form like M06) can match Fanuc-style omitted-leading-zero codes. Two-digit and decimal codes are kept as-is. ParameterizedFlagSyntax Syntax for flags with attached parameters (e.g., G54.1P1, G10L2P1). This is essentially a combination of main flag matching (like NumberedFlagSyntax) plus scoped TagValueSyntax for the parameters after the main flag. Note that the ParameterizedFlagSyntax often should be applied before NumberedFlagSyntax since NumberedFlagSyntax may eat the text that ParameterizedFlagSyntax should handle. ShrinkIfNoDecimalPointSyntax Applies the “conventional type” decimal-point interpretation to coordinate values in UnparsedText. When a tag value has no decimal point (e.g. Y20), it is shrunk by the implied decimal places: Y20 → Y0.020 (3 decimal places). Values that already contain a decimal point are left unchanged. Place inside BundleSyntax before FloatTagValueSyntax so the modified text is parsed correctly by subsequent syntaxes. TagAssignmentSyntax Assignment syntax with = sign. Unlike TagValueSyntax which handles concatenated tag-value pairs (no = sign), this class handles explicit assignment statements. TagValueSyntax Concatenated tag-value syntax (no = sign), glued by default. ex. Heidenhain: L X+Q2 Y33.4 FQ1 ISO: X100.3Y3.3 With AllowEqualsForm also the Siemens address=value form: Siemens: X=100 Z=R63+150 With AllowSpacedValue also the detached spelling: Heidenhain: L Z-22.5 F 20000 A word that occurs twice on one block keeps its FIRST value in the scalar slot; the later occurrences are listed under RepeatedWordsKey for a consumer that gives them a meaning (the Mazak dual tool word T10 T2 M06 — see ToolChangeSyntax). This is HardNc's first-match grab; a last-wins overwrite would load the pre-selected tool instead of the called one. TapeBoundarySyntax Detects the % tape leader / trailer at the start of a block and records it under TapeBoundary on the block JSON. Universal across ISO controllers (Fanuc, Mazak, Syntec, Siemens) — a brand's program-identifier header (e.g. Fanuc O1234) is a separate concern handled by its own brand-specific syntax."
  },
  "api/Hi.NcParsers.PostLogicSyntaxs.ModalCarrySyntax.html": {
    "href": "api/Hi.NcParsers.PostLogicSyntaxs.ModalCarrySyntax.html",
    "title": "Class ModalCarrySyntax | HiAPI-C# 2025",
    "summary": "Class ModalCarrySyntax Namespace Hi.NcParsers.PostLogicSyntaxs Assembly HiMech.dll Per-block modal-section carry. For each key in TrackedKeys, if the current block has no section for that key, deep-clone the same section from the immediately previous block (which is itself guaranteed to carry it because every block is processed by this syntax) and set AddedByKey = AddedByValue inside the cloned section. For each key in MergeKeys, a block that DID write its own (partial) section additionally receives the previous block's remaining entries — the block's own values win, only missing keys are filled — so a partially-written modal section (e.g. an XYZ-only motion block's MachineCoordinateState, which lacks the rotary axes) does not break the carry chain for the keys it did not write. Lets every block stand alone with its full modal context, so downstream readers (cache-file dumps, semantics, UI jumping to a single block) do not need EnumerateBack() to resolve modal state. A JSON section is a candidate for TrackedKeys when ALL four criteria hold: Writers concentrated — one or two syntaxes own the section (e.g. LinearMotionSyntax / CircularMotionSyntax own MotionState; the call/return pair own SubProgramCall-derived state). Readers distributed — multiple downstream consumers each need the value, and none of them should walk back to find it. Single-reader sections do not benefit from blanket carry. Every block must see the section — cache-dump readers landing randomly, single-block UI views, and look-ahead syntaxes all require the section to be present on every block. Carry is unconditional — no frame-gating or other per-block veto. Sections that need conditional carry (e.g. FanucLocalVariableReadingSyntax's frame-aware Vars.Local dict-merge — carry only when MacroFrame matches) belong in the owning syntax's own carry logic, not here. A section failing any criterion should be carried through its owning syntax's own logic (single-step node.Previous read, or no carry at all if absence is meaningful — e.g. MacroFrame absent = main frame). This replaces the earlier CacheSyntax design (which sampled every Pace blocks). The legacy CacheSyntax XName is still recognised on load for backward compatibility with previously-saved project files. public class ModalCarrySyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object ModalCarrySyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ModalCarrySyntax() Creates an empty ModalCarrySyntax; populate TrackedKeys before use. public ModalCarrySyntax() ModalCarrySyntax(XElement) Reconstructs a ModalCarrySyntax from a project XML element previously produced by MakeXmlSource(string, string, bool). public ModalCarrySyntax(XElement src) Parameters src XElement XML element carrying a TrackedKeys child with one Key per entry; null is treated as defaults. Fields AddedByValue Value written under AddedByKey on each section this syntax deep-clones from the previous block. Mirrors AddedByValue's role for its own synthesis — both let cache-file readers distinguish post-Logic / Inspection stage injections from LogicSyntaxs-stage authored values (the latter have no AddedByKey). public const string AddedByValue = \"ModalCarry\" Field Value string Properties Default Full-set carrier (Logic ∪ PostLogic) — retained for the legacy backstop in SoftNcRunner that appends a single ModalCarry to pre-3.1.168 project syntax lists. New brand syntax kits should split into Logic + PostLogic instead. public static ModalCarrySyntax Default { get; } Property Value ModalCarrySyntax Logic Logic-stage carrier — modal sections that are written in the Logic bundle and never mutated by PostLogic. Carrying these at the end of each block's Logic bundle keeps single-step node.Previous modal lookups from Logic syntaxes correct, even when a PostLogic syntax (e.g. RadiusCompensationSyntax) does node.Next look-forward and drags subsequent blocks' Logic builds forward before the intermediate block's PostLogic ModalCarry has run. public static ModalCarrySyntax Logic { get; } Property Value ModalCarrySyntax MergeKeys Section keys whose carry is per-KEY, not just per-section: when the current block already has the section, entries it did not write are filled from the previous block's section (own values win; AddedByKey is never copied as data). Opt-in and deliberately separate from TrackedKeys — stack-like sections (CallStack, WhileFrames) must NOT be merged: a popped frame would be resurrected. Today only MachineCoordinateState qualifies: its writers are per-axis (an XYZ motion block writes only X/Y/Z), and without the merge the modal rotary values die at every partially-written section, forcing downstream modal lookbacks into unbounded EnumerateBack() walks (progress-dependent slowdown once executed pieces freeze). public List<string> MergeKeys { get; set; } Property Value List<string> Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string PostLogic PostLogic-stage carrier — modal sections that may still be mutated by PostLogic syntaxes after Logic completes. Today only MachineCoordinateState qualifies (overwritten by RadiusCompensationSyntax with the radius-compensated position). Carrying these at the end of PostLogic ensures the modal value reflects the final, post-compensation state. public static ModalCarrySyntax PostLogic { get; } Property Value ModalCarrySyntax TrackedKeys Section keys to carry. Order-insensitive; duplicates ignored. public List<string> TrackedKeys { get; set; } Property Value List<string> XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> node, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters node LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.PostLogicSyntaxs.RadiusCompensationSyntax.html": {
    "href": "api/Hi.NcParsers.PostLogicSyntaxs.RadiusCompensationSyntax.html",
    "title": "Class RadiusCompensationSyntax | HiAPI-C# 2025",
    "summary": "Class RadiusCompensationSyntax Namespace Hi.NcParsers.PostLogicSyntaxs Assembly HiMech.dll Resolves cutter radius compensation (G41/G42/G40) by offsetting the tool path perpendicular to the programmed direction. Must be placed after motion syntaxes (CircularMotionSyntax, LinearMotionSyntax) because it reads the Hi.Motion section. Must NOT be placed inside BundleSyntax because it requires look-forward (Next). For simple cases (line-line, no transient), the syntax overwrites MachineCoordinate with the offset position. For arc blocks that need transient bridging segments, the Motion section is replaced with a CompoundMotion containing sub-items. public class RadiusCompensationSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object RadiusCompensationSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Cartesian G41 begin block (tool radius 5 via the D1 offset row): no intersection — the position offsets perpendicular to the segment, left of travel (+X move → +Y), and the compensated machine coordinate plus the motion-section MotionProgramXyz are written: #Previous: { \"MachineCoordinateState\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } } #BeforeBuild: { \"Parsing\": { \"G41\": { \"D\": 1 } }, \"ProgramXyz\": { \"X\": 10, \"Y\": 0, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\" } } #AfterBuild: { \"ProgramXyz\": { \"X\": 10, \"Y\": 0, \"Z\": 0 }, \"MotionEvent\": { \"Form\": \"McLinear\", \"MotionProgramXyz\": { \"X\": 10, \"Y\": 5, \"Z\": 0 } }, \"RadiusCompensation\": { \"Side\": \"Left\", \"Term\": \"G41\", \"OffsetId\": 1, \"Radius_mm\": 5 }, \"MachineCoordinateState\": { \"X\": 10, \"Y\": 5, \"Z\": 0 } } Polar continuation with parallel rays (the G12.1 branch): the compensated central position offsets left of the +C travel (−5 on the radius axis), ProgramPolarRxcz stays NOMINAL, and the machine coordinate is re-derived from the compensated central — radius √(35²+20²), C chained from the previous (compensated) angle: #Previous: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"ProgramPolarRxcz\": { \"X\": 40, \"Y\": 10, \"Z\": 0 }, \"RadiusCompensation\": { \"Side\": \"Left\", \"Term\": \"G41\", \"OffsetId\": 1, \"Radius_mm\": 5 }, \"CompensatedCentral\": { \"X\": 35, \"Y\": 10, \"Z\": 0 }, \"MachineCoordinateState\": { \"C\": 15.945395900922854, \"X\": 36.40054944640259, \"Y\": 0, \"Z\": 0 } } #BeforeBuild: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"ProgramPolarRxcz\": { \"X\": 40, \"Y\": 20, \"Z\": 0 }, \"ProgramXyz\": { \"X\": 44.721359549995796, \"Y\": 0, \"Z\": 0 }, \"MachineCoordinateState\": { \"C\": 26.565051177077986, \"X\": 44.721359549995796, \"Y\": 0, \"Z\": 0 }, \"MotionState\": { \"Term\": \"G01\" }, \"MotionEvent\": { \"Form\": \"McPolarLinear\" } } #AfterBuild: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"ProgramPolarRxcz\": { \"X\": 40, \"Y\": 20, \"Z\": 0 }, \"ProgramXyz\": { \"X\": 44.721359549995796, \"Y\": 0, \"Z\": 0 }, \"MachineCoordinateState\": { \"C\": 29.744881296942225, \"X\": 40.311288741492746, \"Y\": 0, \"Z\": 0 }, \"MotionState\": { \"Term\": \"G01\" }, \"MotionEvent\": { \"Form\": \"McPolarLinear\" }, \"RadiusCompensation\": { \"Side\": \"Left\", \"Term\": \"G41\", \"OffsetId\": 1, \"Radius_mm\": 5 }, \"CompensatedCentral\": { \"X\": 35, \"Y\": 20, \"Z\": 0 } } A bare G40 inside polar mode inherits the previous block's (compensated) machine coordinate — the Cartesian McLinear on it is the modal fallthrough, not real motion, so it counts as bare: #Previous: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"ProgramPolarRxcz\": { \"X\": 40, \"Y\": 20, \"Z\": 0 }, \"RadiusCompensation\": { \"Side\": \"Left\", \"Term\": \"G41\", \"OffsetId\": 1, \"Radius_mm\": 5 }, \"MachineCoordinateState\": { \"C\": 29.744881296942225, \"X\": 40.311288741492746, \"Y\": 0, \"Z\": 0 } } #BeforeBuild: { \"Parsing\": { \"Flags\": [\"G40\"] }, \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"ProgramPolarRxcz\": { \"X\": 40, \"Y\": 20, \"Z\": 0 }, \"MachineCoordinateState\": { \"C\": 26.565051177077986, \"X\": 44.721359549995796, \"Y\": 0, \"Z\": 0 }, \"MotionState\": { \"Term\": \"G01\" }, \"MotionEvent\": { \"Form\": \"McLinear\" } } #AfterBuild: { \"PolarInterpolationState\": { \"Dir\": \"XC\", \"InitRxcz\": { \"X\": 0, \"Y\": 0, \"Z\": 0 } }, \"ProgramPolarRxcz\": { \"X\": 40, \"Y\": 20, \"Z\": 0 }, \"MachineCoordinateState\": { \"C\": 29.744881296942225, \"X\": 40.311288741492746, \"Y\": 0, \"Z\": 0 }, \"MotionState\": { \"Term\": \"G01\" }, \"MotionEvent\": { \"Form\": \"McLinear\" }, \"RadiusCompensation\": { \"Side\": \"None\", \"Term\": \"G40\", \"OffsetId\": 1 } } The first block after a program end — #Previous: carries the ProgramEnd section next to a still-active G41 D1. This is the reset edge (ProgramEndSyntax): the controller's reset cancels cutter compensation, so the block is written cancelled (G40) instead of inheriting G41; the modal D row is kept, as it is across an explicit G40: #Previous: { \"ProgramEnd\": { \"Term\": \"M02\" }, \"RadiusCompensation\": { \"Side\": \"Left\", \"Term\": \"G41\", \"OffsetId\": 1, \"Radius_mm\": 5 } } #BeforeBuild: {} #AfterBuild: { \"RadiusCompensation\": { \"Side\": \"None\", \"Term\": \"G40\", \"OffsetId\": 1 } } Constructors RadiusCompensationSyntax() Creates a default RadiusCompensationSyntax. public RadiusCompensationSyntax() RadiusCompensationSyntax(XElement) Reconstructs a RadiusCompensationSyntax from a project XML element previously produced by MakeXmlSource(string, string, bool). The element carries no fields, so src is used only for factory dispatch. public RadiusCompensationSyntax(XElement src) Parameters src XElement XML element previously produced by MakeXmlSource(string, string, bool). Fields ArcBeginProgramXyzKey JSON key for the arc begin program position inside CompoundMotion arc items. public const string ArcBeginProgramXyzKey = \"ArcBeginProgramXyz\" Field Value string MotionProgramXyzKey JSON key for the compensated program position inside Motion sections and CompoundMotion arc items. public const string MotionProgramXyzKey = \"MotionProgramXyz\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.PostLogicSyntaxs.html": {
    "href": "api/Hi.NcParsers.PostLogicSyntaxs.html",
    "title": "Namespace Hi.NcParsers.PostLogicSyntaxs | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.PostLogicSyntaxs Classes ModalCarrySyntax Per-block modal-section carry. For each key in TrackedKeys, if the current block has no section for that key, deep-clone the same section from the immediately previous block (which is itself guaranteed to carry it because every block is processed by this syntax) and set AddedByKey = AddedByValue inside the cloned section. For each key in MergeKeys, a block that DID write its own (partial) section additionally receives the previous block's remaining entries — the block's own values win, only missing keys are filled — so a partially-written modal section (e.g. an XYZ-only motion block's MachineCoordinateState, which lacks the rotary axes) does not break the carry chain for the keys it did not write. Lets every block stand alone with its full modal context, so downstream readers (cache-file dumps, semantics, UI jumping to a single block) do not need EnumerateBack() to resolve modal state. A JSON section is a candidate for TrackedKeys when ALL four criteria hold: Writers concentrated — one or two syntaxes own the section (e.g. LinearMotionSyntax / CircularMotionSyntax own MotionState; the call/return pair own SubProgramCall-derived state). Readers distributed — multiple downstream consumers each need the value, and none of them should walk back to find it. Single-reader sections do not benefit from blanket carry. Every block must see the section — cache-dump readers landing randomly, single-block UI views, and look-ahead syntaxes all require the section to be present on every block. Carry is unconditional — no frame-gating or other per-block veto. Sections that need conditional carry (e.g. FanucLocalVariableReadingSyntax's frame-aware Vars.Local dict-merge — carry only when MacroFrame matches) belong in the owning syntax's own carry logic, not here. A section failing any criterion should be carried through its owning syntax's own logic (single-step node.Previous read, or no carry at all if absence is meaningful — e.g. MacroFrame absent = main frame). This replaces the earlier CacheSyntax design (which sampled every Pace blocks). The legacy CacheSyntax XName is still recognised on load for backward compatibility with previously-saved project files. RadiusCompensationSyntax Resolves cutter radius compensation (G41/G42/G40) by offsetting the tool path perpendicular to the programmed direction. Must be placed after motion syntaxes (CircularMotionSyntax, LinearMotionSyntax) because it reads the Hi.Motion section. Must NOT be placed inside BundleSyntax because it requires look-forward (Next). For simple cases (line-line, no transient), the syntax overwrites MachineCoordinate with the offset position. For arc blocks that need transient bridging segments, the Motion section is replaced with a CompoundMotion containing sub-items."
  },
  "api/Hi.NcParsers.Segmenters.HeidenhainSegmenter.html": {
    "href": "api/Hi.NcParsers.Segmenters.HeidenhainSegmenter.html",
    "title": "Class HeidenhainSegmenter | HiAPI-C# 2025",
    "summary": "Class HeidenhainSegmenter Namespace Hi.NcParsers.Segmenters Assembly HiMech.dll Heidenhain NC block builder. Also support single line NC block. Two grouping rules produce multi-line Sentences: Trailing ~ continuation (modern TNC cycle definitions): a line whose last visible character is ~ continues on the next physical line; the chain ends at the first line without a trailing ~. Both corpus spellings are accepted — \"… ;STRATEGIE ~\" (space before, after a trailing comment) and \"DATUM SETTING~\" (glued). Continuation lines carry no klartext block number. Configurable via JoinTildeContinuations (default on — files using ~ are simply mis-simulated without it, so legacy XML without the attribute also gets the join). Repeated command head (Hi.NcParsers.Segmenters.HeidenhainSegmenter.BlockKeywordList, default CYCL DEF): consecutive lines sharing the same CYCL DEF n head group into one sentence (7.0/7.1/… style). The ~ characters stay in the raw BlockText (write-back authority); the Parsing bundle strips them from UnparsedText via HeidenhainTildeTrimSyntax. public class HeidenhainSegmenter : ISegmenter, IToXElement Inheritance object HeidenhainSegmenter Implements ISegmenter IToXElement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainSegmenter() Creates a HeidenhainSegmenter with the default block-keyword list. public HeidenhainSegmenter() Properties JoinTildeContinuations Joins lines ending with the TNC ~ continuation character into one sentence. On by default; an XML source without the attribute also defaults to on — the join is a capability fix (house.H-style cycle definitions are unparsable without it), not a behavioral contract a legacy project could depend on. public bool JoinTildeContinuations { get; set; } Property Value bool Name Display name of this segmenter. public string Name { get; } Property Value string XName XML element name used to register and serialize this segmenter. public static string XName { get; } Property Value string Methods GetSentences(LazyLinkedList<IndexedFileLine>, List<INcDependency>, NcDiagnosticProgress) Segments the indexed file lines into Sentences. public IEnumerable<Sentence> GetSentences(LazyLinkedList<IndexedFileLine> indexedFileLines, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters indexedFileLines LazyLinkedList<IndexedFileLine> The lazy linked list of indexed file lines. ncDependencyList List<INcDependency> Dependency list of the owning runner; segmenters that consume header rows (e.g. CsvSegmenter) read host-wired dependencies from here. May be null in lightweight test fixtures — implementations that need a dependency must null-check. ncDiagnosticProgress NcDiagnosticProgress Diagnostic progress reporter. Returns IEnumerable<Sentence> A sequence of Sentences. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.NcParsers.Segmenters.ISegmenter.html": {
    "href": "api/Hi.NcParsers.Segmenters.ISegmenter.html",
    "title": "Interface ISegmenter | HiAPI-C# 2025",
    "summary": "Interface ISegmenter Namespace Hi.NcParsers.Segmenters Assembly HiMech.dll Interface to segment IndexedFileLines into Sentences. public interface ISegmenter : IToXElement Inherited Members IToXElement.ToXElement() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Name Display name of this segmenter. string Name { get; } Property Value string Methods GetSentences(LazyLinkedList<IndexedFileLine>, List<INcDependency>, NcDiagnosticProgress) Segments the indexed file lines into Sentences. IEnumerable<Sentence> GetSentences(LazyLinkedList<IndexedFileLine> indexedFileLines, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters indexedFileLines LazyLinkedList<IndexedFileLine> The lazy linked list of indexed file lines. ncDependencyList List<INcDependency> Dependency list of the owning runner; segmenters that consume header rows (e.g. CsvSegmenter) read host-wired dependencies from here. May be null in lightweight test fixtures — implementations that need a dependency must null-check. ncDiagnosticProgress NcDiagnosticProgress Diagnostic progress reporter. Returns IEnumerable<Sentence> A sequence of Sentences."
  },
  "api/Hi.NcParsers.Segmenters.InlineDelimiterSegmenter.html": {
    "href": "api/Hi.NcParsers.Segmenters.InlineDelimiterSegmenter.html",
    "title": "Class InlineDelimiterSegmenter | HiAPI-C# 2025",
    "summary": "Class InlineDelimiterSegmenter Namespace Hi.NcParsers.Segmenters Assembly HiMech.dll Segments NC lines by an inline delimiter (e.g. ';'). A line containing the delimiter produces multiple Sentences, each with a precise FileLineCharIndexSegment. Lines without the delimiter produce a single Sentence. public class InlineDelimiterSegmenter : ISegmenter, IToXElement Inheritance object InlineDelimiterSegmenter Implements ISegmenter IToXElement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors InlineDelimiterSegmenter() Creates an InlineDelimiterSegmenter using DefaultDelimiter. public InlineDelimiterSegmenter() InlineDelimiterSegmenter(char) Creates an InlineDelimiterSegmenter with a custom delimiter character. public InlineDelimiterSegmenter(char delimiter) Parameters delimiter char Fields DefaultDelimiter Default delimiter: ';'. public static readonly char DefaultDelimiter Field Value char Properties Delimiter The inline delimiter character. public char Delimiter { get; } Property Value char Name Display name of this segmenter. public string Name { get; } Property Value string XName XML element name used to register and serialize this segmenter. public static string XName { get; } Property Value string Methods GetSentences(LazyLinkedList<IndexedFileLine>, List<INcDependency>, NcDiagnosticProgress) Segments the indexed file lines into Sentences. public IEnumerable<Sentence> GetSentences(LazyLinkedList<IndexedFileLine> indexedFileLines, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters indexedFileLines LazyLinkedList<IndexedFileLine> The lazy linked list of indexed file lines. ncDependencyList List<INcDependency> Dependency list of the owning runner; segmenters that consume header rows (e.g. CsvSegmenter) read host-wired dependencies from here. May be null in lightweight test fixtures — implementations that need a dependency must null-check. ncDiagnosticProgress NcDiagnosticProgress Diagnostic progress reporter. Returns IEnumerable<Sentence> A sequence of Sentences. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.NcParsers.Segmenters.SingleLineSegmenter.html": {
    "href": "api/Hi.NcParsers.Segmenters.SingleLineSegmenter.html",
    "title": "Class SingleLineSegmenter | HiAPI-C# 2025",
    "summary": "Class SingleLineSegmenter Namespace Hi.NcParsers.Segmenters Assembly HiMech.dll Maps each physical source line to one Sentence (no multi-line merging). public class SingleLineSegmenter : ISegmenter, IToXElement Inheritance object SingleLineSegmenter Implements ISegmenter IToXElement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Name Display name of this segmenter. public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods GetSentences(LazyLinkedList<IndexedFileLine>, List<INcDependency>, NcDiagnosticProgress) Segments the indexed file lines into Sentences. public IEnumerable<Sentence> GetSentences(LazyLinkedList<IndexedFileLine> indexedFileLines, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters indexedFileLines LazyLinkedList<IndexedFileLine> The lazy linked list of indexed file lines. ncDependencyList List<INcDependency> Dependency list of the owning runner; segmenters that consume header rows (e.g. CsvSegmenter) read host-wired dependencies from here. May be null in lightweight test fixtures — implementations that need a dependency must null-check. ncDiagnosticProgress NcDiagnosticProgress Diagnostic progress reporter. Returns IEnumerable<Sentence> A sequence of Sentences. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.NcParsers.Segmenters.html": {
    "href": "api/Hi.NcParsers.Segmenters.html",
    "title": "Namespace Hi.NcParsers.Segmenters | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.Segmenters Classes HeidenhainSegmenter Heidenhain NC block builder. Also support single line NC block. Two grouping rules produce multi-line Sentences: Trailing ~ continuation (modern TNC cycle definitions): a line whose last visible character is ~ continues on the next physical line; the chain ends at the first line without a trailing ~. Both corpus spellings are accepted — \"… ;STRATEGIE ~\" (space before, after a trailing comment) and \"DATUM SETTING~\" (glued). Continuation lines carry no klartext block number. Configurable via JoinTildeContinuations (default on — files using ~ are simply mis-simulated without it, so legacy XML without the attribute also gets the join). Repeated command head (Hi.NcParsers.Segmenters.HeidenhainSegmenter.BlockKeywordList, default CYCL DEF): consecutive lines sharing the same CYCL DEF n head group into one sentence (7.0/7.1/… style). The ~ characters stay in the raw BlockText (write-back authority); the Parsing bundle strips them from UnparsedText via HeidenhainTildeTrimSyntax. InlineDelimiterSegmenter Segments NC lines by an inline delimiter (e.g. ';'). A line containing the delimiter produces multiple Sentences, each with a precise FileLineCharIndexSegment. Lines without the delimiter produce a single Sentence. SingleLineSegmenter Maps each physical source line to one Sentence (no multi-line merging). Interfaces ISegmenter Interface to segment IndexedFileLines into Sentences."
  },
  "api/Hi.NcParsers.Semantics.ClLinearMcMotionSemantic.html": {
    "href": "api/Hi.NcParsers.Semantics.ClLinearMcMotionSemantic.html",
    "title": "Class ClLinearMcMotionSemantic | HiAPI-C# 2025",
    "summary": "Class ClLinearMcMotionSemantic Namespace Hi.NcParsers.Semantics Assembly HiMech.dll Resolves ClLinear motion into CL-level linear interpolation with per-step inverse kinematics. Used when RTCP (G43.4/TRAORI/M128) is active and rotary axes change, producing ActClLinearMcXyzabcContour. The CL (cutter location) endpoints are derived from MC endpoints via forward kinematics, then interpolated linearly. The MC path is non-linear because the tool orientation changes during the move. public class ClLinearMcMotionSemantic : INcSemantic, IMakeXmlSource Inheritance object ClLinearMcMotionSemantic Implements INcSemantic IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public string DisplayName { get; } Property Value string XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. public IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.NcParsers.Semantics.CompoundMotionSemantic.html": {
    "href": "api/Hi.NcParsers.Semantics.CompoundMotionSemantic.html",
    "title": "Class CompoundMotionSemantic | HiAPI-C# 2025",
    "summary": "Class CompoundMotionSemantic Namespace Hi.NcParsers.Semantics Assembly HiMech.dll Resolves ICompoundMotionDef into acts by delegating ItemsKey to ResolveItems(JsonArray, LazyLinkedListNode<SyntaxPiece>, DVec3d, IRapidFeedrateConfig, NcDiagnosticProgress, IMachineAxisConfig, IMachineKinematics). public class CompoundMotionSemantic : INcSemantic, IMakeXmlSource Inheritance object CompoundMotionSemantic Implements INcSemantic IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public string DisplayName { get; } Property Value string XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. public IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.NcParsers.Semantics.CoolantSemantic.html": {
    "href": "api/Hi.NcParsers.Semantics.CoolantSemantic.html",
    "title": "Class CoolantSemantic | HiAPI-C# 2025",
    "summary": "Class CoolantSemantic Namespace Hi.NcParsers.Semantics Assembly HiMech.dll Resolves the ICoolantDef JSON section (written by CoolantSyntax from M07/M08/M09) into an ActCooling act. Only emits when the coolant mode changes from the previous block — modal state is suppressed so downstream consumers (e.g. StateActRunner) see one act per real transition rather than one per block. public class CoolantSemantic : INcSemantic, IMakeXmlSource Inheritance object CoolantSemantic Implements INcSemantic IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public string DisplayName { get; } Property Value string XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. public IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.NcParsers.Semantics.CsScriptBeginSemantic.html": {
    "href": "api/Hi.NcParsers.Semantics.CsScriptBeginSemantic.html",
    "title": "Class CsScriptBeginSemantic | HiAPI-C# 2025",
    "summary": "Class CsScriptBeginSemantic Namespace Hi.NcParsers.Semantics Assembly HiMech.dll Resolves BeginScript into ActLineCsScript. Must be placed at the beginning of NcSemanticList so that the script runs before motion and other acts. public class CsScriptBeginSemantic : CsScriptSemantic, INcSemantic, IMakeXmlSource Inheritance object CsScriptSemantic CsScriptBeginSemantic Implements INcSemantic IMakeXmlSource Inherited Members CsScriptSemantic.ExternalScripts CsScriptSemantic.Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public override string DisplayName { get; } Property Value string ScriptKey JSON property key on the CsScript section to read for this semantic (typically BeginScript or EndScript). protected override string ScriptKey { get; } Property Value string XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public override XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Semantics.CsScriptEndSemantic.html": {
    "href": "api/Hi.NcParsers.Semantics.CsScriptEndSemantic.html",
    "title": "Class CsScriptEndSemantic | HiAPI-C# 2025",
    "summary": "Class CsScriptEndSemantic Namespace Hi.NcParsers.Semantics Assembly HiMech.dll Resolves EndScript into ActLineCsScript. Must be placed at the end of NcSemanticList so that the script runs after motion and other acts. public class CsScriptEndSemantic : CsScriptSemantic, INcSemantic, IMakeXmlSource Inheritance object CsScriptSemantic CsScriptEndSemantic Implements INcSemantic IMakeXmlSource Inherited Members CsScriptSemantic.ExternalScripts CsScriptSemantic.Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public override string DisplayName { get; } Property Value string ScriptKey JSON property key on the CsScript section to read for this semantic (typically BeginScript or EndScript). protected override string ScriptKey { get; } Property Value string XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public override XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Semantics.CsScriptSemantic.html": {
    "href": "api/Hi.NcParsers.Semantics.CsScriptSemantic.html",
    "title": "Class CsScriptSemantic | HiAPI-C# 2025",
    "summary": "Class CsScriptSemantic Namespace Hi.NcParsers.Semantics Assembly HiMech.dll Base class for resolving CsScript JSON entries into ActLineCsScript. Subclasses specify which script key to read (BeginScript or EndScript). Also supports an external script dictionary via ExternalScripts. When set, each NC block's FileLineIndex is looked up in the dictionary and the matched script is emitted as an additional ActLineCsScript. This allows runtime injection of per-line scripts without modifying the NC file. public abstract class CsScriptSemantic : INcSemantic, IMakeXmlSource Inheritance object CsScriptSemantic Implements INcSemantic IMakeXmlSource Derived CsScriptBeginSemantic CsScriptEndSemantic Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public abstract string DisplayName { get; } Property Value string ExternalScripts Optional external script source keyed by FileLineIndex. Set at session start to inject per-line scripts without editing NC files. The Func is evaluated each resolve call so the dictionary can be modified at runtime. public Func<Dictionary<FileLineIndex, string>> ExternalScripts { get; set; } Property Value Func<Dictionary<FileLineIndex, string>> ScriptKey JSON property key on the CsScript section to read for this semantic (typically BeginScript or EndScript). protected abstract string ScriptKey { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public abstract XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. public IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.NcParsers.Semantics.INcSemantic.html": {
    "href": "api/Hi.NcParsers.Semantics.INcSemantic.html",
    "title": "Interface INcSemantic | HiAPI-C# 2025",
    "summary": "Interface INcSemantic Namespace Hi.NcParsers.Semantics Assembly HiMech.dll Resolves SyntaxPiece into IAct sequence. Unlike INcSyntax which only transforms data in-place, INcSemantic produces machine actions from the parsed syntax data. public interface INcSemantic : IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. string DisplayName { get; } Property Value string Methods Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.NcParsers.Semantics.MachineCoordinateStepSemantic.html": {
    "href": "api/Hi.NcParsers.Semantics.MachineCoordinateStepSemantic.html",
    "title": "Class MachineCoordinateStepSemantic | HiAPI-C# 2025",
    "summary": "Class MachineCoordinateStepSemantic Namespace Hi.NcParsers.Semantics Assembly HiMech.dll Read MachineCoordinate from MachineCoordinateState in JsonObject and produce ActMcXyzStep. Requires ProgramXyzSyntax to have computed McXyz first. public class MachineCoordinateStepSemantic : INcSemantic, IMakeXmlSource Inheritance object MachineCoordinateStepSemantic Implements INcSemantic IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public string DisplayName { get; } Property Value string XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. public IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.NcParsers.Semantics.McArcMotionSemantic.html": {
    "href": "api/Hi.NcParsers.Semantics.McArcMotionSemantic.html",
    "title": "Class McArcMotionSemantic | HiAPI-C# 2025",
    "summary": "Class McArcMotionSemantic Namespace Hi.NcParsers.Semantics Assembly HiMech.dll Resolves McArc motion into ActFeedrate + ActMcXyzSpiralContour. Reads arc center, plane normal, and direction from the Hi.Motion section written by CircularMotionSyntax. public class McArcMotionSemantic : INcSemantic, IMakeXmlSource Inheritance object McArcMotionSemantic Implements INcSemantic IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public string DisplayName { get; } Property Value string XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. public IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.NcParsers.Semantics.McLinearMotionSemantic.html": {
    "href": "api/Hi.NcParsers.Semantics.McLinearMotionSemantic.html",
    "title": "Class McLinearMotionSemantic | HiAPI-C# 2025",
    "summary": "Class McLinearMotionSemantic Namespace Hi.NcParsers.Semantics Assembly HiMech.dll Resolves McLinear motion into ActFeedrate/ActRapid + ActMcXyzLinearContour or ActMcXyzabcLinearContour. Discriminates by whether the block's rotary state actually CHANGED from the previous modal state (HasRotaryMotion(DVec3d, DVec3d, LazyLinkedListNode<SyntaxPiece>) — value comparison, not key presence: MergeKeys completes every motion block's MachineCoordinateState with carried modal rotary values, so key presence no longer means the block moved a rotary axis): rotary unchanged → ActMcXyzLinearContour rotary moved → ActMcXyzabcLinearContour with Fanuc composite feedrate: d = √(ΔX² + ΔY² + ΔZ² + ΔA_deg² + ΔB_deg² + ΔC_deg²) public class McLinearMotionSemantic : INcSemantic, IMakeXmlSource Inheritance object McLinearMotionSemantic Implements INcSemantic IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public string DisplayName { get; } Property Value string XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. public IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.NcParsers.Semantics.McPolarArcMotionSemantic.html": {
    "href": "api/Hi.NcParsers.Semantics.McPolarArcMotionSemantic.html",
    "title": "Class McPolarArcMotionSemantic | HiAPI-C# 2025",
    "summary": "Class McPolarArcMotionSemantic Namespace Hi.NcParsers.Semantics Assembly HiMech.dll Resolves McPolarArc motion into ActFeedrate + ActMcPolarSpiralContour. The arc geometry (center, direction, additional circles) was resolved by ProgramRxczSyntax on the polar hypothetical plane in central (anchor-origin) coordinates; this semantic computes the plane arc length via ActMcPolarSpiralContour's shared spiral derivative, takes duration = length / feedrate (mirroring HardNc NcProc.GetActSpiralMcXyzContour), and emits the polar spiral act whose per-step polar→machine conversion chains the C-axis branch. When RadiusCompensationSyntax compensated the block (marked by CompensatedEndCentral in the motion section), the act structure mirrors HardNc NcProc.GetActsFromArcCommand: an optional ActMcPolarLinearContour bridge onto the offset circle (transient begin), the spiral between the compensated endpoints around the NOMINAL center, and an optional bridge off it (transient end) — the polar twin of HardNc GetActMcContourByLinearProgramPos. public class McPolarArcMotionSemantic : INcSemantic, IMakeXmlSource Inheritance object McPolarArcMotionSemantic Implements INcSemantic IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public string DisplayName { get; } Property Value string XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. public IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.NcParsers.Semantics.McPolarLinearMotionSemantic.html": {
    "href": "api/Hi.NcParsers.Semantics.McPolarLinearMotionSemantic.html",
    "title": "Class McPolarLinearMotionSemantic | HiAPI-C# 2025",
    "summary": "Class McPolarLinearMotionSemantic Namespace Hi.NcParsers.Semantics Assembly HiMech.dll Resolves McPolarLinear motion into ActFeedrate + ActMcPolarLinearContour. Reads the anchor-relative polar positions written by ProgramRxczSyntax (begin from the previous block, end from the current block) and hands the central (anchor-origin) pair to the act, mirroring HardNc NcProc.GetActMcPolarLinearContour. Duration mirrors HardNc GetTimeCostByPolarLinearContour, including the C-axis speed clamp on the hypothetical component — the ceiling comes from the rotary rate bucket (IRapidFeedrateConfig), the same number the legacy import fills from HardNcEnv's MaxRotarySpeedABC. Rapid polar events (G00 while G12.1 is active — disallowed by Fanuc and warned at parse time) resolve to no act, matching HardNc. public class McPolarLinearMotionSemantic : INcSemantic, IMakeXmlSource Inheritance object McPolarLinearMotionSemantic Implements INcSemantic IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public string DisplayName { get; } Property Value string XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. public IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.NcParsers.Semantics.SpindleSpeedSemantic.html": {
    "href": "api/Hi.NcParsers.Semantics.SpindleSpeedSemantic.html",
    "title": "Class SpindleSpeedSemantic | HiAPI-C# 2025",
    "summary": "Class SpindleSpeedSemantic Namespace Hi.NcParsers.Semantics Assembly HiMech.dll Resolves ISpindleSpeedDef section into ActSpindleSpeed and ActSpindleDirection. Only emits when spindle speed or direction actually changes from the previous block. public class SpindleSpeedSemantic : INcSemantic, IMakeXmlSource Inheritance object SpindleSpeedSemantic Implements INcSemantic IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public string DisplayName { get; } Property Value string XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. public IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.NcParsers.Semantics.StrokeLimitCheckSemantic.html": {
    "href": "api/Hi.NcParsers.Semantics.StrokeLimitCheckSemantic.html",
    "title": "Class StrokeLimitCheckSemantic | HiAPI-C# 2025",
    "summary": "Class StrokeLimitCheckSemantic Namespace Hi.NcParsers.Semantics Assembly HiMech.dll Reports a diagnostic error when MachineCoordinateState exceeds the stroke limits defined in IStrokeLimitConfig. Does not emit any IAct; only produces diagnostics. public class StrokeLimitCheckSemantic : INcSemantic, IMakeXmlSource Inheritance object StrokeLimitCheckSemantic Implements INcSemantic IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public string DisplayName { get; } Property Value string XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. public IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.NcParsers.Semantics.ToolChangeSemantic.html": {
    "href": "api/Hi.NcParsers.Semantics.ToolChangeSemantic.html",
    "title": "Class ToolChangeSemantic | HiAPI-C# 2025",
    "summary": "Class ToolChangeSemantic Namespace Hi.NcParsers.Semantics Assembly HiMech.dll Resolves SectionName section into ActToolingStep when a change trigger is present (IsChangeKey = true); a T-code-only (pre-selection) block produces no act — magazine pre-rotation is PLC work with no axis or spindle effect. The axis travel to the tooling position is NOT emitted here: ToolChangeMotionSyntax stamps it as a CompoundMotion at the syntax stage, and this semantic is ordered after CompoundMotionSemantic so the ActToolingStep lands at the tooling position. Reads ToolingTime for the change duration. A string ToolId (Siemens T=\"name\" call) is resolved to a tool number through FindToolNumberByName(string) — the act chain (ActToolingStep, tool-house lookup) is int-keyed. An unresolvable name emits a ToolChange--NameUnresolved warning and produces no act. public class ToolChangeSemantic : INcSemantic, IMakeXmlSource Inheritance object ToolChangeSemantic Implements INcSemantic IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public string DisplayName { get; } Property Value string XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. public IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.NcParsers.Semantics.ToolingTeleportSemantic.html": {
    "href": "api/Hi.NcParsers.Semantics.ToolingTeleportSemantic.html",
    "title": "Class ToolingTeleportSemantic | HiAPI-C# 2025",
    "summary": "Class ToolingTeleportSemantic Namespace Hi.NcParsers.Semantics Assembly HiMech.dll Resolves the SectionName section into ActToolingTeleport: the tool is equipped without the machining-step operation (collision detection, volume removal) that ToolChangeSemantic's ActToolingStep runs at the chain's current pose. For pipelines whose source carries no machine tool-change position: in CSV (recorded telemetry) the tool jumps to its recorded position rather than running a modelled tool-changer cycle; in CLSF the cutter-location stream has no machine coordinates at all, and a step would stamp a cut at the not-yet-positioned device pose (identity = the workpiece program zero). Fires only when IsChangeKey is set (the block's tool id differs from the previous one), so a long run of same-tool blocks emits a single teleport. public class ToolingTeleportSemantic : INcSemantic, IMakeXmlSource Inheritance object ToolingTeleportSemantic Implements INcSemantic IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public string DisplayName { get; } Property Value string XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. public IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.NcParsers.Semantics.html": {
    "href": "api/Hi.NcParsers.Semantics.html",
    "title": "Namespace Hi.NcParsers.Semantics | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.Semantics Classes ClLinearMcMotionSemantic Resolves ClLinear motion into CL-level linear interpolation with per-step inverse kinematics. Used when RTCP (G43.4/TRAORI/M128) is active and rotary axes change, producing ActClLinearMcXyzabcContour. The CL (cutter location) endpoints are derived from MC endpoints via forward kinematics, then interpolated linearly. The MC path is non-linear because the tool orientation changes during the move. CompoundMotionSemantic Resolves ICompoundMotionDef into acts by delegating ItemsKey to ResolveItems(JsonArray, LazyLinkedListNode<SyntaxPiece>, DVec3d, IRapidFeedrateConfig, NcDiagnosticProgress, IMachineAxisConfig, IMachineKinematics). CoolantSemantic Resolves the ICoolantDef JSON section (written by CoolantSyntax from M07/M08/M09) into an ActCooling act. Only emits when the coolant mode changes from the previous block — modal state is suppressed so downstream consumers (e.g. StateActRunner) see one act per real transition rather than one per block. CsScriptBeginSemantic Resolves BeginScript into ActLineCsScript. Must be placed at the beginning of NcSemanticList so that the script runs before motion and other acts. CsScriptEndSemantic Resolves EndScript into ActLineCsScript. Must be placed at the end of NcSemanticList so that the script runs after motion and other acts. CsScriptSemantic Base class for resolving CsScript JSON entries into ActLineCsScript. Subclasses specify which script key to read (BeginScript or EndScript). Also supports an external script dictionary via ExternalScripts. When set, each NC block's FileLineIndex is looked up in the dictionary and the matched script is emitted as an additional ActLineCsScript. This allows runtime injection of per-line scripts without modifying the NC file. MachineCoordinateStepSemantic Read MachineCoordinate from MachineCoordinateState in JsonObject and produce ActMcXyzStep. Requires ProgramXyzSyntax to have computed McXyz first. McArcMotionSemantic Resolves McArc motion into ActFeedrate + ActMcXyzSpiralContour. Reads arc center, plane normal, and direction from the Hi.Motion section written by CircularMotionSyntax. McLinearMotionSemantic Resolves McLinear motion into ActFeedrate/ActRapid + ActMcXyzLinearContour or ActMcXyzabcLinearContour. Discriminates by whether the block's rotary state actually CHANGED from the previous modal state (HasRotaryMotion(DVec3d, DVec3d, LazyLinkedListNode<SyntaxPiece>) — value comparison, not key presence: MergeKeys completes every motion block's MachineCoordinateState with carried modal rotary values, so key presence no longer means the block moved a rotary axis): rotary unchanged → ActMcXyzLinearContour rotary moved → ActMcXyzabcLinearContour with Fanuc composite feedrate: d = √(ΔX² + ΔY² + ΔZ² + ΔA_deg² + ΔB_deg² + ΔC_deg²) McPolarArcMotionSemantic Resolves McPolarArc motion into ActFeedrate + ActMcPolarSpiralContour. The arc geometry (center, direction, additional circles) was resolved by ProgramRxczSyntax on the polar hypothetical plane in central (anchor-origin) coordinates; this semantic computes the plane arc length via ActMcPolarSpiralContour's shared spiral derivative, takes duration = length / feedrate (mirroring HardNc NcProc.GetActSpiralMcXyzContour), and emits the polar spiral act whose per-step polar→machine conversion chains the C-axis branch. When RadiusCompensationSyntax compensated the block (marked by CompensatedEndCentral in the motion section), the act structure mirrors HardNc NcProc.GetActsFromArcCommand: an optional ActMcPolarLinearContour bridge onto the offset circle (transient begin), the spiral between the compensated endpoints around the NOMINAL center, and an optional bridge off it (transient end) — the polar twin of HardNc GetActMcContourByLinearProgramPos. McPolarLinearMotionSemantic Resolves McPolarLinear motion into ActFeedrate + ActMcPolarLinearContour. Reads the anchor-relative polar positions written by ProgramRxczSyntax (begin from the previous block, end from the current block) and hands the central (anchor-origin) pair to the act, mirroring HardNc NcProc.GetActMcPolarLinearContour. Duration mirrors HardNc GetTimeCostByPolarLinearContour, including the C-axis speed clamp on the hypothetical component — the ceiling comes from the rotary rate bucket (IRapidFeedrateConfig), the same number the legacy import fills from HardNcEnv's MaxRotarySpeedABC. Rapid polar events (G00 while G12.1 is active — disallowed by Fanuc and warned at parse time) resolve to no act, matching HardNc. SpindleSpeedSemantic Resolves ISpindleSpeedDef section into ActSpindleSpeed and ActSpindleDirection. Only emits when spindle speed or direction actually changes from the previous block. StrokeLimitCheckSemantic Reports a diagnostic error when MachineCoordinateState exceeds the stroke limits defined in IStrokeLimitConfig. Does not emit any IAct; only produces diagnostics. ToolChangeSemantic Resolves SectionName section into ActToolingStep when a change trigger is present (IsChangeKey = true); a T-code-only (pre-selection) block produces no act — magazine pre-rotation is PLC work with no axis or spindle effect. The axis travel to the tooling position is NOT emitted here: ToolChangeMotionSyntax stamps it as a CompoundMotion at the syntax stage, and this semantic is ordered after CompoundMotionSemantic so the ActToolingStep lands at the tooling position. Reads ToolingTime for the change duration. A string ToolId (Siemens T=\"name\" call) is resolved to a tool number through FindToolNumberByName(string) — the act chain (ActToolingStep, tool-house lookup) is int-keyed. An unresolvable name emits a ToolChange--NameUnresolved warning and produces no act. ToolingTeleportSemantic Resolves the SectionName section into ActToolingTeleport: the tool is equipped without the machining-step operation (collision detection, volume removal) that ToolChangeSemantic's ActToolingStep runs at the chain's current pose. For pipelines whose source carries no machine tool-change position: in CSV (recorded telemetry) the tool jumps to its recorded position rather than running a modelled tool-changer cycle; in CLSF the cutter-location stream has no machine coordinates at all, and a step would stamp a cut at the not-yet-positioned device pose (identity = the workpiece program zero). Fires only when IsChangeKey is set (the block's tool id differs from the previous one), so a long run of same-tool blocks emits a single teleport. Interfaces INcSemantic Resolves SyntaxPiece into IAct sequence. Unlike INcSyntax which only transforms data in-place, INcSemantic produces machine actions from the parsed syntax data."
  },
  "api/Hi.NcParsers.Sentence.html": {
    "href": "api/Hi.NcParsers.Sentence.html",
    "title": "Class Sentence | HiAPI-C# 2025",
    "summary": "Class Sentence Namespace Hi.NcParsers Assembly HiMech.dll A small NC block for one or several lines. public class Sentence : IGetSentence Inheritance object Sentence Implements IGetSentence Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Sentence(IndexedFileLine) Creates a Sentence from a single IndexedFileLine. public Sentence(IndexedFileLine indexedFileLine) Parameters indexedFileLine IndexedFileLine Sentence(List<IndexedFileLine>) Creates a Sentence from multiple IndexedFileLines. [Obsolete(\"Use the (blockText, charSegment, filePath) constructor.\")] public Sentence(List<IndexedFileLine> indexedFileLineList) Parameters indexedFileLineList List<IndexedFileLine> Sentence(string, FileLineCharIndexSegment, string) Initializes a new instance of the Sentence class. public Sentence(string blockText, FileLineCharIndexSegment charIndexSegment, string filePath = null) Parameters blockText string The source text of this block. charIndexSegment FileLineCharIndexSegment The character-level segment [Begin, End). filePath string The file path of the source file. Properties BlockText The source text of this block. May contain line breaks for multi-line blocks. public string BlockText { get; } Property Value string CharIndexSegment Character-level segment within the source file(s). [Begin, End). public FileLineCharIndexSegment CharIndexSegment { get; set; } Property Value FileLineCharIndexSegment FilePath File path of the source file. public string FilePath { get; set; } Property Value string FirstIndexedFileLine Derives a IndexedFileLine from CharIndexSegment, FilePath, and BlockText. public IndexedFileLine FirstIndexedFileLine { get; } Property Value IndexedFileLine Methods GetSentence() Returns the source Sentence carried by this object. public Sentence GetSentence() Returns Sentence"
  },
  "api/Hi.NcParsers.SoftNcRunner.html": {
    "href": "api/Hi.NcParsers.SoftNcRunner.html",
    "title": "Class SoftNcRunner | HiAPI-C# 2025",
    "summary": "Class SoftNcRunner Namespace Hi.NcParsers Assembly HiMech.dll Configurable NC Runner. public class SoftNcRunner : INcRunner, IMakeXmlSource Inheritance object SoftNcRunner Implements INcRunner IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SoftNcRunner() Creates an empty runner; populate the pipeline lists before use. public SoftNcRunner() SoftNcRunner(XElement, string, string, IProgress<IMessage>, object[]) Reconstructs a SoftNcRunner from a project XML element. Each pipeline list (PipelineNcDependencyList, Segmenter, NcInitializationList, NcSyntaxList, NcSemanticList) is rehydrated via XFactory, then the legacy back-fills run against the version the element was written by (the owning project's stamp, else the element's own ApiVersionAttributeName stamp, else “unstamped” — see Hi.NcParsers.SoftNcRunner.ApplyLegacyVersionPatches(Hi.Common.XmlUtils.ProjectApiVersion)). public SoftNcRunner(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress, object[] res = null) Parameters src XElement XML element previously produced by MakeXmlSource(string, string, bool). baseDirectory string Project base directory for resolving relative paths. relFile string Project file path relative to baseDirectory. progress IProgress<IMessage> Diagnostic sink propagated to nested factories. res object[] Optional ambient resources (e.g. the owning project's ProjectApiVersion, used when the element carries no stamp of its own). Fields ApiVersionAttributeName XML attribute name of the API version stamp on a serialized runner (<SoftNcRunner ApiVersion=“3.2.17.0”>) — the same name and the same version line a project file carries on its root. public const string ApiVersionAttributeName = \"ApiVersion\" Field Value string Properties ApiVersion The API version MakeXmlSource(string, string, bool) stamps on the runner element, or null to write no stamp. The version line is the project file's ApiVersion — the assembly that owns the project format assigns this once at registration time (the legacy-patch gates in Hi.NcParsers.SoftNcRunner.ApplyLegacyVersionPatches(Hi.Common.XmlUtils.ProjectApiVersion) are keyed to that line, not to this library's own version, which runs ahead of it). A runner serialized by a host that never assigns it (the shipped preset generator, tests) carries no stamp and reloads as ProjectApiVersion-less, i.e. older than every gate. public static Version ApiVersion { get; set; } Property Value Version FanucNcRunner Brand preset for Fanuc — composes a SoftNcRunner whose NcSyntaxList comes from DefaultSyntaxList. public static SoftNcRunner FanucNcRunner { get; } Property Value SoftNcRunner HeidenhainNcRunner Brand preset for Heidenhain — composes a SoftNcRunner whose NcSyntaxList comes from DefaultSyntaxList. public static SoftNcRunner HeidenhainNcRunner { get; } Property Value SoftNcRunner MazakNcRunner Brand preset for Mazak — composes a SoftNcRunner whose NcSyntaxList comes from DefaultSyntaxList. public static SoftNcRunner MazakNcRunner { get; } Property Value SoftNcRunner NcInitializationList Seeds the initial SyntaxPiece JSON state (e.g. home position, defaults). public List<INcInitializer> NcInitializationList { get; set; } Property Value List<INcInitializer> NcSemanticList Final-stage semantics that turn the last syntax layer into SourcedActEntry records consumed by the runtime. public List<INcSemantic> NcSemanticList { get; set; } Property Value List<INcSemantic> NcSyntaxList Ordered syntax pipeline. Each entry consumes the previous layer's SyntaxPiece stream and emits the next layer. public List<INcSyntax> NcSyntaxList { get; set; } Property Value List<INcSyntax> PipelineNcDependencyList External configuration providers consumed by syntaxes/semantics (machine axes, tool offsets, coordinate tables, block-skip flags, etc.). May contain INcDependencyProxy placeholders — see GetEffectiveNcDependencyList(). public List<INcDependency> PipelineNcDependencyList { get; set; } Property Value List<INcDependency> Segmenter Splits raw NC text into Sentence blocks. public ISegmenter Segmenter { get; set; } Property Value ISegmenter SiemensNcRunner Brand preset for Siemens — composes a SoftNcRunner whose NcSyntaxList comes from DefaultSyntaxList. public static SoftNcRunner SiemensNcRunner { get; } Property Value SoftNcRunner SyntecNcRunner Brand preset for Syntec — composes a SoftNcRunner whose NcSyntaxList comes from DefaultSyntaxList. public static SoftNcRunner SyntecNcRunner { get; } Property Value SoftNcRunner XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods ConfigureByMachiningChain(IMachiningChain) Configures this SoftNcRunner to match the kinematic chain of a machine tool. Registers every axis present on the chain into the IMachineAxisConfig in PipelineNcDependencyList (linear or rotary, derived from whether the chain's transformer implements IDynamicRotation). When the chain carries any rotary axis, a NcKinematicsDependency is appended so that downstream syntaxes / semantics (e.g. G53.1, G68.2, McLinearMotionSemantic) can resolve orientation; its KinematicsProvider is intentionally left null — the owning project service wires it up after the solver instance is available (see LocalProjectService.BuildCoordinateConverter). The axis / home machine config is read from GetEffectiveNcDependencyList(), so a proxied parameter table resolves to the host's materialized instance — call this only after the proxies' host is wired. The NcKinematicsDependency, by contrast, is a runner-level pipeline dependency and is appended to the runner's own PipelineNcDependencyList below. public void ConfigureByMachiningChain(IMachiningChain chain) Parameters chain IMachiningChain The machining chain whose axes and kinematics the runner should match. No-op when null. EnumerateSnapshotSyntaxs() Enumerates every SnapshotSyntax reachable from NcSyntaxList, including those nested inside any top-level BundleSyntax's inner list. Yields in pipeline-execution order: each top-level slot in turn, and within a bundle slot the bundle's SyntaxList order. public IEnumerable<SnapshotSyntax> EnumerateSnapshotSyntaxs() Returns IEnumerable<SnapshotSyntax> FromLegacyNcEnvXml(XElement) Creates a SoftNcRunner brand preset from legacy HardNcEnv XML, picked by the CncBrand element. The returned runner carries proxy placeholders for both per-case data and the (Fanuc-family) parameter table, so machine config and per-case values are not populated here — the owning project wires the proxies to its host, then calls PopulateLegacyMachineConfig(XElement, List<INcDependency>), ConfigureByMachiningChain(IMachiningChain), and PopulateLegacyPerCaseData(XElement, List<INcDependency>) against the resolved host tables. Remove this region when HardNcEnv is fully replaced. public static SoftNcRunner FromLegacyNcEnvXml(XElement ncEnvXml) Parameters ncEnvXml XElement The inner XML element of the legacy HardNcEnv. Returns SoftNcRunner An unconfigured brand-preset SoftNcRunner. GetEffectiveNcDependencyList() Resolves every INcDependencyProxy in PipelineNcDependencyList to the concrete dependency it stands in for (via GetNcDependency()), leaving every non-proxy entry in place. Order is preserved, so downstream OfType<T>().FirstOrDefault() lookups behave exactly as for a proxy-free runner; entries a proxy resolves to null are dropped. Proxies must have their host wired (InitNcDependencyHost(INcDependencyListHost)) before this is called. RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) resolves the list once per session and caches it on NcRunnerSessionState, so each proxy maps to a single stable instance for the whole session and every pipeline stage sees the same dependencies. public List<INcDependency> GetEffectiveNcDependencyList() Returns List<INcDependency> GetSourcedActEntrysFromNode(LazyLinkedListNode<SyntaxPiece>, NcDiagnosticProgress, List<INcDependency>, CancellationToken) Drives the NcSemanticList over the post-syntax SyntaxPiece stream starting at startNode, yielding a SourcedActEntry for each emitted IAct (or a single null-act entry when a semantic produces no acts but still updates the source SyntaxPiece). public IEnumerable<SourcedActEntry> GetSourcedActEntrysFromNode(LazyLinkedListNode<SyntaxPiece> startNode, NcDiagnosticProgress ncDiagnosticProgress, List<INcDependency> ncDependencyList, CancellationToken cancellationToken) Parameters startNode LazyLinkedListNode<SyntaxPiece> First node to evaluate; iteration walks Next. ncDiagnosticProgress NcDiagnosticProgress Sink for semantic exceptions. ncDependencyList List<INcDependency> Proxy-resolved dependency list (see GetEffectiveNcDependencyList()) handed to each semantic's Resolve. cancellationToken CancellationToken Cancellation token (checked between blocks). Returns IEnumerable<SourcedActEntry> MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. PopulateLegacyMachineConfig(XElement, List<INcDependency>) Populates legacy machine config — home position, tooling pose/time, rapid rates, and stroke limits — from a legacy HardNcEnv XML element onto targetDeps. Split out of FromLegacyNcEnvXml(XElement) so it runs against the proxy-resolved host list (GetEffectiveNcDependencyList()) after the parameter-table proxy has materialized its host table — the Fanuc-family parameter table (which implements IHomeMcConfig / IRapidFeedrateConfig / IStrokeLimitConfig) is no longer a concrete entry on the runner. No-op for configs with no matching provider. public static void PopulateLegacyMachineConfig(XElement ncEnvXml, List<INcDependency> targetDeps) Parameters ncEnvXml XElement The inner XML element of the legacy HardNcEnv. targetDeps List<INcDependency> The proxy-resolved dependency list holding the machine-config providers. PopulateLegacyPerCaseData(XElement, List<INcDependency>) Populates the legacy per-case tables — tool offsets, work coordinate offsets, and (Heidenhain) datum preset/shift tables — from a legacy HardNcEnv XML element into targetDeps. Split out of FromLegacyNcEnvXml(XElement) so the per-case values land on the owning project's PerCaseNcDependencyList (where its proxies have materialized the real tables), not on the shared runner. No-op when targetDeps has no matching table. public static void PopulateLegacyPerCaseData(XElement ncEnvXml, List<INcDependency> targetDeps) Parameters ncEnvXml XElement The inner XML element of the legacy HardNcEnv. targetDeps List<INcDependency> The host dependency list holding the materialized per-case tables. Reg(XFactory) Registers SoftNcRunner and chains Reg() on every pipeline component the runner may deserialize from XML — dependencies, initializers, segmenters, parsing/logic/evaluation/post-logic/inspection syntaxes, and semantics. Idempotent; safe to call from any number of boot paths. public static void Reg(XFactory factory = null) Parameters factory XFactory RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) Runs raw NC program lines and yields source sentence and Act pairs. public IEnumerable<SourcedActEntry> RunNcLines(string relFilePath, IEnumerable<string> lines, MachiningSession machiningSession, StepDiagnosticProgress stepDiagnosticProgress, NcDiagnosticProgress ncDiagnosticProgress, CancellationToken cancellationToken) Parameters relFilePath string The relative path of the NC program file lines IEnumerable<string> The enumerable collection of NC program lines machiningSession MachiningSession Session-scoped state shared across multiple RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) calls (e.g. lazy-initialized pipeline state, file-index counter). stepDiagnosticProgress StepDiagnosticProgress Step-anchored IMessage-channel sink. ncDiagnosticProgress NcDiagnosticProgress NC-pipeline diagnostic sink, threaded in as an input so the runner stays host-agnostic (the caller injects it; the production caller passes the service-scoped instance, standalone tests pass their own). cancellationToken CancellationToken Cancellation token to cancel the operation Returns IEnumerable<SourcedActEntry> Enumerable of source sentence and Act pairs SetAllSnapshotSyntaxEnabled(bool) Sets IsEnabled on every SnapshotSyntax reachable from NcSyntaxList (including those nested inside top-level BundleSyntax) to isEnabled. Callers that need finer control (per-section toggling, instance inspection) should iterate EnumerateSnapshotSyntaxs() directly. public void SetAllSnapshotSyntaxEnabled(bool isEnabled) Parameters isEnabled bool"
  },
  "api/Hi.NcParsers.SoftNcUtil.html": {
    "href": "api/Hi.NcParsers.SoftNcUtil.html",
    "title": "Class SoftNcUtil | HiAPI-C# 2025",
    "summary": "Class SoftNcUtil Namespace Hi.NcParsers Assembly HiMech.dll JSON helpers for soft-NC blocks: vectors under Parsing, motion-term queries, flag grab/remove on raw text, and unparsed-line trimming. public static class SoftNcUtil Inheritance object SoftNcUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Properties RegexFlagPrefix Regex prefix pattern that matches word boundary, after digit, after whitespace, or at start of string. The whitespace/start-of-string alternatives are needed for non-word-character prefixes (e.g. Fanuc '#', Siemens '$'). public static string RegexFlagPrefix { get; } Property Value string Methods GetMachineStateDouble(JsonObject, string) Reads a numeric tag from a machine-state section (one written by a LogicSyntax / Semantic with explicit numeric values, not from the parser stage). Used by backward-walk lookback paths (ProgramXyzUtil FindPrevious*, FindPreviousState on Feedrate/SpindleSpeed/IsoLocalCoordinateOffset, modal arc-/linear-feedrate prev-block reads, etc.) where the data is supposed to be guaranteed numeric and any non-numeric is a HiAPIs codegen bug rather than an unevaluated user expression. Tag missing → returns null silently (the section may not have been written on a previous block; caller's ?? default chain handles it). Tag present and numeric → returns the value. Tag present but non-numeric → throws InvalidOperationException immediately. The stack trace anchors the bug at the read site (which is the right place to investigate — the originating block has already passed). Continuing with NaN/0 would silently propagate corrupt coordinates downstream and is more dangerous than crashing the run. Use GetParsedDouble(JsonObject, string, ISentenceCarrier, NcDiagnosticProgress) instead when reading from a parser- stage section (variable expressions on the current block deserve a soft diagnostic, not a hard crash). public static double? GetMachineStateDouble(this JsonObject section, string key) Parameters section JsonObject key string Returns double? GetMachineStateVec3d(JsonObject, string) Vec3d reader for machine-state sections (written by upstream LogicSyntaxes / Semantics with explicit numeric values). Section missing → returns null; individual missing X/Y/Z components fall through to NaN; a non-numeric value at any of X/Y/Z throws via GetMachineStateDouble(JsonObject, string) — non-numeric here is a HiAPIs codegen bug, not a user-facing unevaluated expression, and silently degrading to NaN/0 would propagate corrupt coordinates downstream. public static Vec3d GetMachineStateVec3d(JsonObject json, string sectionKey) Parameters json JsonObject sectionKey string Returns Vec3d GetOccupiedMotionEventForm(JsonObject) Reads the form on the current block's MotionEvent section, indicating that a motion event has already been authored on this block by an earlier-stage motion syntax. Returns null when no motion event is present on this block. Used by motion syntaxes to enforce mutual exclusion (only one motion event per block). Reads MotionEvent rather than MotionState because state is modally carried onto every block via ModalCarrySyntax and would always appear \"occupied\"; only the event section is sparse and meaningfully indicates an authored claim on this block. public static string GetOccupiedMotionEventForm(this JsonObject json) Parameters json JsonObject Returns string GetParsedDouble(JsonObject, string, ISentenceCarrier, NcDiagnosticProgress) Reads a numeric tag from a JSON object held on a SyntaxPiece (the Parsing tree, a previously-written modal section, or any sub-object thereof), with strict separation between “tag absent” and “tag present but not a number”. Tag missing → returns null silently. The caller's existing ?? default chain handles the \"axis not written\" / \"section absent\" case as before. Tag present and numeric → returns the value. Tag present but non-numeric → emits UnsupportedError(ISentenceCarrier, string, string, object) (id VariableExpression--Unevaluated) and returns null. Two sources land here: Parser-stage residue — a Fanuc \"#124\", Heidenhain \"Q1\", Siemens \"R5\", or bracket expression \"[#100+5]\" stored as a string by ToFloat(string) / ToInteger(string) when the literal parse failed. Remediation: wire up the variable evaluator. Codegen residue — a previously-written modal section that somehow ended up with a non-numeric JsonValue. Remediation: file a HiAPIs bug. Severity is intentionally the same; reconfigurable diagnostic routing handles operator-vs-developer triage and a second error id would be cosmetic. Replaces the legacy idiom section[key]?.GetDouble() at every call site that consumes a numeric tag held on a SyntaxPiece. public static double? GetParsedDouble(this JsonObject section, string key, ISentenceCarrier sentenceCarrier, NcDiagnosticProgress diag) Parameters section JsonObject key string sentenceCarrier ISentenceCarrier diag NcDiagnosticProgress Returns double? GetVec3d(JsonObject, string, Vec3d, ISentenceCarrier, NcDiagnosticProgress) Reads Vec3d from a sub-object with X/Y/Z keys, substituting each missing component (or a missing section) with the matching component of fallback. When sentenceCarrier is non-null and diag is supplied, non-numeric X/Y/Z values are reported via GetParsedDouble(JsonObject, string, ISentenceCarrier, NcDiagnosticProgress); when sentenceCarrier is null, the diagnostic still fires but without a source-line anchor. public static Vec3d GetVec3d(JsonObject json, string sectionKey, Vec3d fallback, ISentenceCarrier sentenceCarrier, NcDiagnosticProgress diag) Parameters json JsonObject sectionKey string fallback Vec3d sentenceCarrier ISentenceCarrier diag NcDiagnosticProgress Returns Vec3d GetVec3d(JsonObject, string, ISentenceCarrier, NcDiagnosticProgress) Read Vec3d from a sub-object with X/Y/Z keys. Returns null if the section or all three keys are missing; individual missing keys are filled with NaN. When sentenceCarrier is non-null and diag is supplied, non-numeric X/Y/Z values are reported via GetParsedDouble(JsonObject, string, ISentenceCarrier, NcDiagnosticProgress) (id VariableExpression--Unevaluated); when sentenceCarrier is null, the diagnostic still fires but without a source-line anchor (used by backward-walk / dump-reading callers that cannot tie the read to the current sentence). public static Vec3d GetVec3d(JsonObject json, string sectionKey, ISentenceCarrier sentenceCarrier, NcDiagnosticProgress diag) Parameters json JsonObject sectionKey string sentenceCarrier ISentenceCarrier diag NcDiagnosticProgress Returns Vec3d GrabDouble(ref string, string, bool) Grab double value with decimal point judgement: The text is changed by replacing tag and value to empty string. If enableIntegerShrink is true and no decimal point, the value should be scale by 0.001. public static double GrabDouble(ref string text, string tag, bool enableIntegerShrink) Parameters text string text tag string tag enableIntegerShrink bool If true and no decimal point exists, the value will be scaled by 0.001. Returns double double value GrabFlag(ref string, string) Grabs and removes a flag from the NC text. public static bool GrabFlag(ref string text, string regexTag) Parameters text string The NC text to search and modify. regexTag string The flag tag to search for. Returns bool True if the flag was found and removed; otherwise, false. GrabFlags(ref string, IEnumerable<string>) Removes the first occurrence of any flag in tags from text (alternation regex). public static bool GrabFlags(ref string text, IEnumerable<string> tags) Parameters text string tags IEnumerable<string> Returns bool true if a match was removed. HasAnyFlag(string, IEnumerable<string>) True if text contains any flag in flags as whole tokens. public static bool HasAnyFlag(string text, IEnumerable<string> flags) Parameters text string flags IEnumerable<string> Returns bool HasAnyFlag(string, string) True if text contains flag as a whole token (see RegexFlagPrefix). public static bool HasAnyFlag(string text, string flag) Parameters text string flag string Returns bool HasFlagInArray(JsonObject, string) Checks if a specific flag string exists in the Parsing.Flags JsonArray. public static bool HasFlagInArray(this JsonObject parsing, string flag) Parameters parsing JsonObject flag string Returns bool ParseDouble(JsonNode) Parses a double from a JsonNode that may be a number or a string. Extends GetDouble(JsonNode) with string parsing support (needed for values from ParameterizedFlagSyntax which stores values as strings like “180”). Returns 0 if null or unparseable. public static double ParseDouble(this JsonNode node) Parameters node JsonNode Returns double RemoveFlagFromArray(JsonObject, string) Removes a specific flag string from the Parsing.Flags JsonArray. public static void RemoveFlagFromArray(this JsonObject parsing, string flag) Parameters parsing JsonObject flag string SetAndTrimUnparsedText(JsonObject, string) Normalises UnparsedText (trim, drop blank-only lines) and removes the property when empty. public static void SetAndTrimUnparsedText(this JsonObject root, string unparsedText) Parameters root JsonObject Block JSON object. unparsedText string Raw tail text after structured fields were consumed. SetVec3d(JsonObject, string, Vec3d) Writes Vec3d to a sub-object under sectionKey, setting only the X/Y/Z keys. If the section already exists, other keys (e.g. A/B/C on a shared MachineCoordinate) are preserved; if it does not exist, a new sub-object is created. Upsert rather than replace so callers that write XYZ and ABC in separate stages (McXyzSyntax and McAbcSyntax) can cooperate on the same MachineCoordinateState section without clobbering each other. public static void SetVec3d(JsonObject json, string sectionKey, Vec3d v) Parameters json JsonObject sectionKey string v Vec3d"
  },
  "api/Hi.NcParsers.Syntaxs.BundleSyntax.html": {
    "href": "api/Hi.NcParsers.Syntaxs.BundleSyntax.html",
    "title": "Class BundleSyntax | HiAPI-C# 2025",
    "summary": "Class BundleSyntax Namespace Hi.NcParsers.Syntaxs Assembly HiMech.dll Depth-First Sequential Syntaxes management. It saves space by save the LazyLinkedLists from each syntax to only one LazyLinkedLists in SoftNcRunner to get better performance. If the INcSyntax only edit the current node itself, those self-editing INcSyntax without looks-forward is suitable to put into the BundleSyntax. public class BundleSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object BundleSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors BundleSyntax() Creates an empty bundle (name defaults to the type name BundleSyntax). public BundleSyntax() BundleSyntax(IEnumerable<ISituNcSyntax>) Creates a bundle with default Name from an ordered syntax list. public BundleSyntax(IEnumerable<ISituNcSyntax> syntaxes) Parameters syntaxes IEnumerable<ISituNcSyntax> BundleSyntax(string, IEnumerable<ISituNcSyntax>) Creates a named bundle wrapping the given syntax list. public BundleSyntax(string name, IEnumerable<ISituNcSyntax> syntaxes) Parameters name string syntaxes IEnumerable<ISituNcSyntax> BundleSyntax(XElement, string, string, IProgress<IMessage>) Loads nested in-situ syntax elements from XML under Name. public BundleSyntax(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress) Parameters src XElement baseDirectory string relFile string progress IProgress<IMessage> Properties Name Syntax kind name (typically the concrete type name). public string Name { get; set; } Property Value string SyntaxList Child syntaxes executed in registration order within this bundle. public List<ISituNcSyntax> SyntaxList { get; } Property Value List<ISituNcSyntax> XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.NcParsers.Syntaxs.ExpressionPrefixParser.html": {
    "href": "api/Hi.NcParsers.Syntaxs.ExpressionPrefixParser.html",
    "title": "Delegate ExpressionPrefixParser | HiAPI-C# 2025",
    "summary": "Delegate ExpressionPrefixParser Namespace Hi.NcParsers.Syntaxs Assembly HiMech.dll Longest-valid-prefix expression parse over source: returns true with consumedLength set to the number of leading characters forming a valid expression (the grammar decides where a captured RHS ends), or false when not even a prefix parses. Capture syntaxes take this as an optional hook so the assignment/tag grammars stay decoupled from any concrete expression parser (see NcExpressionDialectUtil.TryParsePrefix). public delegate bool ExpressionPrefixParser(string source, out int consumedLength) Parameters source string Longest-valid-prefix expression parse over source: returns true with consumedLength set to the number of leading characters forming a valid expression (the grammar decides where a captured RHS ends), or false when not even a prefix parses. Capture syntaxes take this as an optional hook so the assignment/tag grammars stay decoupled from any concrete expression parser (see NcExpressionDialectUtil.TryParsePrefix). consumedLength int Longest-valid-prefix expression parse over source: returns true with consumedLength set to the number of leading characters forming a valid expression (the grammar decides where a captured RHS ends), or false when not even a prefix parses. Capture syntaxes take this as an optional hook so the assignment/tag grammars stay decoupled from any concrete expression parser (see NcExpressionDialectUtil.TryParsePrefix). Returns bool Longest-valid-prefix expression parse over source: returns true with consumedLength set to the number of leading characters forming a valid expression (the grammar decides where a captured RHS ends), or false when not even a prefix parses. Capture syntaxes take this as an optional hook so the assignment/tag grammars stay decoupled from any concrete expression parser (see NcExpressionDialectUtil.TryParsePrefix). Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.NcParsers.Syntaxs.FanucSyntaxUtil.html": {
    "href": "api/Hi.NcParsers.Syntaxs.FanucSyntaxUtil.html",
    "title": "Class FanucSyntaxUtil | HiAPI-C# 2025",
    "summary": "Class FanucSyntaxUtil Namespace Hi.NcParsers.Syntaxs Assembly HiMech.dll Pre-built ParameterizedFlagSyntax / flag patterns for Fanuc-style NC text. public static class FanucSyntaxUtil Inheritance object FanucSyntaxUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields VarTag Variable token prefix for Fanuc macro addresses (#). public const string VarTag = \"#\" Field Value string Properties DefaultSyntaxList Syntax list for general kind of Fanuc Controller. public static List<INcSyntax> DefaultSyntaxList { get; } Property Value List<INcSyntax> G05Syntax G05 P{n}: Fanuc HPCC family selector. P is a function-selection code, not a quantity: P10000 enters high-precision contour control (RISC-board look-ahead — never alters programmed coordinates), P0 cancels, P10001–P10999 call high-speed cycle machining (executes cycle data pre-registered in the variable area — real axis motion), and small P values select the high-speed remote buffer modes (binary DNC transfer). Consumed by FanucPathSmoothingSyntax into the block-local FanucHpcc section (see IFanucHpccDef). Both the G05 and G5 spellings are captured (the DwellSyntax G4/G04 discipline); the trailing-character guard keeps G05.1 for G05p1Syntax. public static ParameterizedFlagSyntax G05Syntax { get; } Property Value ParameterizedFlagSyntax G05p1Syntax G05.1 High-precision contour control (Fanuc AICC / Nano Smoothing). Q1 enables, Q0 disables. Optional R{n} selects the precision / smoothness level number (R1..R10) — captured here so the parameter does not leak into the standalone Parsing.R tag and so FanucPathSmoothingSyntax can record it in the PathSmoothing modal section for bidirectional NC-text reconstruction. public static ParameterizedFlagSyntax G05p1Syntax { get; } Property Value ParameterizedFlagSyntax G43p4Syntax G43.4: Fanuc TCPM (Tool Center Point Management / RTCP). Fanuc-specific — not in GenericSyntaxKit. Siemens equivalent: TRAORI. Heidenhain equivalent: M128. TerminateWords intentionally only M: H (offset id) commonly appears after move axes or other G modifiers in the same block (e.g., G43.4 Z5. H1, G43.4 G54 H1). Using G/X/Y/Z would truncate scope before H and lose the offset id. public static ParameterizedFlagSyntax G43p4Syntax { get; } Property Value ParameterizedFlagSyntax G54p1Syntax G54.1 P… additional work coordinate system selection, in both spellings Fanuc's manual gives the chapter (“G54.1 or G54”): G54.1 P4 / G54.1P4 and G54 P4 / G54P4 all land as Parsing.G54.1 = {P: 4}. The G54 spelling is a parameter-gated alias: without a P word it is left alone and stays the ordinary G54 flag for NumberedFlagSyntax. Any P word on a G54 block is taken as the offset index, as the controller does (the manual forbids other P uses on that block). Shared by the Syntec and Mazak presets; consumed by IsoCoordinateOffsetSyntax. public static ParameterizedFlagSyntax G54p1Syntax { get; } Property Value ParameterizedFlagSyntax G65Syntax G65: Fanuc one-shot custom macro call. G65 P{program} [L{repeat}] [{arg_letter}{value} ...] public static ParameterizedFlagSyntax G65Syntax { get; } Property Value ParameterizedFlagSyntax Remarks Macro argument letters: A-E, F, H-K, M, Q-Z map to local variables #1-#26. G, L, N, O, P are reserved (G-code prefix, repeat count, line number, program number, program to call). G66Syntax G66: Fanuc modal custom macro call. G66 P{program} [L{repeat}] [{arg_letter}{value} ...] public static ParameterizedFlagSyntax G66Syntax { get; } Property Value ParameterizedFlagSyntax Remarks Same argument letters as G65. Modal: executes at every positioning block until cancelled by G67. M198Syntax M198: Fanuc subprogram call from external storage (memory card, USB, DNC drive). Same parameter shape as M98Syntax; only the lookup root differs (see ExternalFolder). M198 P{program} [L{repeat}] public static ParameterizedFlagSyntax M198Syntax { get; } Property Value ParameterizedFlagSyntax M98Syntax M98: Fanuc subprogram call. M98 P{program} [L{repeat}] public static ParameterizedFlagSyntax M98Syntax { get; } Property Value ParameterizedFlagSyntax M99Syntax M99: Fanuc subprogram end / return. M99 [P{sequence}] public static ParameterizedFlagSyntax M99Syntax { get; } Property Value ParameterizedFlagSyntax"
  },
  "api/Hi.NcParsers.Syntaxs.GenericSyntaxKit.html": {
    "href": "api/Hi.NcParsers.Syntaxs.GenericSyntaxKit.html",
    "title": "Class GenericSyntaxKit | HiAPI-C# 2025",
    "summary": "Class GenericSyntaxKit Namespace Hi.NcParsers.Syntaxs Assembly HiMech.dll Generic/ISO standard syntax kit. Involve G code. Contains syntax definitions for common G codes used across multiple NC systems. public class GenericSyntaxKit Inheritance object GenericSyntaxKit Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors GenericSyntaxKit(string) Creates a kit with the given variable-address prefix. public GenericSyntaxKit(string varPrefix) Parameters varPrefix string Single-character or short prefix used by parameterized syntaxes. Properties CannedCycleCodes Cycle codes captured by CannedCycleSyntax. Defaults to CannedCycleCodes; brands whose vocabulary conflicts override it (e.g. Siemens excludes G74 — reference-point return there, not a tapping cycle). public List<string> CannedCycleCodes { get; set; } Property Value List<string> CannedCycleSyntax Canned drilling/boring/tapping cycle syntax (G73/G74/G81/G82/G83/G84/G85/G86/G89). Captures all cycle parameters (X, Y, Z, R, Q, F) into the cycle sub-section (e.g., Parsing.G83) so that cycle syntaxes can read them as a unit and store them for modal lookback. Terminates at G/M only. public ParameterizedFlagSyntax CannedCycleSyntax { get; } Property Value ParameterizedFlagSyntax DwellCodes Dwell codes captured by G4Syntax. Both spellings by default — real programs write G04 as often as G4, and the un-captured spelling used to fall through to the flag/axis syntaxes (where a Fanuc G04 X0.5 dwell time became a ghost X motion word). public List<string> DwellCodes { get; set; } Property Value List<string> DwellParamPrefixes Argument prefixes captured into the dwell sub-section by G4Syntax. Default covers the Fanuc-family dialect (X/U seconds, P milliseconds, plus the legacy S spindle-revolutions capture); the Siemens preset overrides with F (seconds) + S (revolutions). public List<string> DwellParamPrefixes { get; set; } Property Value List<string> G28Syntax G28 Reference point return syntax. public ParameterizedFlagSyntax G28Syntax { get; } Property Value ParameterizedFlagSyntax G41G42Syntax G41/G42 Cutter radius compensation syntax. TerminateWords intentionally only M: D (offset id) commonly appears after move axes or other G modifiers in the same block (e.g., G41 X10. D1, G54 G41 D1). Using G/X/Y/Z would truncate scope before D and lose the offset id. public ParameterizedFlagSyntax G41G42Syntax { get; } Property Value ParameterizedFlagSyntax G43G44Syntax G43/G44 Tool length compensation syntax (ISO standard). G43.4 (TCPM) is Fanuc-specific — see G43p4Syntax. TerminateWords intentionally only M: H (offset id) commonly appears after move axes or other G modifiers in the same block (e.g., G43Z5.H01, G43 G54 H1). Using G/X/Y/Z would truncate scope before H and lose the offset id. public ParameterizedFlagSyntax G43G44Syntax { get; } Property Value ParameterizedFlagSyntax G4Syntax G4 Dwell/Pause syntax. Captures DwellCodes plus their DwellParamPrefixes arguments into a Parsing.G4/Parsing.G04 sub-section, consumed by DwellSyntax. public ParameterizedFlagSyntax G4Syntax { get; } Property Value ParameterizedFlagSyntax G52Syntax G52 Local coordinate system syntax. public ParameterizedFlagSyntax G52Syntax { get; } Property Value ParameterizedFlagSyntax G68Syntax G68 Coordinate rotation syntax. X/Y/Z (center), I/J/K (axis), R (angle) stored as doubles. public ParameterizedFlagSyntax G68Syntax { get; } Property Value ParameterizedFlagSyntax G68p2Syntax G68.2 Tilted work plane syntax. X/Y/Z (origin), I/J/K (euler angles) stored as doubles. A/B/C post-processor hints are parsed by FloatTagValueSyntax and consumed by IsoG68p2TiltSyntax from Parsing. public ParameterizedFlagSyntax G68p2Syntax { get; } Property Value ParameterizedFlagSyntax ParameterizedFlagSyntaxList Common ISO-style G-code parameterized syntaxes using VarPrefix. public List<ParameterizedFlagSyntax> ParameterizedFlagSyntaxList { get; } Property Value List<ParameterizedFlagSyntax> VarPrefix Variable index prefix for this kit (e.g. Fanuc #, Heidenhain Q). public string VarPrefix { get; set; } Property Value string"
  },
  "api/Hi.NcParsers.Syntaxs.HeidenhainSyntaxUtil.html": {
    "href": "api/Hi.NcParsers.Syntaxs.HeidenhainSyntaxUtil.html",
    "title": "Class HeidenhainSyntaxUtil | HiAPI-C# 2025",
    "summary": "Class HeidenhainSyntaxUtil Namespace Hi.NcParsers.Syntaxs Assembly HiMech.dll Pre-built parsing syntax fragments for Heidenhain-style programs (Q variables, FMAX/FAUTO, etc.). public static class HeidenhainSyntaxUtil Inheritance object HeidenhainSyntaxUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields VarTag Variable token prefix for Heidenhain Q parameters. public const string VarTag = \"Q\" Field Value string Properties CcAwareIncrementalResolveSyntax The brand's IncrementalResolveSyntax: the Parsing root (L / C endpoints) plus the nested Parsing.CC record, so an incremental circle center (CC IX+.. IY+.., stamped per axis by HeidenhainIncrementalAxisWordUtil) is made absolute against the last programmed tool position before HeidenhainCircleCenterSyntax freezes it. The shared default's Parsing.G28 path is left out on purpose: this brand's G28 is MIRROR IMAGE, consumed at the Parsing stage, so the record never exists here. public static IncrementalResolveSyntax CcAwareIncrementalResolveSyntax { get; } Property Value IncrementalResolveSyntax DefaultSyntaxList Syntax list for general kind of Heidenhain Controller. public static List<INcSyntax> DefaultSyntaxList { get; } Property Value List<INcSyntax> FTagValueSyntax Feed-word capture as a float tag using VarTag. Spaced values are accepted (F 20000 — a real post family writes the feed word detached; glued stays the default for every other brand). public static FloatTagValueSyntax FTagValueSyntax { get; } Property Value FloatTagValueSyntax FlagSyntax Flags written under Flags for the rapid-feed modes. Glued followers are allowed so the turbine post's FMAXM03M08 run still yields FMAX. The STOP word deliberately lives on its own word-bounded instance in the bundle below — under the glued option a quoted tool name like TOOL CALL “STOPFEN” would lose its STOP head to this list. public static FlagSyntax FlagSyntax { get; } Property Value FlagSyntax"
  },
  "api/Hi.NcParsers.Syntaxs.IExpandingNcSyntax.html": {
    "href": "api/Hi.NcParsers.Syntaxs.IExpandingNcSyntax.html",
    "title": "Interface IExpandingNcSyntax | HiAPI-C# 2025",
    "summary": "Interface IExpandingNcSyntax Namespace Hi.NcParsers.Syntaxs Assembly HiMech.dll Expanding syntax: transforms one SyntaxPiece node into zero or more output pieces (e.g., subprogram inlining, macro expansion, conditional branching). public interface IExpandingNcSyntax : INcSyntax, IMakeXmlSource Inherited Members INcSyntax.Name IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods Expand(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Expand the syntaxPieceNode into a sequence of SyntaxPiece results. IEnumerable<SyntaxPiece> Expand(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<SyntaxPiece>"
  },
  "api/Hi.NcParsers.Syntaxs.INcSyntax.html": {
    "href": "api/Hi.NcParsers.Syntaxs.INcSyntax.html",
    "title": "Interface INcSyntax | HiAPI-C# 2025",
    "summary": "Interface INcSyntax Namespace Hi.NcParsers.Syntaxs Assembly HiMech.dll Base interface for syntax-level data transformation on SyntaxPiece.JsonObject. Unlike INcSemantic which produces IAct, INcSyntax only restructures or enriches parsed data without producing actions. public interface INcSyntax : IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks Do not implement this interface directly. Use one of the two derived interfaces: ISituNcSyntax — in-situ (in-place) mutation of a single SyntaxPiece. IExpandingNcSyntax — expands one SyntaxPiece into multiple pieces. Properties Name Syntax kind name (typically the concrete type name). string Name { get; } Property Value string"
  },
  "api/Hi.NcParsers.Syntaxs.ISituNcSyntax.html": {
    "href": "api/Hi.NcParsers.Syntaxs.ISituNcSyntax.html",
    "title": "Interface ISituNcSyntax | HiAPI-C# 2025",
    "summary": "Interface ISituNcSyntax Namespace Hi.NcParsers.Syntaxs Assembly HiMech.dll In-situ syntax: mutates the JsonObject of the given node in-place without changing the node count. Most parsing and logic syntaxes implement this interface. public interface ISituNcSyntax : INcSyntax, IMakeXmlSource Inherited Members INcSyntax.Name IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress"
  },
  "api/Hi.NcParsers.Syntaxs.MazakSyntaxUtil.html": {
    "href": "api/Hi.NcParsers.Syntaxs.MazakSyntaxUtil.html",
    "title": "Class MazakSyntaxUtil | HiAPI-C# 2025",
    "summary": "Class MazakSyntaxUtil Namespace Hi.NcParsers.Syntaxs Assembly HiMech.dll Mazak-specific NC syntax utilities. public static class MazakSyntaxUtil Inheritance object MazakSyntaxUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields VarTag Variable prefix for Mazak (same as Fanuc). public const string VarTag = \"#\" Field Value string Properties DefaultSyntaxList Syntax list for general kind of Mazak Controller. public static List<INcSyntax> DefaultSyntaxList { get; } Property Value List<INcSyntax> G10p9Syntax G10.9 Center path mode syntax. public static ParameterizedFlagSyntax G10p9Syntax { get; } Property Value ParameterizedFlagSyntax Remarks G10.9X0 → center path G10.9X1 → compensation path by CAM (generally for G41 and G42)"
  },
  "api/Hi.NcParsers.Syntaxs.NcSyntaxUtil.html": {
    "href": "api/Hi.NcParsers.Syntaxs.NcSyntaxUtil.html",
    "title": "Class NcSyntaxUtil | HiAPI-C# 2025",
    "summary": "Class NcSyntaxUtil Namespace Hi.NcParsers.Syntaxs Assembly HiMech.dll JSON serialization settings and grab/set helpers for NC block JsonObject trees. public static class NcSyntaxUtil Inheritance object NcSyntaxUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields RepeatedWordsKey Key under a Parsing category collecting the values of a word that occurs more than once on the block, in text order after the first (T10 T2 M06 → { “T”: 10, “RepeatedWords”: { “T”: [2] } }). The scalar slot keeps the FIRST occurrence — HardNc parity, whose word grabs are first-match (HardNcUtil.GrabInt). A consumer that gives a repeat a meaning (the dual tool word: ToolChangeSyntax) reads and removes it here; anything left surfaces as Parsing–Unconsumed instead of silently overwriting the first word. public const string RepeatedWordsKey = \"RepeatedWords\" Field Value string Properties AxisTagList tag list for the motion axis tags. public static List<string> AxisTagList { get; set; } Property Value List<string> Remarks Must be initialized before MixedNcSyntaxList to avoid static initialization cycle. FloatTagList tag list for the float number tags. public static List<string> FloatTagList { get; set; } Property Value List<string> Remarks Must be initialized before MixedNcSyntaxList to avoid static initialization cycle. Methods GrabTagAssignment(ref string, IEnumerable<string>, string, IEnumerable<string>, ExpressionPrefixParser) Get Tag Assignments with = sign. ex. Siemens: R1=100.5, Z=V1+V2, Z=V1 - V3 * V2 F200 Heidenhain: Q1 = Q2 + 100 Fanuc: #1=#2+#3 public static List<TagValue> GrabTagAssignment(ref string unparsedText, IEnumerable<string> targetTags, string varPrefix, IEnumerable<string> terminateWords = null, ExpressionPrefixParser rhsPrefixParser = null) Parameters unparsedText string The NC text to parse and modify. targetTags IEnumerable<string> candidate target tags to extract values for varPrefix string variable index code prefix. terminateWords IEnumerable<string> words that terminate expression (e.g., F, G, M, S). These are different from varPrefix - they signal end of expression, not variables. rhsPrefixParser ExpressionPrefixParser Optional longest-valid-prefix expression parser (see ExpressionPrefixParser). When provided and a prefix parses, it supersedes both the lexical boundary and the terminateWords cut for that match — the grammar itself ends the RHS (R26=R64-14/2 R23=2, Z=R63 + 150 X100); the lexical machinery remains the per-match fallback when no prefix parses. Returns List<TagValue> List of extracted tag assignments. GrabTagEqualsValue(ref string, IEnumerable<string>, ExpressionPrefixParser) Get tag values written in the Siemens address=value form (an explicit = between a single-letter tag and its value). ex. Siemens: X=100, Z=R63+150, C=R61, F=R103, Z=_Z_HOME public static List<TagValue> GrabTagEqualsValue(ref string unparsedText, IEnumerable<string> targetTags, ExpressionPrefixParser rhsPrefixParser = null) Parameters unparsedText string The NC text to parse and modify. targetTags IEnumerable<string> candidate target tags to extract values for rhsPrefixParser ExpressionPrefixParser Optional longest-valid-prefix expression parser delimiting each RHS (see ExpressionPrefixParser). Returns List<TagValue> List of extracted tag values. Remarks Without rhsPrefixParser, the value is captured as the following non-whitespace run, so arithmetic expressions without embedded spaces (R63+150) and named-variable references (_Z_HOME) survive as strings for the evaluation stage; numeric literals are typed later by the caller's converter (e.g. ToFloat(string)). With rhsPrefixParser (parser-delimited capture), the value is the longest valid expression prefix after the = — spaced arithmetic (R63 + 150), balanced call parentheses (DC(47.296)) and glued following words (X=100Y50) all delimit correctly; the lexical \\S+ run stays as the per-match fallback when no prefix parses. GrabTagValue(ref string, IEnumerable<string>, string, bool) Get tag values. Concatenated tag-value syntax (no = sign), glued by default: the value must follow the tag immediately. Pass allowSpacedValue to also accept whitespace between tag and value (the Heidenhain detached feed word). ex. Heidenhain: L X+10 Y33.4 FQ1 Heidenhain (allowSpacedValue): L Z-22.5 F 20000 ISO: X100.3Y3.3 Fanuc Macro: X[#1+#2] Y[#1*2+100] public static List<TagValue> GrabTagValue(ref string unparsedText, IEnumerable<string> targetTags, string varPrefix, bool allowSpacedValue = false) Parameters unparsedText string The NC text to parse and modify. targetTags IEnumerable<string> candidate target tags to extract values for varPrefix string variable index code prefix. ex. Fanuc # for #123; Heidenhain Q for Q123. allowSpacedValue bool when true, whitespace may separate a tag from its value (F 20000); the value grammar must still match right after the run, so F MAX or F X+10 stay unclaimed. Default false keeps the glued-only grammar every other brand pins. Returns List<TagValue> List of extracted tag values."
  },
  "api/Hi.NcParsers.Syntaxs.SiemensSyntaxUtil.html": {
    "href": "api/Hi.NcParsers.Syntaxs.SiemensSyntaxUtil.html",
    "title": "Class SiemensSyntaxUtil | HiAPI-C# 2025",
    "summary": "Class SiemensSyntaxUtil Namespace Hi.NcParsers.Syntaxs Assembly HiMech.dll Pre-built parsing syntax fragments for Siemens-style programs (R parameters, TRAORI, etc.). public static class SiemensSyntaxUtil Inheritance object SiemensSyntaxUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields NamedIdentPattern Identifier grammar for Siemens named-assignment LHS capture (IdentPattern override). Four alternatives: $ system variables with an optional literal index list ($P_UIFR[5,Z,TR], $AC_TIME); underscore-leading names (_X_HOME); names containing an underscore (HH_ROBOTON, L_39); and one-letter+digits words (H1=21 auxiliary functions; also re-matches R63, the P0-blessed benign overlap with TagAssignmentSyntax — both sides carry the same TerminateWords and RhsDialect). Deliberately narrower than DefaultIdentPattern: a multi-letter letters+digits run must NOT match, or a fully-glued block like G90X0Y=R63 is swallowed whole as Assignments.G90X0Y before the flag/axis syntaxes can token-split it (real-corpus bug); the one-letter+digits alternative cannot fire inside it (no letter+digits run sits directly before the =). The corpus' named variables all carry an underscore; a hypothetical underscore-free DEF name is still lowered correctly because SiemensDefStatementSyntax owns DEF lines, but its later re-assignments would not be captured — corpus-driven trade-off. public const string NamedIdentPattern = \"\\\\$\\\\w+(?:\\\\[[^\\\\]=]*\\\\])?|_\\\\w+|[A-Za-z]\\\\w*_\\\\w*|[A-Za-z]\\\\d+\" Field Value string VarTag Variable token prefix for Siemens R parameters. public const string VarTag = \"R\" Field Value string Properties DefaultSyntaxList Syntax list for general kind of Siemens Controller. public static List<INcSyntax> DefaultSyntaxList { get; } Property Value List<INcSyntax> FlagSyntax Common Siemens bare-word flags under Flags: RTCP codes (TRAORI/TRAFOOF — consumed by SiemensTraoriSyntax), SUPA (consumed by MachineCoordSelectSyntax), STOPRE (consumed by SiemensStopreSyntax), RET (consumed by SiemensSubProgramReturnSyntax) and the path-control modal words consumed by SiemensPathSmoothingSyntax. public static FlagSyntax FlagSyntax { get; } Property Value FlagSyntax"
  },
  "api/Hi.NcParsers.Syntaxs.SyntaxPiece.html": {
    "href": "api/Hi.NcParsers.Syntaxs.SyntaxPiece.html",
    "title": "Class SyntaxPiece | HiAPI-C# 2025",
    "summary": "Class SyntaxPiece Namespace Hi.NcParsers.Syntaxs Assembly HiMech.dll One NC block's source line paired with its parsed JSON payload during soft-NC processing. public class SyntaxPiece : ISentenceCarrier, IGetSentence, ISentenceIndexed Inheritance object SyntaxPiece Implements ISentenceCarrier IGetSentence ISentenceIndexed Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks The design pattern of Sentence and JsonObject are one-one mapping. JSON value type convention: Prefer base types (double, int) over string for numeric values in JsonObject. This applies to both parsing syntaxes and logic syntaxes. Strings should only be used when the value is genuinely textual (e.g., macro variable references like \"#1\", \"Q2\", coordinate IDs like \"G54\") or when the value cannot be parsed to a number. Use FloatTagValueSyntax, IntegerTagValueSyntax, or FloatParamPrefixes / IntParamPrefixes to store typed values at parse time. Constructors SyntaxPiece(Sentence, JsonObject, int) Creates a piece binding sentence to jsonObject with its execution-order sentenceIndex. public SyntaxPiece(Sentence sentence, JsonObject jsonObject, int sentenceIndex) Parameters sentence Sentence jsonObject JsonObject sentenceIndex int Properties IsFrozen True when the parse result is held as a frozen UTF-8 snapshot instead of a live JsonObject graph — see Freeze(). public bool IsFrozen { get; } Property Value bool JsonObject Structured parse result built by syntax passes. While the piece is live (the default), this is the one mutable JsonObject every pipeline stage reads and writes. After Freeze(), the getter re-parses the frozen UTF-8 snapshot and returns a FRESH object on every call — treat it as a read-only snapshot: mutations land on the transient copy and are lost, and two calls return different object references. All mutating consumers run before the freeze boundary (see Freeze()), so downstream readers (NC optimization, writeback composition, GUI JSON panels) see identical content either way. Setting this property replaces the live object and discards any frozen snapshot. public JsonObject JsonObject { get; set; } Property Value JsonObject Sentence Indexed source line and block text for this piece. public Sentence Sentence { get; set; } Property Value Sentence SentenceIndex 0-based, session-globally unique ordinal in NC execution order. Stamped at piece construction time by GetSyntaxPieces(ISegmenter, List<INcDependency>, IEnumerable<IndexedFileLine>, int, NcDiagnosticProgress, CancellationToken) from the session's SentenceIndexCounterDependency: each piece allocates the next counter value as the lazy pipeline materializes it, so values are strictly increasing along the executed stream — subprogram / macro bodies inlined by SubProgramCallSyntax and friends interleave correctly between host blocks, including nested calls. Useful as a cross-process alignment key (messages, ClStripPos, MachiningStep) — unlike the (FileIndex, LineIndex) source order, it reflects execution order. Values are NOT contiguous per file: eager label scans (LabelScanUtil / RewindToLine) number the whole re-segmented file and discard the pre-label prefix, leaving gaps. Never negative — -1 stays reserved as the \"not in pipeline\" sentinel on downstream carriers. When the counter dependency is absent (legacy XML preset), numbering falls back to the caller's contiguous begin-index sequence, which can double-book across inline boundaries. Required at construction: the index is identity, not optional metadata. Read-only after construction; the pipeline guarantees one stamping per piece at the wrapping chokepoint. public int SentenceIndex { get; } Property Value int Methods Freeze() Replaces the live JsonObject graph with its compact UTF-8 serialization (~13× smaller live-memory footprint per retained piece), keeping the piece readable through the JsonObject getter via on-demand re-parse. Uses CompactNanOptions — the exact leaf encoding of ToLeafCompactJsonString(JsonNode, JsonSerializerOptions) — so the JSON projection of a frozen piece is byte-identical to the live one (NaN / Infinity serialize as quoted literal strings; explicit nulls survive). Call only after every mutating consumer of this piece has run — the session pipeline freezes a piece once it left the executing window (its semantics completed plus a lag margin; see MachiningProcs.NcRunnerSessionState). Idempotent; a piece with a null JsonObject stays null. Thread-safe against concurrent readers: they observe either the live graph or the frozen snapshot, never a torn state. public void Freeze() GetSentence() Returns the source Sentence carried by this object. public Sentence GetSentence() Returns Sentence ToString() Serialize with Hi.NcParsers.Syntaxs.NcSyntaxUtil.Options to support NaN/Infinity. public override string ToString() Returns string"
  },
  "api/Hi.NcParsers.Syntaxs.SyntaxStageKeys.html": {
    "href": "api/Hi.NcParsers.Syntaxs.SyntaxStageKeys.html",
    "title": "Class SyntaxStageKeys | HiAPI-C# 2025",
    "summary": "Class SyntaxStageKeys Namespace Hi.NcParsers.Syntaxs Assembly HiMech.dll Shared JSON key constants written by post-Logic and Inspection stage syntaxes. Central registry so the string literals do not drift across syntax files; readers of cache dumps can reference these constants directly rather than hard-coding the raw strings. public static class SyntaxStageKeys Inheritance object SyntaxStageKeys Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields AddedByKey Sub-object key that names the syntax which synthesized or copied the containing data. Values are short stage names: AddedByValue (\"Backfill\") — ProgramXyzBackfillSyntax computed the value via modal lookback (MC × inverse(transform) or GetLastProgramXyz(LazyLinkedListNode<SyntaxPiece>)). AddedByValue (\"ModalCarry\") — ModalCarrySyntax deep-cloned the section from the previous block so the current block carries its full modal context. Absent on sub-objects written by LogicSyntaxs-stage syntaxes — readers can filter by this key's presence to distinguish originally-authored data from pipeline-synthesized markers. public const string AddedByKey = \"AddedBy\" Field Value string"
  },
  "api/Hi.NcParsers.Syntaxs.SyntecSyntaxUtil.html": {
    "href": "api/Hi.NcParsers.Syntaxs.SyntecSyntaxUtil.html",
    "title": "Class SyntecSyntaxUtil | HiAPI-C# 2025",
    "summary": "Class SyntecSyntaxUtil Namespace Hi.NcParsers.Syntaxs Assembly HiMech.dll Syntec-specific NC syntax utilities. public static class SyntecSyntaxUtil Inheritance object SyntecSyntaxUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields VarTag Variable prefix for Syntec (same as Fanuc). public const string VarTag = \"#\" Field Value string Properties DefaultSyntaxList Syntax list for general kind of Syntec Controller. public static List<INcSyntax> DefaultSyntaxList { get; } Property Value List<INcSyntax> G05p1Syntax G05.1 with Syntec-specific R parameter (smoothing level). Placed before GenericSyntaxKit spread so it captures R before FloatTagValueSyntax does. public static ParameterizedFlagSyntax G05p1Syntax { get; } Property Value ParameterizedFlagSyntax"
  },
  "api/Hi.NcParsers.Syntaxs.TagValue.html": {
    "href": "api/Hi.NcParsers.Syntaxs.TagValue.html",
    "title": "Class TagValue | HiAPI-C# 2025",
    "summary": "Class TagValue Namespace Hi.NcParsers.Syntaxs Assembly HiMech.dll public record TagValue : IEquatable<TagValue> Inheritance object TagValue Implements IEquatable<TagValue> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks The term Tag generally accompanies with variable value. The term Flag generally not accompanies with variable value. Constructors TagValue(string, string, string) public TagValue(string Tag, string Value, string OriginalText) Parameters Tag string Value string OriginalText string Remarks The term Tag generally accompanies with variable value. The term Flag generally not accompanies with variable value. Properties OriginalText public string OriginalText { get; init; } Property Value string Tag public string Tag { get; init; } Property Value string Value public string Value { get; init; } Property Value string"
  },
  "api/Hi.NcParsers.Syntaxs.TransformationUtil.html": {
    "href": "api/Hi.NcParsers.Syntaxs.TransformationUtil.html",
    "title": "Class TransformationUtil | HiAPI-C# 2025",
    "summary": "Class TransformationUtil Namespace Hi.NcParsers.Syntaxs Assembly HiMech.dll Utilities for the ProgramToMcTransform chain. Each entry is {Source, Kind, Mat4d}; entries are composed in order with pure matrix multiplication (GetComposedTransform(JsonObject)). KindKey partitions the entries by contour validity: KindStatic — the matrix is valid across the whole block, applicable to any interpolated point along the contour. KindDynamic — the matrix is a block-endpoint snapshot of a rotary-state-dependent transform (RTCP rotary-dynamic). Composing it produces a correct endpoint MC, but interpolated points along the contour must be derived per-step by motion semantics (ClLinearMcMotionSemantic); do not apply it to interpolated ProgramXyz. Both kinds carry a real Mat4d so composition stays a pure matrix product — no entry has a missing matrix. Use HasDynamicEntry(JsonObject) to detect the dynamic-rotary state without consulting a sibling section flag. public static class TransformationUtil Inheritance object TransformationUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields KindDynamic The entry's Mat4d is a block-endpoint snapshot only; intermediate contour points must be resolved by per-step IK in motion semantics. public const string KindDynamic = \"Dynamic\" Field Value string KindKey JSON key for the entry's contour-validity classification. Value must be KindStatic or KindDynamic. public const string KindKey = \"Kind\" Field Value string KindStatic The entry's Mat4d is valid for any point along the contour. public const string KindStatic = \"Static\" Field Value string Mat4dKey JSON key for the Mat4d snapshot inside each chain entry. public const string Mat4dKey = \"Mat4d\" Field Value string PivotTransformSource Canonical source name for the RTCP pivot transform — the kinematic transform from Pn (post-G54, post-G68.2) to MC at the block's endpoint ABC. Contributed by PivotTransformationSyntax. Must be the last entry written into the chain so that all Pn-frame operations (tilt, tool-height, coord-offset) are accumulated before the final kinematic IK; this ordering is enforced by the syntax- chain registration order, not by the writer API. public const string PivotTransformSource = \"PivotTransform\" Field Value string SourceKey JSON key for the transform origin label inside each chain entry. public const string SourceKey = \"Source\" Field Value string ToolHeightCompensationSource Canonical source name for the tool-height-compensation entry (tool-normal · offset_mm along the current tool axis). Matches the ToolHeightCompensation section key read for Offset_mm. public const string ToolHeightCompensationSource = \"ToolHeightCompensation\" Field Value string Methods AddOrReplaceTransform(JsonObject, string, string, Mat4d) Adds or replaces a named transformation entry in the chain. If an entry with the same source already exists, it is replaced in-place. Otherwise the new entry is appended. kind must be KindStatic or KindDynamic. public static void AddOrReplaceTransform(JsonObject json, string source, string kind, Mat4d mat) Parameters json JsonObject source string kind string mat Mat4d GetComposedTransform(JsonObject) Composes all entries in the chain into a single block-endpoint Mat4d (left-to-right multiplication). Pure multiplication — no special cases, no kinematic lookup. The returned matrix is valid only for the block's endpoint state; see ProgramToMcTransform for the endpoint-semantic contract. public static Mat4d GetComposedTransform(JsonObject json) Parameters json JsonObject Returns Mat4d GetComposedTransformAtAbc(JsonObject, Vec3d, Vec3d, IMachineKinematics, double) Composes the chain into the Mat4d valid at an INTERPOLATED contour point whose rotary state is stepAbc_rad, by rebuilding every KindDynamic entry at that rotary state while keeping every KindStatic entry's stored snapshot. The per-step dual of GetComposedTransform(JsonObject), which is endpoint-only when the chain carries a Dynamic entry. public static Mat4d GetComposedTransformAtAbc(JsonObject json, Vec3d stepAbc_rad, Vec3d endpointAbc_rad, IMachineKinematics kinematics, double toolHeightOffset_mm) Parameters json JsonObject The block's JSON sections carrying the chain. stepAbc_rad Vec3d The interpolated point's MC rotary state in radians (NaN axes are treated as 0, mirroring ResolveEndpointAbc(LazyLinkedListNode<SyntaxPiece>, IMachineAxisConfig)). endpointAbc_rad Vec3d The block-endpoint MC rotary state in radians — the state the stored Dynamic snapshots were built at. kinematics IMachineKinematics The machine kinematics; null keeps every stored snapshot. toolHeightOffset_mm double The block's ToolHeightCompensation offset in mm (the value its Dynamic height entry was built with). Returns Mat4d Remarks Rebuild rules, per Dynamic entry source: ToolHeightCompensationSource — rebuilt with MakeToolHeightMat(IMachineKinematics, Vec3d, double) at stepAbc_rad and toolHeightOffset_mm: the same construction every writer uses (G43p4RtcpSyntax, SiemensTraoriSyntax), so at stepAbc_rad equal to the block-endpoint ABC the rebuilt matrix is bit-identical to the stored snapshot. PivotTransformSource — rebuilt anchor-agnostically as stored · K(endpointAbc) · K(stepAbc)⁻¹, recovering the writer's pre-pivot anchor (preFrameToPn = stored · K(endpointAbc), see MakePivotTransformMat(IMachineKinematics, Vec3d, Mat4d)) from the snapshot itself instead of assuming the NC pipeline's machine-zero anchor — the CLSF pivot (ClToMcTransformSyntax) folds a fixture-topology anchor into the same entry and stays correct here. Any other Dynamic source — kept as stored (no rebuild recipe; no shipped writer produces one). With a null kinematics every entry keeps its stored snapshot, collapsing to GetComposedTransform(JsonObject) — correct for the only kinematics-less Dynamic corner (the G43p4RtcpSyntax UnitZ height fallback, whose matrix does not depend on ABC). GetTransformBySource(JsonObject, string) Gets a specific entry's Mat4d by source name. Returns identity if not found. public static Mat4d GetTransformBySource(JsonObject json, string source) Parameters json JsonObject source string Returns Mat4d HasDynamicEntry(JsonObject) Returns true if any entry in the chain carries KindDynamic. Used by motion-form selection (LinearMotionSyntax) and ProgramXyz strategy dispatch (ProgramXyzUtil) to detect RTCP-rotary-dynamic state without consulting a flag on a sibling section. Throws if any entry lacks KindKey. public static bool HasDynamicEntry(JsonObject json) Parameters json JsonObject Returns bool MakePivotTransformMat(IMachineKinematics, Vec3d) Builds the PivotTransformSource Mat4d — an empirically-constructed Pn→MC rigid-affine transform at the block's endpoint ABC. Equivalent to kinematics.PnToMc(pn_input, normal).Point when applied to a Pn-frame point, but expressed as a reusable Mat4d so the chain stays a pure matrix product (no per-point IK call inside GetComposedTransform(JsonObject)). The pre-pivot anchor is the machine-zero attacher point McToPn(0).Point as a pure translation — the same origin anchor HardNc keeps in HardNcEnv.AttacherAtMcZeroOnTableCoordinate. Program-frame vectors already point along the Pn (table-buckle) axes, so only K(0)'s translation may enter the anchor. Folding the full K(0) (its linear part encodes per-axis motion sense — a workpiece-side linear axis contributes a negated row) would flip those axes' program components before the IK; on a machine whose Z rides the table (e.g. the B-x7000 WAC chain, table branch Base→Z→B→W) that mirrored every program Z and, at B≈180°, threw the resolved MC off by twice the pivot-to-attacher distance (~3.5 m). Requiring machine files to be modelled the other way instead — workpiece-side axes negative, which makes K(0)'s linear part the identity and the two constructions equivalent — was evaluated as an alternative to this fix and deliberately rejected. IMachineKinematics resolves either axis direction, so a file that positions correctly through PnToMc(DVec3d, out DVec3d) has to position correctly through this transform as well; a precondition enforced here and nowhere else would only make one consumer diverge from the kinematics on files every other consumer accepts. The modelling convention governs how MC values read against the machine panel, and belongs to a check on the data when it loads — never to this matrix. Constructed by probing McToPn(DVec3d) at the four standard basis points (origin + XYZ unit vectors) at the target ABC to derive K(abc); returns T(McToPn(0).Point) · K(abc).GetInverse(). Topology- agnostic — works for any affine kinematic chain regardless of axis order. Legacy PnToMc(DVec3d, out DVec3d) remains the reference oracle. public static Mat4d MakePivotTransformMat(IMachineKinematics kinematics, Vec3d abc_rad) Parameters kinematics IMachineKinematics abc_rad Vec3d Returns Mat4d MakePivotTransformMat(IMachineKinematics, Vec3d, Mat4d) Variant anchored to an arbitrary pre-pivot frame: builds the PivotTransformSource Mat4d preFrameToPn · K(abc)⁻¹ that maps a point of the chain's accumulated pre-pivot frame directly to MC at the block's endpoint ABC. The two-parameter overload is this variant specialised to the NC pipeline's machine-zero program frame (preFrameToPn = T(McToPn(0).Point), translation only — see its remarks for why K(0)'s linear part must stay out); the CLSF pipeline passes its workpiece→Pn fixture-topology matrix instead, so the pivot entry absorbs the workpiece placement together with the kinematics. public static Mat4d MakePivotTransformMat(IMachineKinematics kinematics, Vec3d abc_rad, Mat4d preFrameToPn) Parameters kinematics IMachineKinematics abc_rad Vec3d preFrameToPn Mat4d Returns Mat4d MakeToolHeightMat(IMachineKinematics, Vec3d, double) Builds the tool-height-compensation Mat4d for a given rotary state: translate by (tool-normal at abc_rad) · height_mm. Pure translation (no rotation component); combines with the downstream PivotTransformSource to form the full Pn→MC IK. public static Mat4d MakeToolHeightMat(IMachineKinematics kinematics, Vec3d abc_rad, double height_mm) Parameters kinematics IMachineKinematics abc_rad Vec3d height_mm double Returns Mat4d"
  },
  "api/Hi.NcParsers.Syntaxs.html": {
    "href": "api/Hi.NcParsers.Syntaxs.html",
    "title": "Namespace Hi.NcParsers.Syntaxs | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers.Syntaxs Classes BundleSyntax Depth-First Sequential Syntaxes management. It saves space by save the LazyLinkedLists from each syntax to only one LazyLinkedLists in SoftNcRunner to get better performance. If the INcSyntax only edit the current node itself, those self-editing INcSyntax without looks-forward is suitable to put into the BundleSyntax. FanucSyntaxUtil Pre-built ParameterizedFlagSyntax / flag patterns for Fanuc-style NC text. GenericSyntaxKit Generic/ISO standard syntax kit. Involve G code. Contains syntax definitions for common G codes used across multiple NC systems. HeidenhainSyntaxUtil Pre-built parsing syntax fragments for Heidenhain-style programs (Q variables, FMAX/FAUTO, etc.). MazakSyntaxUtil Mazak-specific NC syntax utilities. NcSyntaxUtil JSON serialization settings and grab/set helpers for NC block JsonObject trees. SiemensSyntaxUtil Pre-built parsing syntax fragments for Siemens-style programs (R parameters, TRAORI, etc.). SyntaxPiece One NC block's source line paired with its parsed JSON payload during soft-NC processing. SyntaxStageKeys Shared JSON key constants written by post-Logic and Inspection stage syntaxes. Central registry so the string literals do not drift across syntax files; readers of cache dumps can reference these constants directly rather than hard-coding the raw strings. SyntecSyntaxUtil Syntec-specific NC syntax utilities. TagValue TransformationUtil Utilities for the ProgramToMcTransform chain. Each entry is {Source, Kind, Mat4d}; entries are composed in order with pure matrix multiplication (GetComposedTransform(JsonObject)). KindKey partitions the entries by contour validity: KindStatic — the matrix is valid across the whole block, applicable to any interpolated point along the contour. KindDynamic — the matrix is a block-endpoint snapshot of a rotary-state-dependent transform (RTCP rotary-dynamic). Composing it produces a correct endpoint MC, but interpolated points along the contour must be derived per-step by motion semantics (ClLinearMcMotionSemantic); do not apply it to interpolated ProgramXyz. Both kinds carry a real Mat4d so composition stays a pure matrix product — no entry has a missing matrix. Use HasDynamicEntry(JsonObject) to detect the dynamic-rotary state without consulting a sibling section flag. Interfaces IExpandingNcSyntax Expanding syntax: transforms one SyntaxPiece node into zero or more output pieces (e.g., subprogram inlining, macro expansion, conditional branching). INcSyntax Base interface for syntax-level data transformation on SyntaxPiece.JsonObject. Unlike INcSemantic which produces IAct, INcSyntax only restructures or enriches parsed data without producing actions. ISituNcSyntax In-situ syntax: mutates the JsonObject of the given node in-place without changing the node count. Most parsing and logic syntaxes implement this interface. Delegates ExpressionPrefixParser Longest-valid-prefix expression parse over source: returns true with consumedLength set to the number of leading characters forming a valid expression (the grammar decides where a captured RHS ends), or false when not even a prefix parses. Capture syntaxes take this as an optional hook so the assignment/tag grammars stay decoupled from any concrete expression parser (see NcExpressionDialectUtil.TryParsePrefix)."
  },
  "api/Hi.NcParsers.html": {
    "href": "api/Hi.NcParsers.html",
    "title": "Namespace Hi.NcParsers | HiAPI-C# 2025",
    "summary": "Namespace Hi.NcParsers Classes ControllerPresetWriter Writes the built-in brand controller presets out as standalone SoftNcRunner resource files. A controller resource file is one serialized SoftNcRunner — the whole pipeline (dependencies, segmenter, initializers, syntaxes, semantics) that decides how a brand's NC code is interpreted. The shipped copies live under Resource/Controller/ so the Object Management Load browser starts populated; they are regenerable snapshots, not the source of truth — the brand properties on SoftNcRunner are. Writing needs no XFactory registration. Reading a file back does: call Reg(XFactory) first, otherwise XFactory.GenListSkippingUnloadable drops every unregistered pipeline entry and hands back a silently hollow runner. NcCompositionGate License gate for the NC composition layer — the capability of registering external (non-built-in) processing units into a SoftNcRunner pipeline, and of executing NC-embedded C# scripts (ActLineCsScript). The boundary: the script layer (calling the public API from your own application code, e.g. session scripts) needs no extra license; the composition layer (registering or replacing processing units inside the interpretation pipeline — NcSyntaxList, PipelineNcDependencyList, NcSemanticList, NcInitializationList, Segmenter — or injecting per-line scripts into it) requires NcComposition. A unit is built-in when its concrete type lives in this library's own assembly; anything else is external. Order, count, duplication and constructor configuration of built-in units are unrestricted — the gate never inspects the shape of the pipeline, only the identity of each unit. Degradation is silent and functional: without the license the built-in dialects run unchanged; external units are skipped for the session and a single Composition--NotLicensed diagnostic lists them. The decision and its rejection record live in the native license module. NcDiagnostic A structured diagnostic from the SoftNcRunner pipeline, designed for IProgress<T> consumption. Implements IMessage so it shares the common message channel with SimpleMessage, step diagnostics, and progress fractions, while additionally carrying an NC-source SentenceCarrier anchor that non-NC messages do not have. Also an ISentenceCarrier itself — GetSentence() and SentenceIndex delegate to SentenceCarrier so a diagnostic can be used directly anywhere a carrier is expected, without the consumer unwrapping the inner anchor. Id is composed as {Primary}-{Secondary}--{Abbrev} (e.g., Cycle-Peck--BadPeckQ, Syntax-Build--Exception). For irregular cases that don't fit the pattern, use a custom string. NcDiagnosticProgress Helper that emits NcDiagnostic records — retaining them in Diagnostics (their canonical home) and forwarding each to an IProgress<T> of IMessage sink for live consumption. Provides one method per (Category, Severity) pair, each with an optional Sentence overload locating the issue in the NC source. Each method has a *Fmt sibling taking a FormattableString that keeps the interpolated template and values (Format / Args) for client-side localization; the sibling must be opted into by name — an interpolated string literal passed to the string method binds to string and is not captured. A caller that runs a bounded operation (an NC play, a writeback run) can wrap it in BeginRepeatFold() so identical repeated diagnostics fold into a first occurrence plus one counted summary instead of flooding the sink. NcRunnerSuit A switchable “runner suit”: bundles the per-machine NC pipeline (SoftNcRunner plus its optional side-file path SoftNcRunnerFile) with the per-workpiece PerCaseNcDependencyList the runner's INcDependencyProxy placeholders resolve against. The suit is the proxies' INcDependencyListHost, so the runner and its case data switch together as one unit — load a different suit to switch the active parser (NC or CSV) within a session. Read/Write only (pure IO, no own XxxFile identity pointer): the owning project serializes the suit's two members flat in the project XML, keeping the per-workpiece PerCaseNcDependencyList project-local rather than a shared side file. Sentence A small NC block for one or several lines. SoftNcRunner Configurable NC Runner. SoftNcUtil JSON helpers for soft-NC blocks: vectors under Parsing, motion-term queries, flag grab/remove on raw text, and unparsed-line trimming. Interfaces IGetSentence Abstraction for a source that carries a Sentence. ISentenceCarrier Carries a reference to a source Sentence together with its execution-order SentenceIndex. Used as the cross-process alignment carrier for diagnostics, messages, ClStripPos, MachiningStep, etc. — both the source content (via GetSentence()) and the execution-order position (via SentenceIndex) are available without needing two separate references. ISentenceIndexed Abstraction for an object that carries a SentenceIndex — a 0-based ordinal of its source Sentence in NC execution order. Use as a cross-process alignment key (messages, ClStripPos, MachiningStep, etc.) when the (FileIndex, LineIndex) source order is not enough because SubProgram inline reorders blocks relative to source order. ISessionResettable Marker for objects that hold session-scoped runtime state which must be cleared when RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) initializes a new session pipeline (the state.IsInitialized == false edge). Implementers may live on either chain: INcDependency or INcSyntax. SoftNcRunner scans PipelineNcDependencyList and NcSyntaxList on the session-init edge and calls OnSessionReset() on every match. Distinct from IPowerResettable: power-reset clears retained-but-volatile state on a controller power cycle (e.g., Fanuc #100-#499), an edge that survives ordinary session boundaries. Session-reset clears state whose lifetime is one pipeline pass (iteration counters, file-index allocators, etc.)."
  },
  "api/Hi.Numerical.Acts.ActActualDateTime.html": {
    "href": "api/Hi.Numerical.Acts.ActActualDateTime.html",
    "title": "Class ActActualDateTime | HiAPI-C# 2025",
    "summary": "Class ActActualDateTime Namespace Hi.Numerical.Acts Assembly HiMech.dll Represents an action that records the absolute controller timestamp (wall-clock DateTime) for a machine step. Parallel to ActActualTimecode: that act carries the run-relative timecode (a TimeSpan), this one preserves the raw calendar instant so the date is not lost — converting between the two is the mapping anchor's job, done once at the boundary. public class ActActualDateTime : IActMachineStep, IAct Inheritance object ActActualDateTime Implements IActMachineStep IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActActualDateTime(DateTime) Initializes a new instance of the ActActualDateTime class. public ActActualDateTime(DateTime actualDateTime) Parameters actualDateTime DateTime The absolute controller timestamp for the machine step. Properties ActualDateTime Gets or sets the absolute controller timestamp for the machine step. public DateTime ActualDateTime { get; set; } Property Value DateTime Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActActualTimecode.html": {
    "href": "api/Hi.Numerical.Acts.ActActualTimecode.html",
    "title": "Class ActActualTimecode | HiAPI-C# 2025",
    "summary": "Class ActActualTimecode Namespace Hi.Numerical.Acts Assembly HiMech.dll Represents an action that sets the actual time for a machine step. public class ActActualTimecode : IActMachineStep, IAct Inheritance object ActActualTimecode Implements IActMachineStep IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActActualTimecode(TimeSpan) Initializes a new instance of the ActActualTimecode class. public ActActualTimecode(TimeSpan actualTime) Parameters actualTime TimeSpan The actual time for the machine step. Properties ActualTimecode Gets or sets the actual time for the machine step. public TimeSpan ActualTimecode { get; set; } Property Value TimeSpan Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActClArc.html": {
    "href": "api/Hi.Numerical.Acts.ActClArc.html",
    "title": "Class ActClArc | HiAPI-C# 2025",
    "summary": "Class ActClArc Namespace Hi.Numerical.Acts Assembly HiMech.dll Represents an arc movement action for cutter location. public class ActClArc : IActClMove, IActDuration, IAct Inheritance object ActClArc Implements IActClMove IActDuration IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ActUtil.GetClSteps(IActClMove, int, IMachiningMotionResolution) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActClArc(ClCircleArc, TimeSpan) Initializes a new instance of the ActClArc class. public ActClArc(ClCircleArc path, TimeSpan duration) Parameters path ClCircleArc The circle arc path. duration TimeSpan The total duration of the arc action. Properties ActDuration Gets or sets the duration of the action. public TimeSpan ActDuration { get; set; } Property Value TimeSpan Remarks The duration represents: The time required to complete the action Should be positive and finite Zero duration indicates an instantaneous action Used for scheduling and timing calculations ClCircleArc Gets or sets the cutter location circle arc. public ClCircleArc ClCircleArc { get; set; } Property Value ClCircleArc Methods GetClPath() Gets the cutter location path. public IClPath GetClPath() Returns IClPath The cutter location path. GetClSteps(IMachiningMotionResolution) Gets a sequence of steps split from this movement under the specified NC resolution. public IEnumerable<ActClStep> GetClSteps(IMachiningMotionResolution ncResolution) Parameters ncResolution IMachiningMotionResolution The machining motion resolution. Returns IEnumerable<ActClStep> A sequence of ActClStep. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActClArcMcXyzabcContour.html": {
    "href": "api/Hi.Numerical.Acts.ActClArcMcXyzabcContour.html",
    "title": "Class ActClArcMcXyzabcContour | HiAPI-C# 2025",
    "summary": "Class ActClArcMcXyzabcContour Namespace Hi.Numerical.Acts Assembly HiMech.dll Arc twin of ActClLinearMcXyzabcContour: a circular cutter location path realized on machine coordinates. The arc is interpolated in CL space (true arc via At(double), including tilting normals) and every resampled step is inverse-solved through PnToMc(DVec3d, out DVec3d). public class ActClArcMcXyzabcContour : IActDuration, IActMcXyzabcContour, IAct Inheritance object ActClArcMcXyzabcContour Implements IActDuration IActMcXyzabcContour IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks Differences from the linear twin: The step normal comes from the arc geometry itself (At(double)), not from a forward-kinematic probe of interpolated ABC — the CL source is the truth for tool orientation. Rotary unwrap anchoring chains step-to-step (each solved ABC is anchored to the previous step's) because the ABC path of an arc is not linear; the first step anchors to McSeq.pre. The arc geometry must already be expressed in the kinematic Pn frame (workpiece→Pn transform applied by the emitting semantic). Constructors ActClArcMcXyzabcContour(ClCircleArc, SeqPair<DVec3d>, double, TimeSpan, IMachineKinematics) Initializes a new instance of the ActClArcMcXyzabcContour class. public ActClArcMcXyzabcContour(ClCircleArc clArcOnPn, SeqPair<DVec3d> mcSeq, double controllerToolOffset, TimeSpan duration, IMachineKinematics coordinateConverter) Parameters clArcOnPn ClCircleArc Circular CL path in the kinematic Pn frame mcSeq SeqPair<DVec3d> Machine coordinate endpoint pair (rotary in radians) controllerToolOffset double The tool's attacher→tip length duration TimeSpan Duration of the contour movement coordinateConverter IMachineKinematics Coordinate converter for transformation Properties ActDuration Gets or sets the duration of the action. public TimeSpan ActDuration { get; set; } Property Value TimeSpan Remarks The duration represents: The time required to complete the action Should be positive and finite Zero duration indicates an instantaneous action Used for scheduling and timing calculations ClArcOnPn The circular CL path in the kinematic Pn frame; its points are tool tip positions and its normals tool axis directions. public ClCircleArc ClArcOnPn { get; set; } Property Value ClCircleArc ControllerToolOffset The active tool's attacher→tip length; reconstructs the attacher position from a CL tip point. public double ControllerToolOffset { get; set; } Property Value double CoordinateConverter Coordinate converter. public IMachineKinematics CoordinateConverter { get; set; } Property Value IMachineKinematics McSeq Machine-coordinate endpoints (begin/end); rotary components in radians. Used for the step count estimate and as the unwrap anchor of the first resampled step. public SeqPair<DVec3d> McSeq { get; set; } Property Value SeqPair<DVec3d> Methods GetActMcXyzabcSteps(IMachiningMotionResolution, double, Action<object>) Gets the machine XYZABC steps for this contour. public IEnumerable<ActMcXyzabcStep> GetActMcXyzabcSteps(IMachiningMotionResolution ncResolution, double spindleBuckleToToolTipLength, Action<object> coordinateConversionFailedAction) Parameters ncResolution IMachiningMotionResolution The machining motion resolution to use for step generation. spindleBuckleToToolTipLength double The length from spindle buckle to tool tip, used for computing step numbers. coordinateConversionFailedAction Action<object> Called when attacher NP to MC conversion fails; the argument is the failed DVec3d (attacher NP). Returns IEnumerable<ActMcXyzabcStep> A collection of machine XYZABC steps. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActClLinear.html": {
    "href": "api/Hi.Numerical.Acts.ActClLinear.html",
    "title": "Class ActClLinear | HiAPI-C# 2025",
    "summary": "Class ActClLinear Namespace Hi.Numerical.Acts Assembly HiMech.dll Represents a linear cutter location movement action. public class ActClLinear : IActClMove, IActDuration, IAct Inheritance object ActClLinear Implements IActClMove IActDuration IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ActUtil.GetClSteps(IActClMove, int, IMachiningMotionResolution) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActClLinear(ClLinear, TimeSpan?) Initializes a new instance of the ActClLinear class with the specified path. public ActClLinear(ClLinear path, TimeSpan? duration = null) Parameters path ClLinear The linear cutter location path. duration TimeSpan? Optional total duration of the linear action. ActClLinear(DVec3d, DVec3d, TimeSpan?) Initializes a new instance of the ActClLinear class with begin and end cutter locations. public ActClLinear(DVec3d beginCl, DVec3d endCl, TimeSpan? duration = null) Parameters beginCl DVec3d The begin cutter location. endCl DVec3d The end cutter location. duration TimeSpan? Optional total duration of the linear action. Properties ActDuration Gets or sets the duration of the action. public TimeSpan ActDuration { get; set; } Property Value TimeSpan Remarks The duration represents: The time required to complete the action Should be positive and finite Zero duration indicates an instantaneous action Used for scheduling and timing calculations ClLinear Gets or sets the linear cutter location path. public ClLinear ClLinear { get; set; } Property Value ClLinear Methods GetClPath() Retrieves the cutter location path. public IClPath GetClPath() Returns IClPath The cutter location path. GetClSteps(IMachiningMotionResolution) Gets a sequence of steps split from this movement under the specified NC resolution. public IEnumerable<ActClStep> GetClSteps(IMachiningMotionResolution ncResolution) Parameters ncResolution IMachiningMotionResolution The machining motion resolution. Returns IEnumerable<ActClStep> A sequence of ActClStep. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActClLinearMcXyzabcContour.html": {
    "href": "api/Hi.Numerical.Acts.ActClLinearMcXyzabcContour.html",
    "title": "Class ActClLinearMcXyzabcContour | HiAPI-C# 2025",
    "summary": "Class ActClLinearMcXyzabcContour Namespace Hi.Numerical.Acts Assembly HiMech.dll Represents a combined linear movement in both cutter location and machine coordinates. This class handles synchronized linear interpolation of tool position and orientation. public class ActClLinearMcXyzabcContour : IActDuration, IActMcXyzabcContour, IAct Inheritance object ActClLinearMcXyzabcContour Implements IActDuration IActMcXyzabcContour IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks This class is used for: Complex 5-axis machining movements Synchronized tool path and orientation control Linear interpolation in multiple coordinate systems Precise tool position and orientation control The movement combines: Linear cutter location interpolation Linear machine coordinate ABC interpolation Synchronized motion control Constructors ActClLinearMcXyzabcContour(SeqPair<DVec3d>, SeqPair<Vec3d>, double, TimeSpan, IMachineKinematics) Initializes a new instance of the ActClLinearMcXyzabcContour class. public ActClLinearMcXyzabcContour(SeqPair<DVec3d> mcSeq, SeqPair<Vec3d> controllerClPointSeq, double controllerToolOffset, TimeSpan duration, IMachineKinematics coordinateConverter) Parameters mcSeq SeqPair<DVec3d> Machine coordinate sequence pair controllerClPointSeq SeqPair<Vec3d> Controller CL point sequence pair controllerToolOffset double Controller's tool height compensation value duration TimeSpan Duration of the contour movement coordinateConverter IMachineKinematics Coordinate converter for transformation Properties ActDuration Gets or sets the duration of the action. public TimeSpan ActDuration { get; set; } Property Value TimeSpan Remarks The duration represents: The time required to complete the action Should be positive and finite Zero duration indicates an instantaneous action Used for scheduling and timing calculations ControllerClPointSeq Controller CL (cutter location) point sequence pair. Computed from controller's compensation height (offset table). Represents where the controller believes the tool tip is. Linearly interpolated during motion resolution. public SeqPair<Vec3d> ControllerClPointSeq { get; set; } Property Value SeqPair<Vec3d> ControllerToolOffset Controller's tool height compensation value from the offset table. Used to reconstruct attacher position from controller CL. public double ControllerToolOffset { get; set; } Property Value double CoordinateConverter Coordinate Converter. public IMachineKinematics CoordinateConverter { get; set; } Property Value IMachineKinematics McSeq Gets or sets the machine coordinate sequence pair. The Normal property represents ABC angles in radians. public SeqPair<DVec3d> McSeq { get; set; } Property Value SeqPair<DVec3d> Remarks Contains: Start and end positions in machine coordinates Tool orientation angles (ABC) in radians Used for orientation interpolation Methods GetActMcXyzabcSteps(IMachiningMotionResolution, double, Action<object>) Gets the machine XYZABC steps for this contour. public IEnumerable<ActMcXyzabcStep> GetActMcXyzabcSteps(IMachiningMotionResolution ncResolution, double spindleBuckleToToolTipLength, Action<object> coordinateConversionFailedAction) Parameters ncResolution IMachiningMotionResolution The machining motion resolution to use for step generation. spindleBuckleToToolTipLength double The length from spindle buckle to tool tip, used for computing step numbers. coordinateConversionFailedAction Action<object> Called when attacher NP to MC conversion fails; the argument is the failed DVec3d (attacher NP). Returns IEnumerable<ActMcXyzabcStep> A collection of machine XYZABC steps. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActClStep.html": {
    "href": "api/Hi.Numerical.Acts.ActClStep.html",
    "title": "Class ActClStep | HiAPI-C# 2025",
    "summary": "Class ActClStep Namespace Hi.Numerical.Acts Assembly HiMech.dll Represents a single cutter-location step with optional duration. public class ActClStep : IActMachineStep, IActDuration, IAct Inheritance object ActClStep Implements IActMachineStep IActDuration IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActClStep(DVec3d, TimeSpan?) Initializes a new instance with the specified cutter location. public ActClStep(DVec3d cl, TimeSpan? timeSpan = null) Parameters cl DVec3d The cutter location vector. timeSpan TimeSpan? Optional duration of this step. Properties ActDuration Gets or sets the duration of the action. public TimeSpan ActDuration { get; set; } Property Value TimeSpan Remarks The duration represents: The time required to complete the action Should be positive and finite Zero duration indicates an instantaneous action Used for scheduling and timing calculations Cl Gets or sets the cutter location vector. public DVec3d Cl { get; set; } Property Value DVec3d Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActClTeleport.html": {
    "href": "api/Hi.Numerical.Acts.ActClTeleport.html",
    "title": "Class ActClTeleport | HiAPI-C# 2025",
    "summary": "Class ActClTeleport Namespace Hi.Numerical.Acts Assembly HiMech.dll Represents a teleport action for cutter location, allowing instant position change without movement. public class ActClTeleport : IActDuration, IAct Inheritance object ActClTeleport Implements IActDuration IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActClTeleport(DVec3d, TimeSpan?) Initializes a new instance of the ActClTeleport class with the specified cutter location. public ActClTeleport(DVec3d cl, TimeSpan? timeSpan = null) Parameters cl DVec3d The cutter location vector. timeSpan TimeSpan? Optional duration of this action. Properties ActDuration Gets or sets the duration of the action. public TimeSpan ActDuration { get; set; } Property Value TimeSpan Remarks The duration represents: The time required to complete the action Should be positive and finite Zero duration indicates an instantaneous action Used for scheduling and timing calculations Cl Gets or sets the cutter location vector. public DVec3d Cl { get; set; } Property Value DVec3d Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActCooling.html": {
    "href": "api/Hi.Numerical.Acts.ActCooling.html",
    "title": "Class ActCooling | HiAPI-C# 2025",
    "summary": "Class ActCooling Namespace Hi.Numerical.Acts Assembly HiMech.dll Represents a coolant state transition — the cutting-fluid delivery mode changes on the machine (from e.g. Off to Flood). Emitted by CoolantSemantic when the NC program executes M07/M08/M09. public class ActCooling : IAct Inheritance object ActCooling Implements IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActCooling(CoolantMode) Initializes a new instance with an explicit coolant mode. public ActCooling(CoolantMode mode) Parameters mode CoolantMode ActCooling(bool) Initializes a new instance from a legacy on/off bool. true maps to Flood (the pre-mist default); false maps to Off. public ActCooling(bool isOn) Parameters isOn bool Properties IsOn Whether any coolant stream is active (Flood or Mist). Kept for callers that only care about on/off and predate the CoolantMode distinction. public bool IsOn { get; } Property Value bool Mode The coolant delivery mode after this act has taken effect. public CoolantMode Mode { get; set; } Property Value CoolantMode Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActData.html": {
    "href": "api/Hi.Numerical.Acts.ActData.html",
    "title": "Class ActData | HiAPI-C# 2025",
    "summary": "Class ActData Namespace Hi.Numerical.Acts Assembly HiMech.dll Action that add data to the step. The data is maybe from the sensor or computed, etc.. public class ActData : IAct Inheritance object ActData Implements IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActData() Initializes a new instance of the ActData class. public ActData() ActData(Dictionary<string, object>) Initializes a new instance of the ActData class with the specified data. public ActData(Dictionary<string, object> data) Parameters data Dictionary<string, object> The data dictionary containing key-value pairs. Properties Data Gets or sets the data dictionary containing key-value pairs. public Dictionary<string, object> Data { get; set; } Property Value Dictionary<string, object> Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActDelay.html": {
    "href": "api/Hi.Numerical.Acts.ActDelay.html",
    "title": "Class ActDelay | HiAPI-C# 2025",
    "summary": "Class ActDelay Namespace Hi.Numerical.Acts Assembly HiMech.dll Represents a delay action in machining operations. This class implements a simple time delay in the machining process. public class ActDelay : IActDuration, IAct Inheritance object ActDelay Implements IActDuration IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks Use this class when you need to: Insert a pause in the machining process Implement dwell operations Synchronize timing between operations Allow for cooldown or settling time The delay is implemented as a passive wait without active control. Constructors ActDelay() Initializes a new instance of the ActDelay class with default duration. The default duration is set to TimeSpan.Zero. public ActDelay() ActDelay(TimeSpan) Initializes a new instance of the ActDelay class with the specified delay duration. public ActDelay(TimeSpan delay) Parameters delay TimeSpan The duration of the delay. This value represents: The time to pause the operation Should be non-negative Typically used for dwells or synchronization Properties ActDuration Gets or sets the duration of the action. public TimeSpan ActDuration { get; set; } Property Value TimeSpan Remarks The duration represents: The time required to complete the action Should be positive and finite Zero duration indicates an instantaneous action Used for scheduling and timing calculations Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActFeedrate.html": {
    "href": "api/Hi.Numerical.Acts.ActFeedrate.html",
    "title": "Class ActFeedrate | HiAPI-C# 2025",
    "summary": "Class ActFeedrate Namespace Hi.Numerical.Acts Assembly HiMech.dll A feedrate action: the controller's commanded feedrate of the CL point (CommandedClFeedrate_mmds). public class ActFeedrate : IAct Inheritance object ActFeedrate Implements IAct Derived ActRapid Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActFeedrate() Initializes a new instance of the ActFeedrate class with default feedrate. public ActFeedrate() ActFeedrate(double) Initializes a new instance of the ActFeedrate class with the specified feedrate. public ActFeedrate(double commandedClFeedrate_mmds) Parameters commandedClFeedrate_mmds double The commanded CL feedrate in millimeters per second. Properties CommandedClFeedrate_mmdmin CommandedClFeedrate_mmds in millimeters per minute. public double CommandedClFeedrate_mmdmin { get; set; } Property Value double CommandedClFeedrate_mmds The controller's commanded feedrate of the CL point in millimeters per second: the F word after G94/G95/G93 conversion, or for a rapid the CL path over the act duration. It is the feedrate of the point the controller moves, not of the equipped tool's tip; the two differ when the active tool-length offset does not describe the equipped tool. public double CommandedClFeedrate_mmds { get; set; } Property Value double Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActHiddenStateChanged.html": {
    "href": "api/Hi.Numerical.Acts.ActHiddenStateChanged.html",
    "title": "Class ActHiddenStateChanged | HiAPI-C# 2025",
    "summary": "Class ActHiddenStateChanged Namespace Hi.Numerical.Acts Assembly HiMech.dll Represents an action that indicates a change in the hidden state of an object. This action is typically skipped during normal processing. public class ActHiddenStateChanged : IActSkip, IAct Inheritance object ActHiddenStateChanged Implements IActSkip IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActHiddenStateChanged() Initializes a new instance of the ActHiddenStateChanged class. public ActHiddenStateChanged() Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActIntentionalSkip.html": {
    "href": "api/Hi.Numerical.Acts.ActIntentionalSkip.html",
    "title": "Class ActIntentionalSkip | HiAPI-C# 2025",
    "summary": "Class ActIntentionalSkip Namespace Hi.Numerical.Acts Assembly HiMech.dll Represents an action that is intentionally skipped during processing. Used to explicitly mark operations that should be bypassed. public class ActIntentionalSkip : IActSkip, IAct Inheritance object ActIntentionalSkip Implements IActSkip IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActIntentionalSkip() Initializes a new instance of the ActIntentionalSkip class. public ActIntentionalSkip() Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActLineBegin.html": {
    "href": "api/Hi.Numerical.Acts.ActLineBegin.html",
    "title": "Class ActLineBegin | HiAPI-C# 2025",
    "summary": "Class ActLineBegin Namespace Hi.Numerical.Acts Assembly HiMech.dll Represents the beginning of a line act in numerical control operations. public class ActLineBegin : IAct Inheritance object ActLineBegin Implements IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActLineBegin() Initializes a new instance of the ActLineBegin class. public ActLineBegin() ActLineBegin(IGetSentence) Initializes a new instance of the ActLineBegin class with a source command. public ActLineBegin(IGetSentence sourceCommand) Parameters sourceCommand IGetSentence The source command associated with this line beginning. Properties SourceCommand Gets or sets the source command associated with this line beginning. public IGetSentence SourceCommand { get; set; } Property Value IGetSentence Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActLineCsScript.html": {
    "href": "api/Hi.Numerical.Acts.ActLineCsScript.html",
    "title": "Class ActLineCsScript | HiAPI-C# 2025",
    "summary": "Class ActLineCsScript Namespace Hi.Numerical.Acts Assembly HiMech.dll Cs Script on one Line. public class ActLineCsScript : IAct Inheritance object ActLineCsScript Implements IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActLineCsScript() Initializes a new instance of the ActLineCsScript class. public ActLineCsScript() ActLineCsScript(string) Initializes a new instance of the ActLineCsScript class with the specified script text. public ActLineCsScript(string scriptText) Parameters scriptText string The C# script text to be executed. Properties ScriptText Gets or sets the C# script text to be executed. public string ScriptText { get; set; } Property Value string Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActLineEnd.html": {
    "href": "api/Hi.Numerical.Acts.ActLineEnd.html",
    "title": "Class ActLineEnd | HiAPI-C# 2025",
    "summary": "Class ActLineEnd Namespace Hi.Numerical.Acts Assembly HiMech.dll Represents the end of a line act in numerical control operations. public class ActLineEnd : IAct Inheritance object ActLineEnd Implements IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActLineEnd() Initializes a new instance of the ActLineEnd class. public ActLineEnd() ActLineEnd(ActLineBegin) Initializes a new instance of the ActLineEnd class with a specified line beginning act. public ActLineEnd(ActLineBegin actLineBegin) Parameters actLineBegin ActLineBegin The line beginning act associated with this line end. Properties ActLineBegin Gets or sets the associated line beginning act. public ActLineBegin ActLineBegin { get; set; } Property Value ActLineBegin SourceCommand Gets the source command from the associated line beginning act. public IIndexedFileLine SourceCommand { get; } Property Value IIndexedFileLine Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActMcPolarLinearContour.html": {
    "href": "api/Hi.Numerical.Acts.ActMcPolarLinearContour.html",
    "title": "Class ActMcPolarLinearContour | HiAPI-C# 2025",
    "summary": "Class ActMcPolarLinearContour Namespace Hi.Numerical.Acts Assembly HiMech.dll Polar MCZ linear contour. public class ActMcPolarLinearContour : IActDuration, IActMcXyzabcContour, IAct Inheritance object ActMcPolarLinearContour Implements IActDuration IActMcXyzabcContour IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActMcPolarLinearContour(DVec3d, SeqPair<Vec3d>, TimeSpan, double, PolarModeDirEnum) Initializes a new instance of the ActMcPolarLinearContour class. public ActMcPolarLinearContour(DVec3d preMcXyzabc_rad, SeqPair<Vec3d> programPolarXczSeq, TimeSpan duration, double zCoordinateOffset, PolarModeDirEnum polarDir = PolarModeDirEnum.XC) Parameters preMcXyzabc_rad DVec3d Previous machine XYZ-ABC coordinates in radians programPolarXczSeq SeqPair<Vec3d> Program polar XCZ sequence pair duration TimeSpan Duration of the contour movement zCoordinateOffset double Depth-axis (plane normal) offset polarDir PolarModeDirEnum Polar axis pair (default XC) Properties ActDuration Gets or sets the duration of the action. public TimeSpan ActDuration { get; set; } Property Value TimeSpan Remarks The duration represents: The time required to complete the action Should be positive and finite Zero duration indicates an instantaneous action Used for scheduling and timing calculations PolarDir The polar axis pair mapping the triple-space steps onto machine axes (XC unless the machine runs G12.1 on YA/ZB). public PolarModeDirEnum PolarDir { get; } Property Value PolarModeDirEnum ProgramPolarXczSeq Gets or sets the program polar XCZ sequence pair. public SeqPair<Vec3d> ProgramPolarXczSeq { get; set; } Property Value SeqPair<Vec3d> Remarks Contains the start and end points in polar XCZ coordinates for interpolation in polar coordinate system. Methods GetActMcXyzabcSteps(IMachiningMotionResolution, double, Action<object>) Gets the machine XYZABC steps for this contour. public IEnumerable<ActMcXyzabcStep> GetActMcXyzabcSteps(IMachiningMotionResolution ncResolution, double spindleBuckleToToolTipLength, Action<object> coordinateConversionFailedAction) Parameters ncResolution IMachiningMotionResolution The machining motion resolution to use for step generation. spindleBuckleToToolTipLength double The length from spindle buckle to tool tip, used for computing step numbers. coordinateConversionFailedAction Action<object> Called when attacher NP to MC conversion fails; the argument is the failed DVec3d (attacher NP). Returns IEnumerable<ActMcXyzabcStep> A collection of machine XYZABC steps. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActMcPolarSpiralContour.html": {
    "href": "api/Hi.Numerical.Acts.ActMcPolarSpiralContour.html",
    "title": "Class ActMcPolarSpiralContour | HiAPI-C# 2025",
    "summary": "Class ActMcPolarSpiralContour Namespace Hi.Numerical.Acts Assembly HiMech.dll Circular (arc/helix) contour on the polar hypothetical plane while Polar Coordinate Interpolation (Fanuc G12.1) is active. The arc geometry lives entirely in central polar Rxcz coordinates (X = radius-direction linear axis mm, Y = hypothetical rotary-substitute axis mm, Z = real Z mm, origin on the rotary center) — the same spiral math as ActMcXyzSpiralContour. Each sampled point is then converted to machine coordinates the way ActMcPolarLinearContour does: radius drives machine X, the atan2 angle drives the machine C axis with the branch chained from the previous step (GetNoInterpolationOrdinaryProgramXcz_rad(Vec3d, double, Vec3d)), machine Y/A/B stay frozen at the previous position, and Z carries the coordinate/tool-height offset. The chaining state is local to each enumeration, so the act can be re-enumerated safely and arcs crossing the ±180° branch (or spanning multiple turns via AdditionalCircleNum) stay continuous — unlike the HardNc per-point unresolved atan2, whose machine C jumps by one cycle at the branch cut (same physical pose). Known divergence: per-step machine X is the raw polar radius and machine Y stays frozen — coordinate-offset X/Y components are NOT applied (only Z carries an offset), consistent with ActMcPolarLinearContour and the turn-mill assumption that machine X ≡ radius. HardNc is internally inconsistent here: its polar arc steps run the full transform chain (G5x X/Y included) while its polar linear steps use the raw radius like this act. public class ActMcPolarSpiralContour : IActDuration, IActMcXyzabcContour, IAct Inheritance object ActMcPolarSpiralContour Implements IActDuration IActMcXyzabcContour IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActMcPolarSpiralContour(DVec3d, Vec3d, Vec3d, Vec3d, Vec3d, int, TimeSpan, double, PolarModeDirEnum) Initializes a new instance of the ActMcPolarSpiralContour class. public ActMcPolarSpiralContour(DVec3d preMcXyzabc_rad, Vec3d programPolarBegin, Vec3d programPolarEnd, Vec3d programPolarCenterOnBeginPlane, Vec3d centerNormal, int additionalCircleNum, TimeSpan duration, double zCoordinateOffset, PolarModeDirEnum polarDir = PolarModeDirEnum.XC) Parameters preMcXyzabc_rad DVec3d Previous machine XYZ-ABC coordinates in radians programPolarBegin Vec3d Arc begin in central polar Rxcz (mm) programPolarEnd Vec3d Arc end in central polar Rxcz (mm) programPolarCenterOnBeginPlane Vec3d Arc center on the begin plane, central polar Rxcz (mm) centerNormal Vec3d Plane normal with rotation sign additionalCircleNum int Number of additional full circles duration TimeSpan Duration of the contour movement zCoordinateOffset double Depth-axis (plane normal) offset polarDir PolarModeDirEnum Polar axis pair (default XC) Properties ActDuration Gets or sets the duration of the action. public TimeSpan ActDuration { get; set; } Property Value TimeSpan Remarks The duration represents: The time required to complete the action Should be positive and finite Zero duration indicates an instantaneous action Used for scheduling and timing calculations AdditionalCircleNum Number of additional full circles (helix). public int AdditionalCircleNum { get; set; } Property Value int CenterNormal Plane normal with rotation sign (XC pair → (0,0,±1)). public Vec3d CenterNormal { get; set; } Property Value Vec3d PolarDir The polar axis pair mapping the triple-space steps onto machine axes (XC unless the machine runs G12.1 on YA/ZB). public PolarModeDirEnum PolarDir { get; } Property Value PolarModeDirEnum ProgramPolarBegin Arc begin in central polar Rxcz coordinates (mm). public Vec3d ProgramPolarBegin { get; set; } Property Value Vec3d ProgramPolarCenterOnBeginPlane Arc center on the begin plane, central polar Rxcz (mm). public Vec3d ProgramPolarCenterOnBeginPlane { get; set; } Property Value Vec3d ProgramPolarEnd Arc end in central polar Rxcz coordinates (mm). public Vec3d ProgramPolarEnd { get; set; } Property Value Vec3d Methods GetActMcXyzabcSteps(IMachiningMotionResolution, double, Action<object>) Gets the machine XYZABC steps for this contour. public IEnumerable<ActMcXyzabcStep> GetActMcXyzabcSteps(IMachiningMotionResolution ncResolution, double spindleBuckleToToolTipLength, Action<object> coordinateConversionFailedAction) Parameters ncResolution IMachiningMotionResolution The machining motion resolution to use for step generation. spindleBuckleToToolTipLength double The length from spindle buckle to tool tip, used for computing step numbers. coordinateConversionFailedAction Action<object> Called when attacher NP to MC conversion fails; the argument is the failed DVec3d (attacher NP). Returns IEnumerable<ActMcXyzabcStep> A collection of machine XYZABC steps. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActMcXyzLinearContour.html": {
    "href": "api/Hi.Numerical.Acts.ActMcXyzLinearContour.html",
    "title": "Class ActMcXyzLinearContour | HiAPI-C# 2025",
    "summary": "Class ActMcXyzLinearContour Namespace Hi.Numerical.Acts Assembly HiMech.dll Action of Machine Coordinate XYZ contour by Machine Coordinate linear interpolation. public class ActMcXyzLinearContour : IActDuration, IActMcXyzContour, IAct Inheritance object ActMcXyzLinearContour Implements IActDuration IActMcXyzContour IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActMcXyzLinearContour(SeqPair<Vec3d>, TimeSpan) Initializes a new instance of the ActMcXyzLinearContour class with the specified machine coordinate sequence and duration. public ActMcXyzLinearContour(SeqPair<Vec3d> mcSeq, TimeSpan duration) Parameters mcSeq SeqPair<Vec3d> The machine coordinate sequence pair containing the start and end points. duration TimeSpan The duration of the contour movement. Properties ActDuration Gets or sets the duration of the action. public TimeSpan ActDuration { get; set; } Property Value TimeSpan Remarks The duration represents: The time required to complete the action Should be positive and finite Zero duration indicates an instantaneous action Used for scheduling and timing calculations McSeq Gets or sets the machine coordinate sequence pair containing the start and end points. public SeqPair<Vec3d> McSeq { get; set; } Property Value SeqPair<Vec3d> Methods GetActMcXyzSteps(IMachiningMotionResolution) Gets the machine XYZ steps for this contour. public IEnumerable<ActMcXyzStep> GetActMcXyzSteps(IMachiningMotionResolution ncResolution) Parameters ncResolution IMachiningMotionResolution The machining motion resolution to use for step generation. Returns IEnumerable<ActMcXyzStep> A collection of machine XYZ steps. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActMcXyzSpiralContour.html": {
    "href": "api/Hi.Numerical.Acts.ActMcXyzSpiralContour.html",
    "title": "Class ActMcXyzSpiralContour | HiAPI-C# 2025",
    "summary": "Class ActMcXyzSpiralContour Namespace Hi.Numerical.Acts Assembly HiMech.dll Represents a spiral contour movement in machine XYZ coordinates. public class ActMcXyzSpiralContour : IActDuration, IActMcXyzabcContour, IAct Inheritance object ActMcXyzSpiralContour Implements IActDuration IActMcXyzabcContour IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActMcXyzSpiralContour(Vec3d, Vec3d, Vec3d, Vec3d, int, TimeSpan, Func<Vec3d, DVec3d>) Initializes a new instance of the ActMcXyzSpiralContour class with the specified parameters. public ActMcXyzSpiralContour(Vec3d programPosBegin, Vec3d programPosEnd, Vec3d programPosCenterOnBeginPlane, Vec3d centerNormal, int additionalCircleNum, TimeSpan actDuration, Func<Vec3d, DVec3d> programPosToMcFunc) Parameters programPosBegin Vec3d The beginning position in program coordinates. programPosEnd Vec3d The ending position in program coordinates. programPosCenterOnBeginPlane Vec3d The center position of the spiral in program coordinates. centerNormal Vec3d The normal vector of the center plane. additionalCircleNum int The number of additional circles in the spiral movement. actDuration TimeSpan The duration of the contour movement. programPosToMcFunc Func<Vec3d, DVec3d> The function to convert program position to machine coordinates. Properties ActDuration Gets or sets the duration of the action. public TimeSpan ActDuration { get; set; } Property Value TimeSpan Remarks The duration represents: The time required to complete the action Should be positive and finite Zero duration indicates an instantaneous action Used for scheduling and timing calculations AdditionalCircleNum Gets or sets the number of additional circles in the spiral movement. public int AdditionalCircleNum { get; set; } Property Value int CenterNormal Gets or sets the normal vector of the center plane. public Vec3d CenterNormal { get; set; } Property Value Vec3d ProgramPosBegin Gets or sets the beginning position in program coordinates. public Vec3d ProgramPosBegin { get; set; } Property Value Vec3d ProgramPosCenterOnBeginPlane Gets or sets the center position of the spiral in program coordinates. public Vec3d ProgramPosCenterOnBeginPlane { get; set; } Property Value Vec3d ProgramPosEnd Gets or sets the ending position in program coordinates. public Vec3d ProgramPosEnd { get; set; } Property Value Vec3d ProgramPosToMcFunc Gets or sets the function to convert program position to machine coordinates. public Func<Vec3d, DVec3d> ProgramPosToMcFunc { get; set; } Property Value Func<Vec3d, DVec3d> Methods GetActMcXyzabcSteps(IMachiningMotionResolution, double, Action<object>) Gets the machine XYZABC steps for this contour. public IEnumerable<ActMcXyzabcStep> GetActMcXyzabcSteps(IMachiningMotionResolution ncResolution, double spindleBuckleToToolTipLength, Action<object> coordinateConversionFailedAction) Parameters ncResolution IMachiningMotionResolution The machining motion resolution to use for step generation. spindleBuckleToToolTipLength double The length from spindle buckle to tool tip, used for computing step numbers. coordinateConversionFailedAction Action<object> Called when attacher NP to MC conversion fails; the argument is the failed DVec3d (attacher NP). Returns IEnumerable<ActMcXyzabcStep> A collection of machine XYZABC steps. GetDerivative(Vec3d, Vec3d, Vec3d, Vec3d, int, out Vec3d, out double, out double, out Vec3d, out double, out double) Get derivatives. public static void GetDerivative(Vec3d begin, Vec3d end, Vec3d centerOnBeginPlane, Vec3d centerNormal, int additionalCircleNum, out Vec3d arrowBeginOnProj, out double r0, out double r1, out Vec3d axialMove, out double angleOnProj, out double approxCurveLength) Parameters begin Vec3d end Vec3d centerOnBeginPlane Vec3d centerNormal Vec3d additionalCircleNum int arrowBeginOnProj Vec3d r0 double r1 double axialMove Vec3d synchronized move along the axis angleOnProj double approxCurveLength double GetNcDerivative(Vec3d, Vec3d, Vec2d, int, bool, int, out Vec3d, out double, out double, out Vec3d, out double, out double) Calculates the derivative parameters for numerical control spiral movement. public static void GetNcDerivative(Vec3d ncBegin, Vec3d ncEnd, Vec2d ncCenterVec2d, int planeNormalDir, bool isCcw, int additionalCircleNum, out Vec3d arrowBeginOnProj, out double r0, out double r1, out Vec3d axialMove, out double angleOnProj, out double approxCurveLength) Parameters ncBegin Vec3d The beginning position in NC coordinates. ncEnd Vec3d The ending position in NC coordinates. ncCenterVec2d Vec2d The center position vector in 2D NC coordinates. planeNormalDir int The direction of the plane normal (0=X, 1=Y, 2=Z). isCcw bool Indicates whether the movement is counter-clockwise. additionalCircleNum int The number of additional circles in the spiral movement. arrowBeginOnProj Vec3d The output arrow begin position on projection. r0 double The output starting radius. r1 double The output ending radius. axialMove Vec3d The output axial movement vector. angleOnProj double The output angle on projection. approxCurveLength double The output approximate curve length. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActMcXyzStep.html": {
    "href": "api/Hi.Numerical.Acts.ActMcXyzStep.html",
    "title": "Class ActMcXyzStep | HiAPI-C# 2025",
    "summary": "Class ActMcXyzStep Namespace Hi.Numerical.Acts Assembly HiMech.dll Action representing a machine coordinate XYZ step movement. This class handles linear positioning in machine coordinates. public class ActMcXyzStep : IActDuration, IActMachineStep, IAct Inheritance object ActMcXyzStep Implements IActDuration IActMachineStep IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks This class is used for: Direct machine coordinate movements Linear positioning operations Point-to-point movements Simple trajectory segments The movement is defined by: Target XYZ position in machine coordinates Movement duration Linear interpolation between points Constructors ActMcXyzStep() Initializes a new instance of the ActMcXyzStep class. Creates an empty step with default values. public ActMcXyzStep() ActMcXyzStep(Vec3d, TimeSpan) Initializes a new instance of the ActMcXyzStep class with the specified machine coordinate and duration. public ActMcXyzStep(Vec3d mcXyz, TimeSpan actDuration) Parameters mcXyz Vec3d The machine coordinate XYZ position. This vector: Specifies the target position Uses machine coordinate system Values are in machine units actDuration TimeSpan The duration of the step action. This represents: Time to complete the movement Should account for machine capabilities Must be non-negative Properties ActDuration Gets or sets the duration of the action. public TimeSpan ActDuration { get; set; } Property Value TimeSpan Remarks The duration represents: The time required to complete the action Should be positive and finite Zero duration indicates an instantaneous action Used for scheduling and timing calculations McXyz Gets or sets the machine coordinate XYZ position. public Vec3d McXyz { get; set; } Property Value Vec3d Remarks The position vector represents: X: Machine coordinate X-axis position Y: Machine coordinate Y-axis position Z: Machine coordinate Z-axis position All values are in the machine's native units (typically millimeters). Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActMcXyzabcLinearContour.html": {
    "href": "api/Hi.Numerical.Acts.ActMcXyzabcLinearContour.html",
    "title": "Class ActMcXyzabcLinearContour | HiAPI-C# 2025",
    "summary": "Class ActMcXyzabcLinearContour Namespace Hi.Numerical.Acts Assembly HiMech.dll Action of Machine Coordinate XYZABC contour by Machine Coordinate orientable linear interpolation. This class handles complex tool movements with both position and orientation control. public class ActMcXyzabcLinearContour : IActDuration, IActMcXyzabcContour, IAct Inheritance object ActMcXyzabcLinearContour Implements IActDuration IActMcXyzabcContour IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks This class is used for: 5-axis machining movements Tool orientation control Linear interpolation with orientation Complex contour following The movement combines: Linear position interpolation (XYZ) Rotational orientation interpolation (ABC) Synchronized motion control Constructors ActMcXyzabcLinearContour(SeqPair<DVec3d>, TimeSpan, IMachineKinematics) Initializes a new instance. public ActMcXyzabcLinearContour(SeqPair<DVec3d> mcSeq, TimeSpan duration, IMachineKinematics coordinateConverter) Parameters mcSeq SeqPair<DVec3d> Machine coordinate sequence pair duration TimeSpan Duration of the contour movement coordinateConverter IMachineKinematics Coordinate converter for transformation. Null is acceptable if no cutter location distance is needed. Properties ActDuration Gets or sets the duration of the action. public TimeSpan ActDuration { get; set; } Property Value TimeSpan Remarks The duration represents: The time required to complete the action Should be positive and finite Zero duration indicates an instantaneous action Used for scheduling and timing calculations MachineKinematics Gets or sets the coordinate converter. Can be null if no cutter location distance is needed for interpolation. public IMachineKinematics MachineKinematics { get; set; } Property Value IMachineKinematics Remarks The converter is used for: Coordinate system transformations Distance calculations Path optimization Optional for simple movements McSeq Gets or sets the machine coordinate sequence pair. The Normal property of DVec3d represents ABC angles in radians. public SeqPair<DVec3d> McSeq { get; set; } Property Value SeqPair<DVec3d> Remarks The sequence pair contains: Start and end positions in machine coordinates Tool orientation angles (ABC) in radians Used for interpolation calculations Methods GetActMcXyzabcSteps(IMachiningMotionResolution, double, Action<object>) Gets the machine XYZABC steps for this contour. public IEnumerable<ActMcXyzabcStep> GetActMcXyzabcSteps(IMachiningMotionResolution ncResolution, double spindleBuckleToToolTipLength, Action<object> coordinateConversionFailedAction) Parameters ncResolution IMachiningMotionResolution The machining motion resolution to use for step generation. spindleBuckleToToolTipLength double The length from spindle buckle to tool tip, used for computing step numbers. coordinateConversionFailedAction Action<object> Called when attacher NP to MC conversion fails; the argument is the failed DVec3d (attacher NP). Returns IEnumerable<ActMcXyzabcStep> A collection of machine XYZABC steps. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActMcXyzabcStep.html": {
    "href": "api/Hi.Numerical.Acts.ActMcXyzabcStep.html",
    "title": "Class ActMcXyzabcStep | HiAPI-C# 2025",
    "summary": "Class ActMcXyzabcStep Namespace Hi.Numerical.Acts Assembly HiMech.dll Action of Machine coordinate XYCABC Step. public class ActMcXyzabcStep : IActDuration, IActMachineStep, IAct Inheritance object ActMcXyzabcStep Implements IActDuration IActMachineStep IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActMcXyzabcStep() Ctor. public ActMcXyzabcStep() ActMcXyzabcStep(DVec3d, TimeSpan) Ctor. public ActMcXyzabcStep(DVec3d mcXyzabc, TimeSpan actDuration) Parameters mcXyzabc DVec3d actDuration TimeSpan Properties ActDuration Gets or sets the duration of the action. public TimeSpan ActDuration { get; set; } Property Value TimeSpan Remarks The duration represents: The time required to complete the action Should be positive and finite Zero duration indicates an instantaneous action Used for scheduling and timing calculations McXyzabc Normal is abc in radian. public DVec3d McXyzabc { get; set; } Property Value DVec3d Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActMcXyzabcTeleport.html": {
    "href": "api/Hi.Numerical.Acts.ActMcXyzabcTeleport.html",
    "title": "Class ActMcXyzabcTeleport | HiAPI-C# 2025",
    "summary": "Class ActMcXyzabcTeleport Namespace Hi.Numerical.Acts Assembly HiMech.dll Instant machine-coordinate reposition — the MC counterpart of ActClTeleport: the chain pose is set without a machining step, so no time accumulates and no material-removal step is recorded. Emitted for CLSF FROM / first-motion blocks when the runner drives an MC machine. public class ActMcXyzabcTeleport : IAct Inheritance object ActMcXyzabcTeleport Implements IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActMcXyzabcTeleport() Ctor. public ActMcXyzabcTeleport() ActMcXyzabcTeleport(DVec3d) Ctor. public ActMcXyzabcTeleport(DVec3d mcXyzabc) Parameters mcXyzabc DVec3d Properties McXyzabc Target machine coordinate; Normal is ABC in radians (NaN for axes the chain does not have). public DVec3d McXyzabc { get; set; } Property Value DVec3d Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActRapid.html": {
    "href": "api/Hi.Numerical.Acts.ActRapid.html",
    "title": "Class ActRapid | HiAPI-C# 2025",
    "summary": "Class ActRapid Namespace Hi.Numerical.Acts Assembly HiMech.dll A rapid traverse. Its commanded CL feedrate is the CL path over the act duration (HardNc: the machine's nominal rapid rate); under RTCP a pure rotary swing keeps the CL point still, so the value is legitimately ~0 while the equipped tool's tip sweeps with the posture change. public class ActRapid : ActFeedrate, IAct Inheritance object ActFeedrate ActRapid Implements IAct Inherited Members ActFeedrate.CommandedClFeedrate_mmds ActFeedrate.CommandedClFeedrate_mmdmin object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActRapid(double) Ctor. public ActRapid(double rapidFeedrate_mmds) Parameters rapidFeedrate_mmds double Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActSpindleDirection.html": {
    "href": "api/Hi.Numerical.Acts.ActSpindleDirection.html",
    "title": "Class ActSpindleDirection | HiAPI-C# 2025",
    "summary": "Class ActSpindleDirection Namespace Hi.Numerical.Acts Assembly HiMech.dll Represents an action that sets the spindle rotation direction. public class ActSpindleDirection : IAct Inheritance object ActSpindleDirection Implements IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActSpindleDirection() Initializes a new instance. public ActSpindleDirection() ActSpindleDirection(SpindleDirection) Initializes a new instance with the specified spindle direction. public ActSpindleDirection(SpindleDirection spindleDirection) Parameters spindleDirection SpindleDirection The spindle rotation direction. Properties SpindleDirection Gets or sets the spindle rotation direction. public SpindleDirection SpindleDirection { get; set; } Property Value SpindleDirection Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActSpindleOrientation.html": {
    "href": "api/Hi.Numerical.Acts.ActSpindleOrientation.html",
    "title": "Class ActSpindleOrientation | HiAPI-C# 2025",
    "summary": "Class ActSpindleOrientation Namespace Hi.Numerical.Acts Assembly HiMech.dll Oriented spindle stop — commands the spindle to stop at a specific angular position. Used by G76 (fine boring) and G87 (back boring) to orient the tool before lateral shift. public class ActSpindleOrientation : IAct Inheritance object ActSpindleOrientation Implements IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActSpindleOrientation() Creates an orientation act with zero target angle. public ActSpindleOrientation() ActSpindleOrientation(double) Creates an orientation act with the given spindle angle. public ActSpindleOrientation(double angle_rad) Parameters angle_rad double Target orientation about the spindle axis, radians. Properties Angle_deg Target spindle angle in degrees. public double Angle_deg { get; set; } Property Value double Angle_rad Target spindle angle in radians. public double Angle_rad { get; set; } Property Value double Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActSpindleSpeed.html": {
    "href": "api/Hi.Numerical.Acts.ActSpindleSpeed.html",
    "title": "Class ActSpindleSpeed | HiAPI-C# 2025",
    "summary": "Class ActSpindleSpeed Namespace Hi.Numerical.Acts Assembly HiMech.dll Represents an act that controls the spindle speed in numerical control operations. public class ActSpindleSpeed : IAct Inheritance object ActSpindleSpeed Implements IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActSpindleSpeed() Initializes a new instance of the ActSpindleSpeed class. public ActSpindleSpeed() Properties SpindleSpeed_radds Gets or sets the spindle speed in radians per second. public double SpindleSpeed_radds { get; set; } Property Value double SpindleSpeed_rpm Gets or sets the spindle speed in revolutions per minute. public double SpindleSpeed_rpm { get; set; } Property Value double Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActToolingStep.html": {
    "href": "api/Hi.Numerical.Acts.ActToolingStep.html",
    "title": "Class ActToolingStep | HiAPI-C# 2025",
    "summary": "Class ActToolingStep Namespace Hi.Numerical.Acts Assembly HiMech.dll Action of equiping the tool with machining step operation such as collision detection and volume removal. public class ActToolingStep : IActDuration, IActMachineStep, IActTooling, IAct Inheritance object ActToolingStep Implements IActDuration IActMachineStep IActTooling IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActToolingStep(int, TimeSpan?) Initializes a new instance of the ActToolingStep class with the specified tool ID and duration. public ActToolingStep(int toolId, TimeSpan? actDuration = null) Parameters toolId int The identifier of the tool to use. This value: Must be a valid tool magazine position Should correspond to an existing tool Is used for tool selection and validation actDuration TimeSpan? The duration of the tooling operation. This represents: Time needed for tool change Should include safety margins Must be non-negative Properties ActDuration Gets or sets the duration of the action. public TimeSpan ActDuration { get; set; } Property Value TimeSpan Remarks The duration represents: The time required to complete the action Should be positive and finite Zero duration indicates an instantaneous action Used for scheduling and timing calculations ToolId Gets or sets the tool identifier. public int ToolId { get; set; } Property Value int Remarks The tool ID: Uniquely identifies a specific tool Used for tool selection and validation Corresponds to the machine's tool magazine positions Should be positive and valid for the machine configuration Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActToolingTeleport.html": {
    "href": "api/Hi.Numerical.Acts.ActToolingTeleport.html",
    "title": "Class ActToolingTeleport | HiAPI-C# 2025",
    "summary": "Class ActToolingTeleport Namespace Hi.Numerical.Acts Assembly HiMech.dll Action of Equiping the tool without machining step operation such as collision detection and volume removal. public class ActToolingTeleport : IActTooling, IAct Inheritance object ActToolingTeleport Implements IActTooling IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActToolingTeleport(int) Initializes a new instance of the ActToolingTeleport class with the specified tool ID and duration. public ActToolingTeleport(int toolId) Parameters toolId int The identifier of the tool to use. This value: Must be a valid tool magazine position Should correspond to an existing tool Is used for tool selection and validation Properties ToolId Gets or sets the tool identifier. public int ToolId { get; set; } Property Value int Remarks The tool ID: Uniquely identifies a specific tool Used for tool selection and validation Corresponds to the machine's tool magazine positions Should be positive and valid for the machine configuration Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActUnknownSkip.html": {
    "href": "api/Hi.Numerical.Acts.ActUnknownSkip.html",
    "title": "Class ActUnknownSkip | HiAPI-C# 2025",
    "summary": "Class ActUnknownSkip Namespace Hi.Numerical.Acts Assembly HiMech.dll Represents an act that skips unknown operations in numerical control. public class ActUnknownSkip : IActSkip, IAct Inheritance object ActUnknownSkip Implements IActSkip IAct Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ActUnknownSkip() Initializes a new instance of the ActUnknownSkip class. public ActUnknownSkip() Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.Acts.ActUtil.html": {
    "href": "api/Hi.Numerical.Acts.ActUtil.html",
    "title": "Class ActUtil | HiAPI-C# 2025",
    "summary": "Class ActUtil Namespace Hi.Numerical.Acts Assembly HiMech.dll Provides utility methods for numerical control actions. public static class ActUtil Inheritance object ActUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields MaxStepNumPerAct Hard cap on the number of steps one act may split into. The finest machining resolution the runner accepts (1/4096 mm, the lower bound of the machining-resolution clamp) over a one-metre traverse is ~4M steps; a real quotient beyond that means a degenerate resolution or geometry, not a finer request. Without the cap, (int) of an infinite or huge quotient saturates to MaxValue on .NET 9+ and the act plays as 2^31 zero-duration steps — the “one line, frozen cycle time, step index climbing forever” hang. public const int MaxStepNumPerAct = 4000000 Field Value int Methods GetClSteps(IActClMove, int, IMachiningMotionResolution) Splits a cutter location movement into a sequence of steps according to the NC resolution and desired step count. public static IEnumerable<ActClStep> GetClSteps(this IActClMove actClMove, int stepNum, IMachiningMotionResolution ncResolution) Parameters actClMove IActClMove The cutter location movement action. stepNum int The number of steps to split into. ncResolution IMachiningMotionResolution The machining motion resolution. Returns IEnumerable<ActClStep> An enumerable sequence of ActClStep. GetStepNum(SeqPair<DVec3d>, IMachineKinematics, double, IMachiningMotionResolution, TimeSpan) Gets the step number for a rotary-bearing (XYZABC) machine coordinate move. Two motions are bounded separately and the larger count wins: the posture change — each rotary axis delta over RotaryAxisResolution_rad; the travel — by the resolution's time criterion (GetStepNumByDuration(TimeSpan, double), one step per spindle cycle) when it applies, otherwise the real tool-tip travel of the equipped tool over LinearResolution_mm. With a posture change the tip travel is never divided by a feed-derived linear resolution: that resolution describes the controller's commanded CL point, and under RTCP the real tip can sweep hundreds of millimetres while the CL point stands still. Without a posture change the tip translates with the CL point, so the tip travel over the linear resolution is the CL point's own count — the act keeps the distance form, exactly the number the XYZ-only splitters produce (Soft/Hard parity on a 3-axis move that one engine wraps as an XYZABC act; a time count would differ by one on TimeSpan tick rounding). public static int GetStepNum(SeqPair<DVec3d> mcSeq, IMachineKinematics coordinateConverter, double toolHeightForComputingStepNum, IMachiningMotionResolution ncResolution, TimeSpan duration) Parameters mcSeq SeqPair<DVec3d> The machine coordinate sequence. coordinateConverter IMachineKinematics The coordinate converter to use; null when no tool-tip travel is available. toolHeightForComputingStepNum double The equipped tool's spindle-buckle-to-tip length. ncResolution IMachiningMotionResolution The machining motion resolution. duration TimeSpan The act's duration, for the time criterion. Returns int The calculated step number. GetStepNumOnPolarInterpolationMode(SeqPair<Vec3d>, IMachiningMotionResolution) Gets the step number for a polar interpolation mode. public static int GetStepNumOnPolarInterpolationMode(SeqPair<Vec3d> programPolarXczSeq, IMachiningMotionResolution ncResolution) Parameters programPolarXczSeq SeqPair<Vec3d> The program polar XCZ sequence. ncResolution IMachiningMotionResolution The machining motion resolution. Returns int The calculated step number. GetToolTipTravel(DVec3d, DVec3d, IMachineKinematics, double) Real tool-tip travel between two machine coordinates: the chord between the tips of the equipped tool (compensationHeight below the spindle buckle along the tool normal) at both poses. public static double GetToolTipTravel(DVec3d mcXyzabc0, DVec3d mcXyzabc1, IMachineKinematics coordinateConverter, double compensationHeight) Parameters mcXyzabc0 DVec3d mcXyzabc1 DVec3d coordinateConverter IMachineKinematics compensationHeight double Returns double ToStepNum(double) Converts a real-valued step quotient (total / unitPerStep) into a bounded step count: NaN or non-positive → 0; otherwise the ceiling, clamped to MaxStepNumPerAct. Every act's step-number derivation goes through here so no division can turn into a saturated integer. public static int ToStepNum(double stepQuotient) Parameters stepQuotient double Returns int UpdateStepNumByCl(DVec3d, DVec3d, IMachineKinematics, double, double, ref int) Updates the step number based on cutter location points. public static void UpdateStepNumByCl(DVec3d mcXyzabc0, DVec3d mcXyzabc1, IMachineKinematics coordinateConverter, double compensationHeight, double linearResolution_mm, ref int stepNum) Parameters mcXyzabc0 DVec3d The starting machine coordinate. mcXyzabc1 DVec3d The ending machine coordinate. coordinateConverter IMachineKinematics The coordinate converter to use. compensationHeight double The compensation height value. linearResolution_mm double The linear resolution in millimeters. stepNum int The step number to update."
  },
  "api/Hi.Numerical.Acts.ArcRadialClosure.html": {
    "href": "api/Hi.Numerical.Acts.ArcRadialClosure.html",
    "title": "Class ArcRadialClosure | HiAPI-C# 2025",
    "summary": "Class ArcRadialClosure Namespace Hi.Numerical.Acts Assembly HiMech.dll Classifies the radial closure of an arc motion — how far the arc's endpoint sits off the circle its center defines, measured as the gap between the begin radius and the end radius on the arc plane. A genuine arc closes (gap 0). The simulation accepts any gap and runs the block as a spiral whose radius blends linearly (ActMcXyzSpiralContour), but real controls check this closure and refuse the block once the gap passes their arc tolerance (e.g. Heidenhain error 5824 once MP7431 — typically around 0.016 mm — is exceeded). A program can therefore simulate cleanly and still stop on the machine; the diagnostics built from this class exist to close that gap. public static class ArcRadialClosure Inheritance object ArcRadialClosure Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields AdviceThreshold_mm Advice threshold: half of TypicalControllerTolerance_mm. A gap past this consumes a substantial share of the tolerance budget and deserves attention even though a control still accepts it. public const double AdviceThreshold_mm = 0.008 Field Value double DiagnosticId Diagnostic id shared by the SoftNc and HardNc arc gates. public const string DiagnosticId = \"Arc-EndpointOffRadius\" Field Value string TypicalControllerTolerance_mm The arc tolerance a typical control enforces before refusing the block (e.g. the Heidenhain MP7431 family default). public const double TypicalControllerTolerance_mm = 0.016 Field Value double Methods TryDescribe(double, double, out string, out Dictionary<string, object>) Classifies the begin/end radius pair of an arc. Returns false for a closing arc (gap within AdviceThreshold_mm) and for degenerate radii; returns true with a constant notification text and a value-carrying detail when the gap deserves a validation warning. public static bool TryDescribe(double beginRadius_mm, double endRadius_mm, out string text, out Dictionary<string, object> detail) Parameters beginRadius_mm double Begin-point radius about the center, on the arc plane. endRadius_mm double End-point radius about the center, on the arc plane. text string Constant notification text (fold-stable), or null. detail Dictionary<string, object> Measured radii and gap, or null. Returns bool"
  },
  "api/Hi.Numerical.Acts.IAct.html": {
    "href": "api/Hi.Numerical.Acts.IAct.html",
    "title": "Interface IAct | HiAPI-C# 2025",
    "summary": "Interface IAct Namespace Hi.Numerical.Acts Assembly HiMech.dll Action parsing from NC, CL, NC Steps and etc., for controlling the mechanism and the mechanism simulation process. public interface IAct Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Numerical.Acts.IActClMove.html": {
    "href": "api/Hi.Numerical.Acts.IActClMove.html",
    "title": "Interface IActClMove | HiAPI-C# 2025",
    "summary": "Interface IActClMove Namespace Hi.Numerical.Acts Assembly HiMech.dll Interface for actions that involve cutter location movement. This interface defines the contract for tool path movements in machining operations. public interface IActClMove : IAct Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ActUtil.GetClSteps(IActClMove, int, IMachiningMotionResolution) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks This interface is used for: Tool path planning Cutter location trajectory definition Movement coordination Path interpolation Implementations should handle: Path geometry and kinematics Movement constraints Coordinate transformations Tool orientation Methods GetClPath() Retrieves the cutter location path associated with this movement action. IClPath GetClPath() Returns IClPath The cutter location path defining: Movement trajectory Tool positions and orientations Path geometry Movement constraints Remarks The returned path should: Be properly initialized and valid Include all necessary movement parameters Consider machine kinematics constraints Support interpolation if needed GetClSteps(IMachiningMotionResolution) Gets a sequence of steps split from this movement under the specified NC resolution. IEnumerable<ActClStep> GetClSteps(IMachiningMotionResolution ncResolution) Parameters ncResolution IMachiningMotionResolution The machining motion resolution. Returns IEnumerable<ActClStep> A sequence of ActClStep."
  },
  "api/Hi.Numerical.Acts.IActDuration.html": {
    "href": "api/Hi.Numerical.Acts.IActDuration.html",
    "title": "Interface IActDuration | HiAPI-C# 2025",
    "summary": "Interface IActDuration Namespace Hi.Numerical.Acts Assembly HiMech.dll Interface for actions that have a specific duration. This interface is used to define actions that take a measurable amount of time to complete. public interface IActDuration : IAct Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks This interface is used for: Machining operations with defined durations Time-based process steps Actions that need to track their execution time Common implementations include: Tool changes Cutting operations Positioning movements Delay operations Properties ActDuration Gets or sets the duration of the action. TimeSpan ActDuration { get; set; } Property Value TimeSpan Remarks The duration represents: The time required to complete the action Should be positive and finite Zero duration indicates an instantaneous action Used for scheduling and timing calculations"
  },
  "api/Hi.Numerical.Acts.IActMachineStep.html": {
    "href": "api/Hi.Numerical.Acts.IActMachineStep.html",
    "title": "Interface IActMachineStep | HiAPI-C# 2025",
    "summary": "Interface IActMachineStep Namespace Hi.Numerical.Acts Assembly HiMech.dll public interface IActMachineStep : IAct Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Numerical.Acts.IActMcXyzContour.html": {
    "href": "api/Hi.Numerical.Acts.IActMcXyzContour.html",
    "title": "Interface IActMcXyzContour | HiAPI-C# 2025",
    "summary": "Interface IActMcXyzContour Namespace Hi.Numerical.Acts Assembly HiMech.dll Interface for actions that represent machine XYZ contours. public interface IActMcXyzContour : IAct Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetActMcXyzSteps(IMachiningMotionResolution) Gets the machine XYZ steps for this contour. IEnumerable<ActMcXyzStep> GetActMcXyzSteps(IMachiningMotionResolution ncResolution) Parameters ncResolution IMachiningMotionResolution The machining motion resolution to use for step generation. Returns IEnumerable<ActMcXyzStep> A collection of machine XYZ steps."
  },
  "api/Hi.Numerical.Acts.IActMcXyzabcContour.html": {
    "href": "api/Hi.Numerical.Acts.IActMcXyzabcContour.html",
    "title": "Interface IActMcXyzabcContour | HiAPI-C# 2025",
    "summary": "Interface IActMcXyzabcContour Namespace Hi.Numerical.Acts Assembly HiMech.dll Interface for actions that represent machine XYZABC contours. public interface IActMcXyzabcContour : IAct Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetActMcXyzabcSteps(IMachiningMotionResolution, double, Action<object>) Gets the machine XYZABC steps for this contour. IEnumerable<ActMcXyzabcStep> GetActMcXyzabcSteps(IMachiningMotionResolution ncResolution, double spindleBuckleToToolTipLength, Action<object> coordinateConversionFailedAction) Parameters ncResolution IMachiningMotionResolution The machining motion resolution to use for step generation. spindleBuckleToToolTipLength double The length from spindle buckle to tool tip, used for computing step numbers. coordinateConversionFailedAction Action<object> Called when attacher NP to MC conversion fails; the argument is the failed DVec3d (attacher NP). Returns IEnumerable<ActMcXyzabcStep> A collection of machine XYZABC steps."
  },
  "api/Hi.Numerical.Acts.IActSkip.html": {
    "href": "api/Hi.Numerical.Acts.IActSkip.html",
    "title": "Interface IActSkip | HiAPI-C# 2025",
    "summary": "Interface IActSkip Namespace Hi.Numerical.Acts Assembly HiMech.dll Interface for actions that should be skipped during normal processing. Acts as a marker interface to identify actions that should not be executed. public interface IActSkip : IAct Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Numerical.Acts.IActTooling.html": {
    "href": "api/Hi.Numerical.Acts.IActTooling.html",
    "title": "Interface IActTooling | HiAPI-C# 2025",
    "summary": "Interface IActTooling Namespace Hi.Numerical.Acts Assembly HiMech.dll Represents a tooling action that changes or selects a tool. public interface IActTooling : IAct Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties ToolId Gets or sets the target tool identifier. int ToolId { get; set; } Property Value int"
  },
  "api/Hi.Numerical.Acts.IWorkTimeAttrib.html": {
    "href": "api/Hi.Numerical.Acts.IWorkTimeAttrib.html",
    "title": "Interface IWorkTimeAttrib | HiAPI-C# 2025",
    "summary": "Interface IWorkTimeAttrib Namespace Hi.Numerical.Acts Assembly HiMech.dll Interface for objects that provide both read and write access to work time. Combines the functionality of IWorkTimeGetter and IWorkTimeSetter. public interface IWorkTimeAttrib Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks This interface is used when: Both reading and writing work time is needed Full time tracking functionality is required The object needs to both monitor and control time Common implementations include: Machining operation controllers Time tracking components Process monitoring systems Properties WorkTime_s Gets or sets the work time in seconds. double WorkTime_s { get; set; } Property Value double Remarks This property provides: Read access to current work time Write access to update work time Time values are in seconds Should maintain time continuity when updated"
  },
  "api/Hi.Numerical.Acts.IWorkTimeGetter.html": {
    "href": "api/Hi.Numerical.Acts.IWorkTimeGetter.html",
    "title": "Interface IWorkTimeGetter | HiAPI-C# 2025",
    "summary": "Interface IWorkTimeGetter Namespace Hi.Numerical.Acts Assembly HiMech.dll Interface for objects that provide read-only access to work time. This interface is part of the work time tracking system for machining operations. public interface IWorkTimeGetter Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks This interface is used when: Only reading work time is required The object should not be able to modify work time Time values are needed for monitoring or reporting purposes Properties WorkTime_s Gets the work time in seconds. double WorkTime_s { get; } Property Value double Remarks The work time represents: The total elapsed time of the operation Time is measured in seconds from the start Returns the current accumulated work time"
  },
  "api/Hi.Numerical.Acts.IWorkTimeSetter.html": {
    "href": "api/Hi.Numerical.Acts.IWorkTimeSetter.html",
    "title": "Interface IWorkTimeSetter | HiAPI-C# 2025",
    "summary": "Interface IWorkTimeSetter Namespace Hi.Numerical.Acts Assembly HiMech.dll Interface for objects that provide write-only access to work time. This interface is used for components that need to update work time without reading it. public interface IWorkTimeSetter Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks This interface is used when: Only setting work time is required The object should not be able to read work time Time values need to be updated during operation Properties WorkTime_s Sets the work time in seconds. double WorkTime_s { set; } Property Value double Remarks When setting work time: The value should be in seconds Negative values should be handled appropriately Updates should maintain time continuity"
  },
  "api/Hi.Numerical.Acts.StateActRunner.html": {
    "href": "api/Hi.Numerical.Acts.StateActRunner.html",
    "title": "Class StateActRunner | HiAPI-C# 2025",
    "summary": "Class StateActRunner Namespace Hi.Numerical.Acts Assembly HiMech.dll Manages the state of numerical control operations during runtime. public class StateActRunner Inheritance object StateActRunner Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties ActualDateTime Absolute controller timestamp (wall-clock DateTime) of the step, kept alongside ActualTimecode so the calendar date is not lost. null if not set. public DateTime? ActualDateTime { get; set; } Property Value DateTime? ActualTimecode Actual accumulated worked time. Actual Program time. Actual End Timecode. null if not set. public TimeSpan? ActualTimecode { get; set; } Property Value TimeSpan? CommandedClFeedrate_mmdmin CommandedClFeedrate_mmds in mm/min. public double CommandedClFeedrate_mmdmin { get; set; } Property Value double CommandedClFeedrate_mmds The controller's commanded feedrate of the CL point in mm/sec, as last processed: the F word after G94/G95/G93 conversion, or for a rapid the CL path over the act duration (ActRapid). It describes the point the controller moves, not the equipped tool's tip: under RTCP with a tool-length offset that does not match the equipped tool the tip sweeps while the CL point may stand still, so this value is not the real tool-tip feedrate (ActualTipFeedrate_mmds). public double CommandedClFeedrate_mmds { get; set; } Property Value double CoolantMode Current coolant delivery mode as last-seen ActCooling. Updated by ProcAct(IAct). public CoolantMode CoolantMode { get; set; } Property Value CoolantMode Data State external data. public Dictionary<string, object> Data { get; set; } Property Value Dictionary<string, object> EndTimecode Ideal accumulated worked time by simulation. Ideal Program time. The value includes last action duration. public TimeSpan EndTimecode { get; set; } Property Value TimeSpan IsCoolantOn Legacy convenience flag. True for Flood / Mist; false for Off / UnDefined. public bool IsCoolantOn { get; set; } Property Value bool SpindleAngle_deg Spindle rotation angle in degrees. public double SpindleAngle_deg { get; set; } Property Value double SpindleAngle_rad Spindle rotation angle in radians. public double SpindleAngle_rad { get; set; } Property Value double SpindleDirection Gets or sets the spindle rotation direction. public SpindleDirection SpindleDirection { get; set; } Property Value SpindleDirection SpindleSpeed_radds Gets or sets the spindle speed in radians per second. public double SpindleSpeed_radds { get; set; } Property Value double SpindleSpeed_rpm Gets or sets the spindle speed in revolutions per minute. public double SpindleSpeed_rpm { get; set; } Property Value double ToolId Gets or sets the current tool identifier. public int ToolId { get; set; } Property Value int Methods ProcAct(IAct) filter the same effect action and run the effective action. public IAct ProcAct(IAct act) Parameters act IAct Returns IAct null if the input act is the same effect action. otherwise, return act. ResetState() Resets all state values to their defaults. public void ResetState()"
  },
  "api/Hi.Numerical.Acts.html": {
    "href": "api/Hi.Numerical.Acts.html",
    "title": "Namespace Hi.Numerical.Acts | HiAPI-C# 2025",
    "summary": "Namespace Hi.Numerical.Acts Classes ActActualDateTime Represents an action that records the absolute controller timestamp (wall-clock DateTime) for a machine step. Parallel to ActActualTimecode: that act carries the run-relative timecode (a TimeSpan), this one preserves the raw calendar instant so the date is not lost — converting between the two is the mapping anchor's job, done once at the boundary. ActActualTimecode Represents an action that sets the actual time for a machine step. ActClArc Represents an arc movement action for cutter location. ActClArcMcXyzabcContour Arc twin of ActClLinearMcXyzabcContour: a circular cutter location path realized on machine coordinates. The arc is interpolated in CL space (true arc via At(double), including tilting normals) and every resampled step is inverse-solved through PnToMc(DVec3d, out DVec3d). ActClLinear Represents a linear cutter location movement action. ActClLinearMcXyzabcContour Represents a combined linear movement in both cutter location and machine coordinates. This class handles synchronized linear interpolation of tool position and orientation. ActClStep Represents a single cutter-location step with optional duration. ActClTeleport Represents a teleport action for cutter location, allowing instant position change without movement. ActCooling Represents a coolant state transition — the cutting-fluid delivery mode changes on the machine (from e.g. Off to Flood). Emitted by CoolantSemantic when the NC program executes M07/M08/M09. ActData Action that add data to the step. The data is maybe from the sensor or computed, etc.. ActDelay Represents a delay action in machining operations. This class implements a simple time delay in the machining process. ActFeedrate A feedrate action: the controller's commanded feedrate of the CL point (CommandedClFeedrate_mmds). ActHiddenStateChanged Represents an action that indicates a change in the hidden state of an object. This action is typically skipped during normal processing. ActIntentionalSkip Represents an action that is intentionally skipped during processing. Used to explicitly mark operations that should be bypassed. ActLineBegin Represents the beginning of a line act in numerical control operations. ActLineCsScript Cs Script on one Line. ActLineEnd Represents the end of a line act in numerical control operations. ActMcPolarLinearContour Polar MCZ linear contour. ActMcPolarSpiralContour Circular (arc/helix) contour on the polar hypothetical plane while Polar Coordinate Interpolation (Fanuc G12.1) is active. The arc geometry lives entirely in central polar Rxcz coordinates (X = radius-direction linear axis mm, Y = hypothetical rotary-substitute axis mm, Z = real Z mm, origin on the rotary center) — the same spiral math as ActMcXyzSpiralContour. Each sampled point is then converted to machine coordinates the way ActMcPolarLinearContour does: radius drives machine X, the atan2 angle drives the machine C axis with the branch chained from the previous step (GetNoInterpolationOrdinaryProgramXcz_rad(Vec3d, double, Vec3d)), machine Y/A/B stay frozen at the previous position, and Z carries the coordinate/tool-height offset. The chaining state is local to each enumeration, so the act can be re-enumerated safely and arcs crossing the ±180° branch (or spanning multiple turns via AdditionalCircleNum) stay continuous — unlike the HardNc per-point unresolved atan2, whose machine C jumps by one cycle at the branch cut (same physical pose). Known divergence: per-step machine X is the raw polar radius and machine Y stays frozen — coordinate-offset X/Y components are NOT applied (only Z carries an offset), consistent with ActMcPolarLinearContour and the turn-mill assumption that machine X ≡ radius. HardNc is internally inconsistent here: its polar arc steps run the full transform chain (G5x X/Y included) while its polar linear steps use the raw radius like this act. ActMcXyzLinearContour Action of Machine Coordinate XYZ contour by Machine Coordinate linear interpolation. ActMcXyzSpiralContour Represents a spiral contour movement in machine XYZ coordinates. ActMcXyzStep Action representing a machine coordinate XYZ step movement. This class handles linear positioning in machine coordinates. ActMcXyzabcLinearContour Action of Machine Coordinate XYZABC contour by Machine Coordinate orientable linear interpolation. This class handles complex tool movements with both position and orientation control. ActMcXyzabcStep Action of Machine coordinate XYCABC Step. ActMcXyzabcTeleport Instant machine-coordinate reposition — the MC counterpart of ActClTeleport: the chain pose is set without a machining step, so no time accumulates and no material-removal step is recorded. Emitted for CLSF FROM / first-motion blocks when the runner drives an MC machine. ActRapid A rapid traverse. Its commanded CL feedrate is the CL path over the act duration (HardNc: the machine's nominal rapid rate); under RTCP a pure rotary swing keeps the CL point still, so the value is legitimately ~0 while the equipped tool's tip sweeps with the posture change. ActSpindleDirection Represents an action that sets the spindle rotation direction. ActSpindleOrientation Oriented spindle stop — commands the spindle to stop at a specific angular position. Used by G76 (fine boring) and G87 (back boring) to orient the tool before lateral shift. ActSpindleSpeed Represents an act that controls the spindle speed in numerical control operations. ActToolingStep Action of equiping the tool with machining step operation such as collision detection and volume removal. ActToolingTeleport Action of Equiping the tool without machining step operation such as collision detection and volume removal. ActUnknownSkip Represents an act that skips unknown operations in numerical control. ActUtil Provides utility methods for numerical control actions. ArcRadialClosure Classifies the radial closure of an arc motion — how far the arc's endpoint sits off the circle its center defines, measured as the gap between the begin radius and the end radius on the arc plane. A genuine arc closes (gap 0). The simulation accepts any gap and runs the block as a spiral whose radius blends linearly (ActMcXyzSpiralContour), but real controls check this closure and refuse the block once the gap passes their arc tolerance (e.g. Heidenhain error 5824 once MP7431 — typically around 0.016 mm — is exceeded). A program can therefore simulate cleanly and still stop on the machine; the diagnostics built from this class exist to close that gap. StateActRunner Manages the state of numerical control operations during runtime. Interfaces IAct Action parsing from NC, CL, NC Steps and etc., for controlling the mechanism and the mechanism simulation process. IActClMove Interface for actions that involve cutter location movement. This interface defines the contract for tool path movements in machining operations. IActDuration Interface for actions that have a specific duration. This interface is used to define actions that take a measurable amount of time to complete. IActMachineStep IActMcXyzContour Interface for actions that represent machine XYZ contours. IActMcXyzabcContour Interface for actions that represent machine XYZABC contours. IActSkip Interface for actions that should be skipped during normal processing. Acts as a marker interface to identify actions that should not be executed. IActTooling Represents a tooling action that changes or selects a tool. IWorkTimeAttrib Interface for objects that provide both read and write access to work time. Combines the functionality of IWorkTimeGetter and IWorkTimeSetter. IWorkTimeGetter Interface for objects that provide read-only access to work time. This interface is part of the work time tracking system for machining operations. IWorkTimeSetter Interface for objects that provide write-only access to work time. This interface is used for components that need to update work time without reading it."
  },
  "api/Hi.Numerical.Args.OrthogonalPlaneFlag.html": {
    "href": "api/Hi.Numerical.Args.OrthogonalPlaneFlag.html",
    "title": "Enum OrthogonalPlaneFlag | HiAPI-C# 2025",
    "summary": "Enum OrthogonalPlaneFlag Namespace Hi.Numerical.Args Assembly HiMech.dll Plane Selection Flag. Fanuc Group02 flags. the int value is the plane dir number. public enum OrthogonalPlaneFlag Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields G17 = 2 XY plane selection. Fanuc Group02. G18 = 1 ZX plane selection. Fanuc Group02. G19 = 0 YZ plane selection. Fanuc Group02."
  },
  "api/Hi.Numerical.Args.PolarModeDirEnum.html": {
    "href": "api/Hi.Numerical.Args.PolarModeDirEnum.html",
    "title": "Enum PolarModeDirEnum | HiAPI-C# 2025",
    "summary": "Enum PolarModeDirEnum Namespace Hi.Numerical.Args Assembly HiMech.dll Polar coordinate interpolation mode direction. YA,ZB has not implemented yet. public enum PolarModeDirEnum Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields XC = 0 XC polar coordinate mode YA = 1 YA polar coordinate mode ZB = 2 ZB polar coordinate mode"
  },
  "api/Hi.Numerical.Args.PolarPairDef.html": {
    "href": "api/Hi.Numerical.Args.PolarPairDef.html",
    "title": "Class PolarPairDef | HiAPI-C# 2025",
    "summary": "Class PolarPairDef Namespace Hi.Numerical.Args Assembly HiMech.dll Axis mapping of a Polar Coordinate Interpolation pair (PolarModeDirEnum): which program/machine axes carry the radius, the plane depth, and the rotation. The polar math itself runs in \"triple space\" — the Rxcz vector (linear/radius, hypothetical, depth) with the plane normal fixed at the third component — and is pair-independent; this definition maps the triple's ends onto real axes: NC words on the way in, machine coordinates on the way out. The plane normal equals the rotary's rotation axis (C about Z, A about X, B about Y), so NormalIndex doubles as the ABC component of the angle. The lathe diameter-programming convention (the radius word arrives doubled) applies to the X axis only, i.e. the XC pair — mirroring HardNc PolarEntry, which halves X unconditionally. HardNc's own YA/ZB slots are dead code (never selected); its ProgramOrthogonalPlaneNormal table carried swapped normals for them, corrected alongside this implementation. public sealed class PolarPairDef Inheritance object PolarPairDef Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields XC X linear + C rotary about Z (the standard turn-mill pair). public static readonly PolarPairDef XC Field Value PolarPairDef YA Y linear + A rotary about X. public static readonly PolarPairDef YA Field Value PolarPairDef ZB Z linear + B rotary about Y. public static readonly PolarPairDef ZB Field Value PolarPairDef Properties DepthWord NC word of the depth (normal-axis) coordinate. public string DepthWord { get; } Property Value string Dir The Dir string stored in the polar state section. public string Dir { get; } Property Value string IsDiameterProgrammed Whether the radius word arrives as a diameter (halved on parse) — the lathe X convention, XC only. public bool IsDiameterProgrammed { get; } Property Value bool KeepIndex Axis index untouched by the polar pair (frozen in acts). public int KeepIndex { get; } Property Value int LinearIndex Axis index (0/1/2 = X/Y/Z) carrying the radius. public int LinearIndex { get; } Property Value int LinearWord NC word of the radius coordinate (“X”/“Y”/“Z”). public string LinearWord { get; } Property Value string Mode The pair this definition describes. public PolarModeDirEnum Mode { get; } Property Value PolarModeDirEnum NormalIndex Axis index of the plane normal = the rotation axis; also the depth axis and the ABC component of the machine angle. public int NormalIndex { get; } Property Value int RotaryAxis Machine rotary letter (“A”/“B”/“C”) — also the NC word of the hypothetical coordinate and the per-axis config key. public string RotaryAxis { get; } Property Value string Methods ComposeAbc(double, Vec3d) Composes a machine ABC vector: the pair's rotary component set to angle_rad, the others inherited from baseAbc_rad. public Vec3d ComposeAbc(double angle_rad, Vec3d baseAbc_rad) Parameters angle_rad double baseAbc_rad Vec3d Returns Vec3d ComposePoint(double, double, Vec3d) Composes a program/machine point from triple-space values: radius on the linear axis, depth on the normal axis, the keep axis inherited from basePoint. public Vec3d ComposePoint(double radius, double depth, Vec3d basePoint) Parameters radius double depth double basePoint Vec3d Returns Vec3d FromDir(string) Resolves a pair from its Dir string (“XC”/“YA”/“ZB”); unknown values fall back to XC. public static PolarPairDef FromDir(string dir) Parameters dir string Returns PolarPairDef FromMode(PolarModeDirEnum) Resolves a pair from its PolarModeDirEnum. public static PolarPairDef FromMode(PolarModeDirEnum mode) Parameters mode PolarModeDirEnum Returns PolarPairDef GetRotary_rad(Vec3d) The pair's rotary component of a machine ABC vector. public double GetRotary_rad(Vec3d abc_rad) Parameters abc_rad Vec3d Returns double"
  },
  "api/Hi.Numerical.Args.html": {
    "href": "api/Hi.Numerical.Args.html",
    "title": "Namespace Hi.Numerical.Args | HiAPI-C# 2025",
    "summary": "Namespace Hi.Numerical.Args Classes PolarPairDef Axis mapping of a Polar Coordinate Interpolation pair (PolarModeDirEnum): which program/machine axes carry the radius, the plane depth, and the rotation. The polar math itself runs in \"triple space\" — the Rxcz vector (linear/radius, hypothetical, depth) with the plane normal fixed at the third component — and is pair-independent; this definition maps the triple's ends onto real axes: NC words on the way in, machine coordinates on the way out. The plane normal equals the rotary's rotation axis (C about Z, A about X, B about Y), so NormalIndex doubles as the ABC component of the angle. The lathe diameter-programming convention (the radius word arrives doubled) applies to the X axis only, i.e. the XC pair — mirroring HardNc PolarEntry, which halves X unconditionally. HardNc's own YA/ZB slots are dead code (never selected); its ProgramOrthogonalPlaneNormal table carried swapped normals for them, corrected alongside this implementation. Enums OrthogonalPlaneFlag Plane Selection Flag. Fanuc Group02 flags. the int value is the plane dir number. PolarModeDirEnum Polar coordinate interpolation mode direction. YA,ZB has not implemented yet."
  },
  "api/Hi.Numerical.ClsfParsers.ClArcMcMotionSemantic.html": {
    "href": "api/Hi.Numerical.ClsfParsers.ClArcMcMotionSemantic.html",
    "title": "Class ClArcMcMotionSemantic | HiAPI-C# 2025",
    "summary": "Class ClArcMcMotionSemantic Namespace Hi.Numerical.ClsfParsers Assembly HiMech.dll MC-machine counterpart of the ClArc branch of ClMotionSemantic: builds the workpiece-frame ClCircleArc from ClArcEvent, transforms it into the kinematic Pn frame (the workpiece→Pn transform wired on ProgramZeroToPnProvider), and emits ActClArcMcXyzabcContour — a true CL-space arc with per-step inverse kinematics. Endpoint machine coordinates come from MachineCoordinateState (this block, solved by ClToMcTransformSyntax + McXyzSyntax) and the previous block's modal state. Feedrate/rapid timing mirrors ClMotionSemantic; like the RTCP linear semantic, a feed move without a usable feedrate drops the motion (with a validation warning) instead of emitting zero duration. public class ClArcMcMotionSemantic : INcSemantic, IMakeXmlSource Inheritance object ClArcMcMotionSemantic Implements INcSemantic IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public string DisplayName { get; } Property Value string XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. public IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.Numerical.ClsfParsers.ClMotionSemantic.html": {
    "href": "api/Hi.Numerical.ClsfParsers.ClMotionSemantic.html",
    "title": "Class ClMotionSemantic | HiAPI-C# 2025",
    "summary": "Class ClMotionSemantic Namespace Hi.Numerical.ClsfParsers Assembly HiMech.dll Resolves the pure-CL motion forms into cutter-location acts that drive a ClMillingDevice chain directly — no machine coordinates involved: ClTeleport → ActClTeleport, ClLinear → ActClLinear, ClArc → ActClArc. Feed moves also emit ActFeedrate (from the modal Feedrate section); rapid moves emit ActRapid at RapidFeedrate_mmdmin. Durations are path-length / effective feedrate. Contrast with ClLinearMcMotionSemantic, which handles the RTCP form ClLinear of the NC pipeline by deriving CL from machine coordinates — this semantic is its CL-source counterpart and reads endpoints from CutterLocationState instead. public class ClMotionSemantic : INcSemantic, IMakeXmlSource Inheritance object ClMotionSemantic Implements INcSemantic IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public string DisplayName { get; } Property Value string XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. public IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.Numerical.ClsfParsers.ClMotionValveSemantic.html": {
    "href": "api/Hi.Numerical.ClsfParsers.ClMotionValveSemantic.html",
    "title": "Class ClMotionValveSemantic | HiAPI-C# 2025",
    "summary": "Class ClMotionValveSemantic Namespace Hi.Numerical.ClsfParsers Assembly HiMech.dll Valve that routes each block to exactly one motion-semantic family, so the leaves keep a single duty and never need cross-guards: Block carries a MachineCoordinateState section (written by ClToMcTransformSyntax + McXyzSyntax when the chain is an MC machine) → McSemanticList (default: McLinearMotionSemantic for downgraded constant-posture moves, ClLinearMcMotionSemantic for RTCP-style orientation-changing lines, ClArcMcMotionSemantic, ClTeleportMcMotionSemantic). Otherwise (pure-CL ClMillingDevice project) → ClSemanticList (default ClMotionSemantic). The semantic-side counterpart of BundleSyntax composition: children are serialized nested under group elements and reconstructed via XFactory. public class ClMotionValveSemantic : INcSemantic, IMakeXmlSource Inheritance object ClMotionValveSemantic Implements INcSemantic IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ClMotionValveSemantic() Creates the valve with the default CL and MC semantic lists. public ClMotionValveSemantic() ClMotionValveSemantic(XElement, string, string, IProgress<IMessage>) Loads nested semantic lists from XML. public ClMotionValveSemantic(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress) Parameters src XElement baseDirectory string relFile string progress IProgress<IMessage> Properties ClSemanticList Semantics for blocks without machine coordinates (pure CL). public List<INcSemantic> ClSemanticList { get; } Property Value List<INcSemantic> DisplayName The process name shown on UI. public string DisplayName { get; } Property Value string McSemanticList Semantics for blocks carrying a machine-coordinate endpoint. public List<INcSemantic> McSemanticList { get; } Property Value List<INcSemantic> XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. public IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.Numerical.ClsfParsers.ClTeleportMcMotionSemantic.html": {
    "href": "api/Hi.Numerical.ClsfParsers.ClTeleportMcMotionSemantic.html",
    "title": "Class ClTeleportMcMotionSemantic | HiAPI-C# 2025",
    "summary": "Class ClTeleportMcMotionSemantic Namespace Hi.Numerical.ClsfParsers Assembly HiMech.dll MC-machine counterpart of the ClTeleport branch of ClMotionSemantic: emits an instant ActMcXyzabcTeleport from the block's MachineCoordinateState endpoint solved by ClToMcTransformSyntax + McXyzSyntax. Mirrors the pure-CL teleport semantics — no machining step, no time accumulation. public class ClTeleportMcMotionSemantic : INcSemantic, IMakeXmlSource Inheritance object ClTeleportMcMotionSemantic Implements INcSemantic IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public string DisplayName { get; } Property Value string XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. public IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.Numerical.ClsfParsers.ClToMcTransformSyntax.html": {
    "href": "api/Hi.Numerical.ClsfParsers.ClToMcTransformSyntax.html",
    "title": "Class ClToMcTransformSyntax | HiAPI-C# 2025",
    "summary": "Class ClToMcTransformSyntax Namespace Hi.Numerical.ClsfParsers Assembly HiMech.dll Endpoint inverse kinematics for driving an MC machine from CLSF input, expressed in the NC pipeline's transform vocabulary: when the pipeline's NcKinematicsDependency resolves to a live solver (the machining chain is an IXyzabcChain), each pure-CL motion block gets a ToolHeightCompensation section (the active tool's attacher→tip length) plus its chain entry — a translation along the workpiece-frame tool axis, mirroring the RTCP entry of G43p4RtcpSyntax; a PivotTransformSource chain entry — MakePivotTransformMat(IMachineKinematics, Vec3d, Mat4d) anchored to the workpiece frame, absorbing the fixture topology (workpiece→Pn, wired on ProgramZeroToPnProvider) together with the Pn→MC kinematics at the solved endpoint rotary state; the solved rotary axes in raw degrees on MachineCoordinateState (wrapped afterwards by McAbcCyclicPathSyntax) — machine XYZ is not written here; the shared McXyzSyntax composes it from ProgramXyz × chain exactly like the NC pipeline. Without a solver (pure-CL ClMillingDevice project) this syntax is inert and the pipeline stays pure CL. Entry Kind follows the block's posture: when the solved rotary endpoint cyclically equals the previous block's modal state the entries are KindStatic (contour-valid), else KindDynamic (endpoint snapshot; path interpolation stays in CL space with per-step IK in ActClLinearMcXyzabcContour / ActClArcMcXyzabcContour). A ClLinear block whose finished chain has no Dynamic entry downgrades to McLinear — the same HasDynamicEntry(JsonObject) dispatch the NC pipeline uses, where MC-linear and CL-linear tip paths coincide and per-step IK is unnecessary. When the endpoint cannot be solved (e.g. a tilted normal on a 3-axis machine) the block's MotionEvent (and arc payload) is removed together with its ProgramXyz and transform chain — so McXyzSyntax composes nothing and the modal MC lookback skips the unreachable block — and a validation error anchors to the CLSF line; the machine holds position over the bad block. public class ClToMcTransformSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object ClToMcTransformSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.ClsfParsers.ClsfKeys.html": {
    "href": "api/Hi.Numerical.ClsfParsers.ClsfKeys.html",
    "title": "Class ClsfKeys | HiAPI-C# 2025",
    "summary": "Class ClsfKeys Namespace Hi.Numerical.ClsfParsers Assembly HiMech.dll JSON section names and keys specific to the NX-CL (CLSF) pipeline. General sections shared with the NC/CSV pipelines (MotionEvent, Feedrate, SpindleSpeed, Coolant, ToolChange) keep their contracts from Hi.NcParsers.Keywords / ToolChangeSyntax. public static class ClsfKeys Inheritance object ClsfKeys Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields ActiveTool Modal section — the currently loaded tool id (ToolIdKey), written by RecordToToolingSyntax on every LOAD/TOOL block and carried onto every subsequent block by the modal carry — unlike the one-shot ToolChange section (whose IsChange flag must not repeat), so per-block readers (ClToMcTransformSyntax tool-offset resolution) get O(1) access instead of a backward walk to the distant LOAD block. public const string ActiveTool = \"ActiveTool\" Field Value string AxisI Arc axis X component (unit vector). public const string AxisI = \"AxisI\" Field Value string AxisJ Arc axis Y component (unit vector). public const string AxisJ = \"AxisJ\" Field Value string AxisK Arc axis Z component (unit vector). public const string AxisK = \"AxisK\" Field Value string CenterX Arc center X in mm. public const string CenterX = \"CenterX\" Field Value string CenterY Arc center Y in mm. public const string CenterY = \"CenterY\" Field Value string CenterZ Arc center Z in mm. public const string CenterZ = \"CenterZ\" Field Value string ClArcEvent One-shot event on the GOTO block that closes a circle record — the arc geometry ClMotionSemantic resolves together with the begin/end cutter locations. Same keys as ClCircleEvent. public const string ClArcEvent = \"ClArcEvent\" Field Value string ClCircleEvent One-shot event — a CIRCLE/MOVARC record, already transformed to workpiece coordinates (NX axis negation applied). The next GOTO consumes it into a ClArcEvent. Keys: CenterX/CenterY/CenterZ, AxisI/AxisJ/AxisK, Radius, Turns. public const string ClCircleEvent = \"ClCircleEvent\" Field Value string ClRapidEvent One-shot event — a standalone RAPID record. The next GOTO's backward walk turns it into MotionEvent.IsRapid; a passed motion or feedrate event cancels it (legacy CL parser behavior). public const string ClRapidEvent = \"ClRapidEvent\" Field Value string ClsfToolData Modal section — the latest TLDATA/MILL tool geometry, kept for ClsfToolBuildSemantic to materialize a tool on LOAD/TOOL when the tool house has no entry for the id. Keys: D, R0, Rr, Rz, TaperAngle_deg, TipAngle_deg, H. public const string ClsfToolData = \"ClsfToolData\" Field Value string CutterLocationState Modal section — the current cutter location in workpiece coordinates (post-Msys): point X/Y/Z in mm and unit normal I/J/K. Written by RecordToClMotionSyntax on each GOTO block and carried onto every block by the pipeline's modal carry. public const string CutterLocationState = \"CutterLocationState\" Field Value string D Tool diameter in mm. public const string D = \"D\" Field Value string FeedrateEvent One-shot event — a FEDRAT record. Marks the rapid-cancel boundary for the ClRapidEvent backward walk (the modal Feedrate section itself is carried onto every block, so it cannot serve as the boundary). public const string FeedrateEvent = \"FeedrateEvent\" Field Value string H Flute height (CLSF LENGTH field) in mm. public const string H = \"H\" Field Value string I Cutter-axis normal X component (unit vector). public const string I = \"I\" Field Value string J Cutter-axis normal Y component (unit vector). public const string J = \"J\" Field Value string K Cutter-axis normal Z component (unit vector). public const string K = \"K\" Field Value string Matrix The 16-element matrix array inside Msys. public const string Matrix = \"Matrix\" Field Value string Msys Modal section — the CLSF MSYS transform. Holds the Matrix key with a 16-element row-major matrix array (rows = rotation rows then translation, matching Mat4d row-vector convention); wrapped in an object because the modal carry only carries object sections. Absent means identity. public const string Msys = \"Msys\" Field Value string R0 Corner (lower) radius in mm. public const string R0 = \"R0\" Field Value string Radius Arc radius in mm as declared by the record (informational — the resolved ClCircleArc derives radii from the geometry). public const string Radius = \"Radius\" Field Value string Rr Corner-center to tool-axis distance in mm (optional). public const string Rr = \"Rr\" Field Value string Rz Tip to corner-center height in mm (optional). public const string Rz = \"Rz\" Field Value string TaperAngle_deg Taper angle (side, above the corner) in degrees. public const string TaperAngle_deg = \"TaperAngle_deg\" Field Value string TipAngle_deg Tip angle (below the corner) in degrees. public const string TipAngle_deg = \"TipAngle_deg\" Field Value string Turns Full-circle count included in the sweep (CLSF TIMES,n). public const string Turns = \"Turns\" Field Value string X Cutter-location point X in mm. public const string X = \"X\" Field Value string Y Cutter-location point Y in mm. public const string Y = \"Y\" Field Value string Z Cutter-location point Z in mm. public const string Z = \"Z\" Field Value string"
  },
  "api/Hi.Numerical.ClsfParsers.ClsfRecordCleanupSyntax.html": {
    "href": "api/Hi.Numerical.ClsfParsers.ClsfRecordCleanupSyntax.html",
    "title": "Class ClsfRecordCleanupSyntax | HiAPI-C# 2025",
    "summary": "Class ClsfRecordCleanupSyntax Namespace Hi.Numerical.ClsfParsers Assembly HiMech.dll Inspection-stage tail of the CLSF record chain. A record that survived every RecordTo* syntax is dispatched here: words in ExcludedWords — intentional skips (PAINT, TOOL PATH, …), consumed silently; UNITS — MM is the pipeline's native unit (silent); anything else keeps running but warns that coordinates are not converted; SET_WORKPIECE — reported as ignored (the workpiece is project-level configuration, not runner input); anything else — ClsfRecord--Unconsumed validation warning. Must run after every other RecordTo* syntax. public class ClsfRecordCleanupSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object ClsfRecordCleanupSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.ClsfParsers.ClsfRecordSyntax.html": {
    "href": "api/Hi.Numerical.ClsfParsers.ClsfRecordSyntax.html",
    "title": "Class ClsfRecordSyntax | HiAPI-C# 2025",
    "summary": "Class ClsfRecordSyntax Namespace Hi.Numerical.ClsfParsers Assembly HiMech.dll Per-record CLSF parsing syntax. Normalizes the block text (strips $$ comments, joins $ continuation lines), splits it into the record word and its comma-separated parameters, and stamps them into JsonObject under ClsfRecordKey for the downstream RecordTo* syntaxes to consume. Numeric parameters are pre-typed to double. The word is everything before the first / with whitespace runs collapsed — multi-word heads (TOOL PATH) and hyphenated records without parameters (END-OF-PATH) are single words, fixing the legacy parser's first-token-only dispatch. public class ClsfRecordSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object ClsfRecordSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples A GOTO record — word and typed parameters extracted, text fully consumed: #BeforeBuild: { \"UnparsedText\": \"GOTO/10.5,20.25,3.5 $$ approach\" } #AfterBuild: { \"ClsfRecord\": { \"Word\": \"GOTO\", \"Params\": [10.5, 20.25, 3.5] } } A multi-word head with a text parameter: #BeforeBuild: { \"UnparsedText\": \"TOOL PATH/S1,TOOL,MILL_D10\" } #AfterBuild: { \"ClsfRecord\": { \"Word\": \"TOOL PATH\", \"Params\": [\"S1\", \"TOOL\", \"MILL_D10\"] } } A record without parameters: #BeforeBuild: { \"UnparsedText\": \"END-OF-PATH\" } #AfterBuild: { \"ClsfRecord\": { \"Word\": \"END-OF-PATH\", \"Params\": [] } } Fields ClsfRecordKey JSON property name under which the parsed record is stored. public const string ClsfRecordKey = \"ClsfRecord\" Field Value string ParamsKey Key of the parameter array inside the ClsfRecordKey section. public const string ParamsKey = \"Params\" Field Value string WordKey Key of the record word inside the ClsfRecordKey section. public const string WordKey = \"Word\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Normalize(string) Strips the $$ comment of every physical line, removes the trailing $ continuation characters, and joins the lines into one single-line record text. public static string Normalize(string blockText) Parameters blockText string Raw (possibly multi-line) CLSF block text. Returns string The joined single-line record text; empty for comment-only blocks. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.ClsfParsers.ClsfRunnerConfig.html": {
    "href": "api/Hi.Numerical.ClsfParsers.ClsfRunnerConfig.html",
    "title": "Class ClsfRunnerConfig | HiAPI-C# 2025",
    "summary": "Class ClsfRunnerConfig Namespace Hi.Numerical.ClsfParsers Assembly HiMech.dll Configuration dependency for the NX-CL (CLSF) runner: the rapid traverse rate (a CLSF has no machine axes, so RAPID timing needs an assumed rate), the tool-creation policy, and the intentionally skipped record words. Also serves as the pipeline's IRapidFeedrateConfig so the machine-coordinate motion semantics reused from the NC pipeline (McLinearMotionSemantic, ClLinearMcMotionSemantic) time rapids from the same assumed rates — axis-uniform: every linear axis gets RapidFeedrate_mmdmin, every rotary axis RotaryRapidFeedrate_degdmin. public class ClsfRunnerConfig : IRapidFeedrateConfig, INcDependency, IMakeXmlSource Inheritance object ClsfRunnerConfig Implements IRapidFeedrateConfig INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ClsfRunnerConfig() Creates a config with default values. public ClsfRunnerConfig() ClsfRunnerConfig(XElement) Reconstructs a config from its XML element. public ClsfRunnerConfig(XElement src) Parameters src XElement XML element previously produced by MakeXmlSource(string, string, bool). Properties ExcludedWords Record words consumed silently as intentional skips (matched case-insensitively; multi-word heads like TOOL PATH included). public List<string> ExcludedWords { get; set; } Property Value List<string> PreferToolHouse When true (default), a LOAD/TOOL id already present in the tool house keeps the configured tool and the CLSF TLDATA geometry is ignored; when false, TLDATA geometry overwrites the tool-house entry on every load. public bool PreferToolHouse { get; set; } Property Value bool RapidFeedrate_mmdmin Assumed rapid traverse rate in mm/min used to time RAPID moves. public double RapidFeedrate_mmdmin { get; set; } Property Value double RotaryRapidFeedrate_degdmin Assumed rotary rapid traverse rate in deg/min, used by the reused MC motion semantics to time rotary-dominated rapids on an MC machine. public double RotaryRapidFeedrate_degdmin { get; set; } Property Value double XName XML element name used to register this dependency with XFactory. public static string XName { get; } Property Value string Methods GetLinearAxisRapidRate_mmdmin(string) Gets rapid traverse feedrate for a linear axis in mm/min. Returns a default value if the axis is not configured. public double GetLinearAxisRapidRate_mmdmin(string axisName) Parameters axisName string Returns double GetRotaryAxisRapidRate_degdmin(string) Gets rapid traverse feedrate for a rotary axis in deg/min. Returns a default value if the axis is not configured. public double GetRotaryAxisRapidRate_degdmin(string axisName) Parameters axisName string Returns double MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory SetLinearAxisRapidRate_mmdmin(string, double) Sets rapid traverse feedrate for a linear axis in mm/min. public void SetLinearAxisRapidRate_mmdmin(string axisName, double value) Parameters axisName string value double SetRotaryAxisRapidRate_degdmin(string, double) Sets rapid traverse feedrate for a rotary axis in deg/min. public void SetRotaryAxisRapidRate_degdmin(string axisName, double value) Parameters axisName string value double"
  },
  "api/Hi.Numerical.ClsfParsers.ClsfSegmenter.html": {
    "href": "api/Hi.Numerical.ClsfParsers.ClsfSegmenter.html",
    "title": "Class ClsfSegmenter | HiAPI-C# 2025",
    "summary": "Class ClsfSegmenter Namespace Hi.Numerical.ClsfParsers Assembly HiMech.dll Segments an NX CLSF (cutter location source file) stream for the SoftNcRunner pipeline. A record normally occupies one physical line; a line whose text (after stripping the $$ comment) ends with a single $ continues on the next line, so continued lines are joined into one multi-line Sentence for ClsfRecordSyntax to parse. public class ClsfSegmenter : ISegmenter, IToXElement Inheritance object ClsfSegmenter Implements ISegmenter IToXElement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Name Display name of this segmenter. public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods GetSentences(LazyLinkedList<IndexedFileLine>, List<INcDependency>, NcDiagnosticProgress) Segments the indexed file lines into Sentences. public IEnumerable<Sentence> GetSentences(LazyLinkedList<IndexedFileLine> indexedFileLines, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters indexedFileLines LazyLinkedList<IndexedFileLine> The lazy linked list of indexed file lines. ncDependencyList List<INcDependency> Dependency list of the owning runner; segmenters that consume header rows (e.g. CsvSegmenter) read host-wired dependencies from here. May be null in lightweight test fixtures — implementations that need a dependency must null-check. ncDiagnosticProgress NcDiagnosticProgress Diagnostic progress reporter. Returns IEnumerable<Sentence> A sequence of Sentences. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.Numerical.ClsfParsers.ClsfToolBuildSemantic.html": {
    "href": "api/Hi.Numerical.ClsfParsers.ClsfToolBuildSemantic.html",
    "title": "Class ClsfToolBuildSemantic | HiAPI-C# 2025",
    "summary": "Class ClsfToolBuildSemantic Namespace Hi.Numerical.ClsfParsers Assembly HiMech.dll Materializes a milling tool from the modal ClsfToolData geometry (CLSF TLDATA/MILL) into the MachiningToolHouse when a ToolChange section requests a tool id the house does not hold — CLSF files carry their own tool definitions, so a project does not need to pre-configure every tool. With PreferToolHouse (default) an existing entry always wins. Emits no acts; must run before ToolChangeSemantic so the tool exists when the tooling act is executed. public class ClsfToolBuildSemantic : INcSemantic, IMakeXmlSource Inheritance object ClsfToolBuildSemantic Implements INcSemantic IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public string DisplayName { get; } Property Value string XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. public IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.Numerical.ClsfParsers.MsysCoordinateOffsetSyntax.html": {
    "href": "api/Hi.Numerical.ClsfParsers.MsysCoordinateOffsetSyntax.html",
    "title": "Class MsysCoordinateOffsetSyntax | HiAPI-C# 2025",
    "summary": "Class MsysCoordinateOffsetSyntax Namespace Hi.Numerical.ClsfParsers Assembly HiMech.dll Expresses the modal CLSF MSYS frame in the NC pipeline's transform vocabulary on machine-coordinate motion blocks: the rotation part becomes a TransformSource entry (the G68.2 tilted-work-plane analogue) and the translation part becomes a TransformSource entry plus CoordinateOffset section (the G54 work-offset analogue, CoordinateId MsysCoordinateId) in ProgramToMcTransform. It also restores the commanded ProgramXyz — the MSYS-local GOTO point — from the workpiece-frame CutterLocationState endpoint, so the shared McXyzSyntax composes machine XYZ exactly like the NC pipeline: ProgramXyz × composed chain → MachineCoordinateState. Entry order carries the math: the MSYS matrix maps local points as p·R + t (row-vector convention), so the rotation entry precedes the translation entry. Both are KindStatic — an MSYS is a fixed frame for every point of the blocks it governs. The rotation entry is omitted for a pure-translation MSYS (and for the absent-MSYS identity), keeping the common dump exactly G54-shaped. Inert without a wired kinematics solver (pure-CL ClMillingDevice project) and on non-motion blocks: the pure-CL pipeline keeps its own CL vocabulary and must never receive ProgramXyz or a transform chain — McXyzSyntax would otherwise fabricate a MachineCoordinateState and misroute the block to the machine-coordinate semantics. ClToMcTransformSyntax continues the chain with the tool-height and kinematic-pivot entries. public class MsysCoordinateOffsetSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object MsysCoordinateOffsetSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields MsysCoordinateId CoordinateId written for the MSYS translation — the CLSF pipeline's stand-in for a G54-series id. public const string MsysCoordinateId = \"MSYS\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.ClsfParsers.NxClRunner.html": {
    "href": "api/Hi.Numerical.ClsfParsers.NxClRunner.html",
    "title": "Class NxClRunner | HiAPI-C# 2025",
    "summary": "Class NxClRunner Namespace Hi.Numerical.ClsfParsers Assembly HiMech.dll Factory for a SoftNcRunner that reads NX CLSF (cutter location source file) input. On a ClMillingDevice chain it resolves into pure-CL acts (ActClTeleport/ActClLinear/ActClArc); on an MC machine (IXyzabcChain, detected through the wired NcKinematicsDependency) each motion block is expressed in the NC pipeline's transform vocabulary — MsysCoordinateOffsetSyntax writes the MSYS work-offset entries plus ProgramXyz, ClToMcTransformSyntax inverse-solves the endpoint rotary state and writes the tool-height / kinematic-pivot entries, the shared McXyzSyntax composes MachineCoordinateState from ProgramXyz × chain — and ClMotionValveSemantic routes the block to the machine-coordinate semantics instead. The record chain maps each CLSF record into the same standardized JSON sections the NC/CSV pipelines use (Feedrate, SpindleSpeed, Coolant, ToolChange, MotionEvent), so the general semantics are reused unchanged; only the motion and tool-creation semantics are CLSF-specific. The modal carry runs first in the record bundle (unlike the NC pipeline's carry-at-the-end): each piece receives the previous block's modal sections (Msys, CutterLocationState, tool data, feedrate, …) before its own record is resolved, so a GOTO reads its begin point and MSYS from its own piece and then overwrites the state with the new endpoint. public static class NxClRunner Inheritance object NxClRunner Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods Create() Builds a fresh SoftNcRunner pre-configured to read NX CLSF input. Call once per machining session so the runner's per-session state starts clean. public static SoftNcRunner Create() Returns SoftNcRunner Reg(XFactory) Registers the CLSF-module components Create() instantiates with the given XFactory. The general components it reuses (BundleSyntax, ModalCarrySyntax, ToolingTeleportSemantic, SpindleSpeedSemantic, CoolantSemantic) are registered by Reg(XFactory). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.ClsfParsers.RecordToClMotionSyntax.html": {
    "href": "api/Hi.Numerical.ClsfParsers.RecordToClMotionSyntax.html",
    "title": "Class RecordToClMotionSyntax | HiAPI-C# 2025",
    "summary": "Class RecordToClMotionSyntax Namespace Hi.Numerical.ClsfParsers Assembly HiMech.dll Translates the CLSF motion records into the pure-CL motion contract: RAPID → one-shot ClRapidEvent (armed until the next GOTO; a passed motion or FEDRAT cancels it). CIRCLE/MOVARC → one-shot ClCircleEvent in workpiece coordinates, with the NX axis-direction negation applied. GOTO → the modal CutterLocationState endpoint (MSYS applied) plus a one-shot MotionEvent whose Form is ClTeleport (first motion, FROM, or first motion after a tool change), ClArc (an armed circle record), or ClLinear; an arc GOTO also receives the consumed circle geometry as ClArcEvent. Requires the pipeline's modal carry to run before this syntax on each node, so the previous endpoint / MSYS are already present on the current piece when the GOTO is resolved. public class RecordToClMotionSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object RecordToClMotionSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.ClsfParsers.RecordToCoolantSyntax.html": {
    "href": "api/Hi.Numerical.ClsfParsers.RecordToCoolantSyntax.html",
    "title": "Class RecordToCoolantSyntax | HiAPI-C# 2025",
    "summary": "Class RecordToCoolantSyntax Namespace Hi.Numerical.ClsfParsers Assembly HiMech.dll Translates a COOLNT record into the standardized ICoolantDef section consumed by the general CoolantSemantic: ON/FLOOD → Flood, MIST → Mist, OFF → Off; other CLSF coolant modes fall back to flood with a configuration warning. public class RecordToCoolantSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object RecordToCoolantSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.ClsfParsers.RecordToFeedrateSyntax.html": {
    "href": "api/Hi.Numerical.ClsfParsers.RecordToFeedrateSyntax.html",
    "title": "Class RecordToFeedrateSyntax | HiAPI-C# 2025",
    "summary": "Class RecordToFeedrateSyntax Namespace Hi.Numerical.ClsfParsers Assembly HiMech.dll Translates a FEDRAT record into the standardized modal Feedrate section (always G94 — mm/min) plus the one-shot FeedrateEvent marker that cancels a pending ClRapidEvent. Accepted dialects: FEDRAT/MMPM,1400, FEDRAT/1400,MMPM, FEDRAT/1400 (MMPM assumed), and IPM (converted to mm/min). public class RecordToFeedrateSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object RecordToFeedrateSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.ClsfParsers.RecordToMsysSyntax.html": {
    "href": "api/Hi.Numerical.ClsfParsers.RecordToMsysSyntax.html",
    "title": "Class RecordToMsysSyntax | HiAPI-C# 2025",
    "summary": "Class RecordToMsysSyntax Namespace Hi.Numerical.ClsfParsers Assembly HiMech.dll Translates an MSYS record into the modal Msys section. The record's nine fields are a translation vector plus the first two rows of a rotation matrix whose third row is their cross product; the section stores the resulting 16-element row-major Mat4d mapping tool-path coordinates to workpiece (absolute) coordinates. public class RecordToMsysSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object RecordToMsysSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.ClsfParsers.RecordToSpindleSyntax.html": {
    "href": "api/Hi.Numerical.ClsfParsers.RecordToSpindleSyntax.html",
    "title": "Class RecordToSpindleSyntax | HiAPI-C# 2025",
    "summary": "Class RecordToSpindleSyntax Namespace Hi.Numerical.ClsfParsers Assembly HiMech.dll Translates a SPINDL record into the standardized ISpindleSpeedDef section consumed by the general SpindleSpeedSemantic. Parameter order is tolerated (SPINDL/8000,RPM,CLW or SPINDL/RPM,8000,CLW): the first numeric field is the rpm, a field containing CCLW selects counter-clockwise, and SPINDL/OFF maps to STOP. public class RecordToSpindleSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object RecordToSpindleSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.ClsfParsers.RecordToToolingSyntax.html": {
    "href": "api/Hi.Numerical.ClsfParsers.RecordToToolingSyntax.html",
    "title": "Class RecordToToolingSyntax | HiAPI-C# 2025",
    "summary": "Class RecordToToolingSyntax Namespace Hi.Numerical.ClsfParsers Assembly HiMech.dll Translates the CLSF tooling records: TLDATA/MILL,… → the modal ClsfToolData geometry section (kept for ClsfToolBuildSemantic); non-MILL tool types are reported and skipped. LOAD/TOOL,n[,XOFF,x][,YOFF,y][,ZOFF,z] → the standardized ToolChange section (SectionName) consumed by the general ToolChangeSemantic; IsChangeKey is set when the tool id differs from the previously loaded tool. Offsets are recorded informationally (no consumer yet). public class RecordToToolingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object RecordToToolingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields OffsetXKey Informational key — LOAD/…XOFF value in mm. public const string OffsetXKey = \"OffsetX\" Field Value string OffsetYKey Informational key — LOAD/…YOFF value in mm. public const string OffsetYKey = \"OffsetY\" Field Value string OffsetZKey Informational key — LOAD/…ZOFF value in mm. public const string OffsetZKey = \"OffsetZ\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.ClsfParsers.html": {
    "href": "api/Hi.Numerical.ClsfParsers.html",
    "title": "Namespace Hi.Numerical.ClsfParsers | HiAPI-C# 2025",
    "summary": "Namespace Hi.Numerical.ClsfParsers Classes ClArcMcMotionSemantic MC-machine counterpart of the ClArc branch of ClMotionSemantic: builds the workpiece-frame ClCircleArc from ClArcEvent, transforms it into the kinematic Pn frame (the workpiece→Pn transform wired on ProgramZeroToPnProvider), and emits ActClArcMcXyzabcContour — a true CL-space arc with per-step inverse kinematics. Endpoint machine coordinates come from MachineCoordinateState (this block, solved by ClToMcTransformSyntax + McXyzSyntax) and the previous block's modal state. Feedrate/rapid timing mirrors ClMotionSemantic; like the RTCP linear semantic, a feed move without a usable feedrate drops the motion (with a validation warning) instead of emitting zero duration. ClMotionSemantic Resolves the pure-CL motion forms into cutter-location acts that drive a ClMillingDevice chain directly — no machine coordinates involved: ClTeleport → ActClTeleport, ClLinear → ActClLinear, ClArc → ActClArc. Feed moves also emit ActFeedrate (from the modal Feedrate section); rapid moves emit ActRapid at RapidFeedrate_mmdmin. Durations are path-length / effective feedrate. Contrast with ClLinearMcMotionSemantic, which handles the RTCP form ClLinear of the NC pipeline by deriving CL from machine coordinates — this semantic is its CL-source counterpart and reads endpoints from CutterLocationState instead. ClMotionValveSemantic Valve that routes each block to exactly one motion-semantic family, so the leaves keep a single duty and never need cross-guards: Block carries a MachineCoordinateState section (written by ClToMcTransformSyntax + McXyzSyntax when the chain is an MC machine) → McSemanticList (default: McLinearMotionSemantic for downgraded constant-posture moves, ClLinearMcMotionSemantic for RTCP-style orientation-changing lines, ClArcMcMotionSemantic, ClTeleportMcMotionSemantic). Otherwise (pure-CL ClMillingDevice project) → ClSemanticList (default ClMotionSemantic). The semantic-side counterpart of BundleSyntax composition: children are serialized nested under group elements and reconstructed via XFactory. ClTeleportMcMotionSemantic MC-machine counterpart of the ClTeleport branch of ClMotionSemantic: emits an instant ActMcXyzabcTeleport from the block's MachineCoordinateState endpoint solved by ClToMcTransformSyntax + McXyzSyntax. Mirrors the pure-CL teleport semantics — no machining step, no time accumulation. ClToMcTransformSyntax Endpoint inverse kinematics for driving an MC machine from CLSF input, expressed in the NC pipeline's transform vocabulary: when the pipeline's NcKinematicsDependency resolves to a live solver (the machining chain is an IXyzabcChain), each pure-CL motion block gets a ToolHeightCompensation section (the active tool's attacher→tip length) plus its chain entry — a translation along the workpiece-frame tool axis, mirroring the RTCP entry of G43p4RtcpSyntax; a PivotTransformSource chain entry — MakePivotTransformMat(IMachineKinematics, Vec3d, Mat4d) anchored to the workpiece frame, absorbing the fixture topology (workpiece→Pn, wired on ProgramZeroToPnProvider) together with the Pn→MC kinematics at the solved endpoint rotary state; the solved rotary axes in raw degrees on MachineCoordinateState (wrapped afterwards by McAbcCyclicPathSyntax) — machine XYZ is not written here; the shared McXyzSyntax composes it from ProgramXyz × chain exactly like the NC pipeline. Without a solver (pure-CL ClMillingDevice project) this syntax is inert and the pipeline stays pure CL. Entry Kind follows the block's posture: when the solved rotary endpoint cyclically equals the previous block's modal state the entries are KindStatic (contour-valid), else KindDynamic (endpoint snapshot; path interpolation stays in CL space with per-step IK in ActClLinearMcXyzabcContour / ActClArcMcXyzabcContour). A ClLinear block whose finished chain has no Dynamic entry downgrades to McLinear — the same HasDynamicEntry(JsonObject) dispatch the NC pipeline uses, where MC-linear and CL-linear tip paths coincide and per-step IK is unnecessary. When the endpoint cannot be solved (e.g. a tilted normal on a 3-axis machine) the block's MotionEvent (and arc payload) is removed together with its ProgramXyz and transform chain — so McXyzSyntax composes nothing and the modal MC lookback skips the unreachable block — and a validation error anchors to the CLSF line; the machine holds position over the bad block. ClsfKeys JSON section names and keys specific to the NX-CL (CLSF) pipeline. General sections shared with the NC/CSV pipelines (MotionEvent, Feedrate, SpindleSpeed, Coolant, ToolChange) keep their contracts from Hi.NcParsers.Keywords / ToolChangeSyntax. ClsfRecordCleanupSyntax Inspection-stage tail of the CLSF record chain. A record that survived every RecordTo* syntax is dispatched here: words in ExcludedWords — intentional skips (PAINT, TOOL PATH, …), consumed silently; UNITS — MM is the pipeline's native unit (silent); anything else keeps running but warns that coordinates are not converted; SET_WORKPIECE — reported as ignored (the workpiece is project-level configuration, not runner input); anything else — ClsfRecord--Unconsumed validation warning. Must run after every other RecordTo* syntax. ClsfRecordSyntax Per-record CLSF parsing syntax. Normalizes the block text (strips $$ comments, joins $ continuation lines), splits it into the record word and its comma-separated parameters, and stamps them into JsonObject under ClsfRecordKey for the downstream RecordTo* syntaxes to consume. Numeric parameters are pre-typed to double. The word is everything before the first / with whitespace runs collapsed — multi-word heads (TOOL PATH) and hyphenated records without parameters (END-OF-PATH) are single words, fixing the legacy parser's first-token-only dispatch. ClsfRunnerConfig Configuration dependency for the NX-CL (CLSF) runner: the rapid traverse rate (a CLSF has no machine axes, so RAPID timing needs an assumed rate), the tool-creation policy, and the intentionally skipped record words. Also serves as the pipeline's IRapidFeedrateConfig so the machine-coordinate motion semantics reused from the NC pipeline (McLinearMotionSemantic, ClLinearMcMotionSemantic) time rapids from the same assumed rates — axis-uniform: every linear axis gets RapidFeedrate_mmdmin, every rotary axis RotaryRapidFeedrate_degdmin. ClsfSegmenter Segments an NX CLSF (cutter location source file) stream for the SoftNcRunner pipeline. A record normally occupies one physical line; a line whose text (after stripping the $$ comment) ends with a single $ continues on the next line, so continued lines are joined into one multi-line Sentence for ClsfRecordSyntax to parse. ClsfToolBuildSemantic Materializes a milling tool from the modal ClsfToolData geometry (CLSF TLDATA/MILL) into the MachiningToolHouse when a ToolChange section requests a tool id the house does not hold — CLSF files carry their own tool definitions, so a project does not need to pre-configure every tool. With PreferToolHouse (default) an existing entry always wins. Emits no acts; must run before ToolChangeSemantic so the tool exists when the tooling act is executed. MsysCoordinateOffsetSyntax Expresses the modal CLSF MSYS frame in the NC pipeline's transform vocabulary on machine-coordinate motion blocks: the rotation part becomes a TransformSource entry (the G68.2 tilted-work-plane analogue) and the translation part becomes a TransformSource entry plus CoordinateOffset section (the G54 work-offset analogue, CoordinateId MsysCoordinateId) in ProgramToMcTransform. It also restores the commanded ProgramXyz — the MSYS-local GOTO point — from the workpiece-frame CutterLocationState endpoint, so the shared McXyzSyntax composes machine XYZ exactly like the NC pipeline: ProgramXyz × composed chain → MachineCoordinateState. Entry order carries the math: the MSYS matrix maps local points as p·R + t (row-vector convention), so the rotation entry precedes the translation entry. Both are KindStatic — an MSYS is a fixed frame for every point of the blocks it governs. The rotation entry is omitted for a pure-translation MSYS (and for the absent-MSYS identity), keeping the common dump exactly G54-shaped. Inert without a wired kinematics solver (pure-CL ClMillingDevice project) and on non-motion blocks: the pure-CL pipeline keeps its own CL vocabulary and must never receive ProgramXyz or a transform chain — McXyzSyntax would otherwise fabricate a MachineCoordinateState and misroute the block to the machine-coordinate semantics. ClToMcTransformSyntax continues the chain with the tool-height and kinematic-pivot entries. NxClRunner Factory for a SoftNcRunner that reads NX CLSF (cutter location source file) input. On a ClMillingDevice chain it resolves into pure-CL acts (ActClTeleport/ActClLinear/ActClArc); on an MC machine (IXyzabcChain, detected through the wired NcKinematicsDependency) each motion block is expressed in the NC pipeline's transform vocabulary — MsysCoordinateOffsetSyntax writes the MSYS work-offset entries plus ProgramXyz, ClToMcTransformSyntax inverse-solves the endpoint rotary state and writes the tool-height / kinematic-pivot entries, the shared McXyzSyntax composes MachineCoordinateState from ProgramXyz × chain — and ClMotionValveSemantic routes the block to the machine-coordinate semantics instead. The record chain maps each CLSF record into the same standardized JSON sections the NC/CSV pipelines use (Feedrate, SpindleSpeed, Coolant, ToolChange, MotionEvent), so the general semantics are reused unchanged; only the motion and tool-creation semantics are CLSF-specific. The modal carry runs first in the record bundle (unlike the NC pipeline's carry-at-the-end): each piece receives the previous block's modal sections (Msys, CutterLocationState, tool data, feedrate, …) before its own record is resolved, so a GOTO reads its begin point and MSYS from its own piece and then overwrites the state with the new endpoint. RecordToClMotionSyntax Translates the CLSF motion records into the pure-CL motion contract: RAPID → one-shot ClRapidEvent (armed until the next GOTO; a passed motion or FEDRAT cancels it). CIRCLE/MOVARC → one-shot ClCircleEvent in workpiece coordinates, with the NX axis-direction negation applied. GOTO → the modal CutterLocationState endpoint (MSYS applied) plus a one-shot MotionEvent whose Form is ClTeleport (first motion, FROM, or first motion after a tool change), ClArc (an armed circle record), or ClLinear; an arc GOTO also receives the consumed circle geometry as ClArcEvent. Requires the pipeline's modal carry to run before this syntax on each node, so the previous endpoint / MSYS are already present on the current piece when the GOTO is resolved. RecordToCoolantSyntax Translates a COOLNT record into the standardized ICoolantDef section consumed by the general CoolantSemantic: ON/FLOOD → Flood, MIST → Mist, OFF → Off; other CLSF coolant modes fall back to flood with a configuration warning. RecordToFeedrateSyntax Translates a FEDRAT record into the standardized modal Feedrate section (always G94 — mm/min) plus the one-shot FeedrateEvent marker that cancels a pending ClRapidEvent. Accepted dialects: FEDRAT/MMPM,1400, FEDRAT/1400,MMPM, FEDRAT/1400 (MMPM assumed), and IPM (converted to mm/min). RecordToMsysSyntax Translates an MSYS record into the modal Msys section. The record's nine fields are a translation vector plus the first two rows of a rotation matrix whose third row is their cross product; the section stores the resulting 16-element row-major Mat4d mapping tool-path coordinates to workpiece (absolute) coordinates. RecordToSpindleSyntax Translates a SPINDL record into the standardized ISpindleSpeedDef section consumed by the general SpindleSpeedSemantic. Parameter order is tolerated (SPINDL/8000,RPM,CLW or SPINDL/RPM,8000,CLW): the first numeric field is the rpm, a field containing CCLW selects counter-clockwise, and SPINDL/OFF maps to STOP. RecordToToolingSyntax Translates the CLSF tooling records: TLDATA/MILL,… → the modal ClsfToolData geometry section (kept for ClsfToolBuildSemantic); non-MILL tool types are reported and skipped. LOAD/TOOL,n[,XOFF,x][,YOFF,y][,ZOFF,z] → the standardized ToolChange section (SectionName) consumed by the general ToolChangeSemantic; IsChangeKey is set when the tool id differs from the previously loaded tool. Offsets are recorded informationally (no consumer yet)."
  },
  "api/Hi.Numerical.CncBrand.html": {
    "href": "api/Hi.Numerical.CncBrand.html",
    "title": "Enum CncBrand | HiAPI-C# 2025",
    "summary": "Enum CncBrand Namespace Hi.Numerical Assembly HiUniNc.dll Represents different CNC controller brands supported by the system. public enum CncBrand Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Fanuc = 0 Fanuc CNC controller. Heidenhain = 1 Heidenhain CNC controller. Mazak = 2 Mazak CNC controller. Siemens = 3 Siemens CNC controller. Syntec = 4 Syntec CNC controller."
  },
  "api/Hi.Numerical.CommentMark.html": {
    "href": "api/Hi.Numerical.CommentMark.html",
    "title": "Enum CommentMark | HiAPI-C# 2025",
    "summary": "Enum CommentMark Namespace Hi.Numerical Assembly HiUniNc.dll Enumeration of different comment mark types used in NC code. public enum CommentMark Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields DoubleSlash = 3 Double slash style comments, e.g. //This is a comment. HeadPercent = 4 Percent sign at the beginning style comments, e.g. %This is a comment. Quote = 1 Parenthesis style comments, e.g. (This is a comment). Semicolon = 2 Semicolon style comments, e.g. ;This is a comment."
  },
  "api/Hi.Numerical.CoolantMode.html": {
    "href": "api/Hi.Numerical.CoolantMode.html",
    "title": "Enum CoolantMode | HiAPI-C# 2025",
    "summary": "Enum CoolantMode Namespace Hi.Numerical Assembly HiGeom.dll Cutting-fluid delivery mode parsed from typical NC coolant machine functions (e.g. M07 / M08 / M09). Values are consumed by higher-level machining simulation and thermal models that map each mode to convection and temperature assumptions. public enum CoolantMode Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Flood = 3 Flood coolant (M08). High-volume liquid stream (typically 0.5–10 L/min of water-based emulsion); used as the reference mode for full liquid-jet convection in downstream thermal calculations. Mist = 2 Mist coolant / Minimum Quantity Lubrication, MQL (M07). Fine oil aerosol; relies primarily on evaporation for heat removal. Empirically about half the convective heat-transfer of flood coolant; thermal solvers typically apply a configurable mist-to-flood convection ratio when this mode is active. Off = 1 Coolant off (M09). No active coolant stream. UnDefined = 0 Undefined / uninitialised. State before the first coolant act has been processed. Treated as Off by physics consumers."
  },
  "api/Hi.Numerical.CoordinateInterpolationMode.html": {
    "href": "api/Hi.Numerical.CoordinateInterpolationMode.html",
    "title": "Enum CoordinateInterpolationMode | HiAPI-C# 2025",
    "summary": "Enum CoordinateInterpolationMode Namespace Hi.Numerical Assembly HiUniNc.dll Defines the coordinate interpolation mode for NC operations. public enum CoordinateInterpolationMode Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Cartesian = 1 Standard Cartesian coordinate system interpolation. Polar = 2 Polar coordinate system interpolation."
  },
  "api/Hi.Numerical.CsvParsers.CsvActDataSemantic.html": {
    "href": "api/Hi.Numerical.CsvParsers.CsvActDataSemantic.html",
    "title": "Class CsvActDataSemantic | HiAPI-C# 2025",
    "summary": "Class CsvActDataSemantic Namespace Hi.Numerical.CsvParsers Assembly HiMech.dll CSV extension semantic: emits ActData from the residual CsvRow columns — those not claimed by any RowTo*Syntax (tool id, spindle, feedrate, coolant, time, csscript) nor by the machine / cutter coordinate prefixes. A caller-supplied ParsingDictionary entry is applied to its column's raw text; the rest pass through as their pre-typed number / bool / string. Carries arbitrary recorded channels (file/line bookkeeping, sensor columns, etc.) onto the step. public class CsvActDataSemantic : INcSemantic, IMakeXmlSource Inheritance object CsvActDataSemantic Implements INcSemantic IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public string DisplayName { get; } Property Value string XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. public IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.Numerical.CsvParsers.CsvActualTimeSemantic.html": {
    "href": "api/Hi.Numerical.CsvParsers.CsvActualTimeSemantic.html",
    "title": "Class CsvActualTimeSemantic | HiAPI-C# 2025",
    "summary": "Class CsvActualTimeSemantic Namespace Hi.Numerical.CsvParsers Assembly HiMech.dll CSV extension semantic: emits ActActualTimecode from the ActualTimeTag cell of the decoded CsvRow. This is telemetry the general semantic list does not cover — the absolute controller timestamp of the recorded sample. Stateless; the duration that consumes this timestamp is computed independently by CsvMotionSemantic via Hi.Numerical.CsvParsers.CsvTimingUtil. public class CsvActualTimeSemantic : INcSemantic, IMakeXmlSource Inheritance object CsvActualTimeSemantic Implements INcSemantic IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public string DisplayName { get; } Property Value string XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. public IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.Numerical.CsvParsers.CsvMotionSemantic.html": {
    "href": "api/Hi.Numerical.CsvParsers.CsvMotionSemantic.html",
    "title": "Class CsvMotionSemantic | HiAPI-C# 2025",
    "summary": "Class CsvMotionSemantic Namespace Hi.Numerical.CsvParsers Assembly HiMech.dll CSV motion semantic — the recorded-duration counterpart of the general McLinearMotionSemantic. Reads the same standardized sections (IMotionEventDef, MachineCoordinateState, IFeedrateDef) the general motion semantic reads, but derives the move's duration from the recorded CSV timing (ResolveDuration(LazyLinkedListNode<SyntaxPiece>)) instead of feedrate × distance — because CSV is replayed telemetry where time is given, not computed. First coordinate row (no previous MC) → ActMcXyzabcStep to the point; subsequent rows → ActMcXyzabcLinearContour from the previous point. The recorded feedrate is emitted as a standalone ActFeedrate on change. Because the upstream RowToMotionEventSyntax writes the full general motion-section contract, this semantic can be replaced one-for-one with McLinearMotionSemantic to fall back to feedrate-derived timing. public class CsvMotionSemantic : INcSemantic, IMakeXmlSource Inheritance object CsvMotionSemantic Implements INcSemantic IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DisplayName The process name shown on UI. public string DisplayName { get; } Property Value string XName XML element name used to register and serialize this semantic. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Resolve(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Resolve the syntaxPieceNode into a sequence of IAct. May also mutate SyntaxPiece.JsonObject for downstream semantics. public IEnumerable<IAct> Resolve(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> dependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> dependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress Returns IEnumerable<IAct>"
  },
  "api/Hi.Numerical.CsvParsers.CsvRowSyntax.html": {
    "href": "api/Hi.Numerical.CsvParsers.CsvRowSyntax.html",
    "title": "Class CsvRowSyntax | HiAPI-C# 2025",
    "summary": "Class CsvRowSyntax Namespace Hi.Numerical.CsvParsers Assembly HiMech.dll Per-row CSV parsing syntax for the soft NC runner. Reads the active TitleList via SegmenterDependency, splits the row text using GetCsvDictionary(IList<string>, string), and stamps the resulting column→value map into JsonObject under the CsvRowKey property for the downstream CSV syntaxes and semantics to consume. Numeric cells are pre-typed to double (or bool) at this stage so downstream readers — including the CSV semantics' backwards walk for the previous machine coordinate — touch native JSON numbers instead of re-parsing strings on every visit. Columns kept as strings: the script / time / spindle-direction tags whose semantic interpretation is non-numeric, plus any column whose key appears in ParsingDictionary (the caller-supplied parsing function expects the raw cell text). public class CsvRowSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object CsvRowSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields CsvRowKey JSON property name under which the parsed row dictionary is stored. public const string CsvRowKey = \"CsvRow\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.CsvParsers.CsvRunnerConfig.html": {
    "href": "api/Hi.Numerical.CsvParsers.CsvRunnerConfig.html",
    "title": "Class CsvRunnerConfig | HiAPI-C# 2025",
    "summary": "Class CsvRunnerConfig Namespace Hi.Numerical.CsvParsers Assembly HiMech.dll Configuration class for CSV Runner. Lives in PipelineNcDependencyList when wired with GeneralCsvRunner; consumed by CsvRowSyntax and the CSV row syntaxes/semantics for tag-name lookup and custom-field parsing. public class CsvRunnerConfig : INcDependency, IMakeXmlSource Inheritance object CsvRunnerConfig Implements INcDependency IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CsvRunnerConfig() Default constructor. public CsvRunnerConfig() CsvRunnerConfig(XElement) Constructor from XML. public CsvRunnerConfig(XElement src) Parameters src XElement XML element Properties ActualTimeTag Actual time tag for CSV parsing. public string ActualTimeTag { get; set; } Property Value string CoolantTag Coolant tag for CSV parsing. The cell holds the coolant mode name (Flood / Mist / Off) or a boolean on/off flag. public string CoolantTag { get; set; } Property Value string CutterLocationPrefix Cutter Location Prefix Tag for CSV Parsing. public string CutterLocationPrefix { get; set; } Property Value string DurationTag Duration tag for CSV parsing. public string DurationTag { get; set; } Property Value string FeedrateTag_mmdmin Feedrate for Simulator Tag for CSV Parsing. public string FeedrateTag_mmdmin { get; set; } Property Value string LineBeginCsScriptTag LineBeginCsScript Tag for CSV Parsing. public string LineBeginCsScriptTag { get; set; } Property Value string LineEndCsScriptTag LineEndCsScript Tag for CSV Parsing. public string LineEndCsScriptTag { get; set; } Property Value string MachineCoordinatePrefix Machine Coordinate Prefix Tag for CSV Parsing. public string MachineCoordinatePrefix { get; set; } Property Value string ParsingDictionary Parsing dictionary for custom field parsing. Note: This dictionary cannot be serialized to XML as it contains functions. public Dictionary<string, Func<string, object>> ParsingDictionary { get; set; } Property Value Dictionary<string, Func<string, object>> SpindleDirectionTag Spindle direction Tag for CSV Parsing. public string SpindleDirectionTag { get; set; } Property Value string SpindleSpeedTag_rpm Spindle speed for Simulator Tag for CSV Parsing. public string SpindleSpeedTag_rpm { get; set; } Property Value string ToolIdTag Tool ID Tag for CSV Parsing. public string ToolIdTag { get; set; } Property Value string XName Name for XML IO. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.CsvParsers.CsvSegmenter.html": {
    "href": "api/Hi.Numerical.CsvParsers.CsvSegmenter.html",
    "title": "Class CsvSegmenter | HiAPI-C# 2025",
    "summary": "Class CsvSegmenter Namespace Hi.Numerical.CsvParsers Assembly HiMech.dll Segments a CSV stream for the SoftNcRunner pipeline. Consumes the first IndexedFileLine as the title row (populating TitleList and registering any new columns as step variables via StepPropertyAccessDictionaryDependency), then yields each subsequent line as a one-line Sentence for CsvRowSyntax to parse. public class CsvSegmenter : ISegmenter, IToXElement Inheritance object CsvSegmenter Implements ISegmenter IToXElement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Name Display name of this segmenter. public string Name { get; } Property Value string TitleList Column titles parsed from the first row of the most recent GetSentences(LazyLinkedList<IndexedFileLine>, List<INcDependency>, NcDiagnosticProgress) invocation. Quote- and whitespace-trimmed to match the convention established in the legacy CsvRunner. Reset on each new call so per-file headers stay accurate across multi-file sessions. public List<string> TitleList { get; } Property Value List<string> XName XML element name for Generators registration. public static string XName { get; } Property Value string Methods GetSentences(LazyLinkedList<IndexedFileLine>, List<INcDependency>, NcDiagnosticProgress) Segments the indexed file lines into Sentences. public IEnumerable<Sentence> GetSentences(LazyLinkedList<IndexedFileLine> indexedFileLines, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters indexedFileLines LazyLinkedList<IndexedFileLine> The lazy linked list of indexed file lines. ncDependencyList List<INcDependency> Dependency list of the owning runner; segmenters that consume header rows (e.g. CsvSegmenter) read host-wired dependencies from here. May be null in lightweight test fixtures — implementations that need a dependency must null-check. ncDiagnosticProgress NcDiagnosticProgress Diagnostic progress reporter. Returns IEnumerable<Sentence> A sequence of Sentences. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.Numerical.CsvParsers.GeneralCsvRunner.html": {
    "href": "api/Hi.Numerical.CsvParsers.GeneralCsvRunner.html",
    "title": "Class GeneralCsvRunner | HiAPI-C# 2025",
    "summary": "Class GeneralCsvRunner Namespace Hi.Numerical.CsvParsers Assembly HiMech.dll Factory for a SoftNcRunner that replays CSV telemetry through the general-semantics architecture: a chain of small RowTo*Syntax classes maps each decoded CsvRow into the same standardized JSON sections the brand-NC pipeline writes (SpindleSpeed, Feedrate, Coolant, CsScript, ToolChange, MachineCoordinateState, MotionEvent), and a mostly-general semantic list resolves them into acts. A handful of CSV extension semantics cover telemetry the general list does not (CsvActualTimeSemantic, CsvMotionSemantic, CsvActDataSemantic); tool changes ride the general ToolingTeleportSemantic (the tool jumps to its recorded position — no modelled tool-changer cycle). This is the flagship CSV runner — it superseded an earlier single-syntax / single-semantic pipeline. Recorded vs. computed timing. CSV is replayed telemetry, so CsvMotionSemantic uses the recorded sample duration (StepDuration / ActualTime delta) rather than feedrate × distance. Because RowToMotionEventSyntax still writes the full general motion-section contract, swapping CsvMotionSemantic for the general McLinearMotionSemantic in NcSemanticList flips the runner to feedrate-derived timing with no other change. public static class GeneralCsvRunner Inheritance object GeneralCsvRunner Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods Create() Builds a fresh SoftNcRunner pre-configured to replay CSV input through the general-semantics pipeline. Call once per machining session so the runner's per-session state starts clean. public static SoftNcRunner Create() Returns SoftNcRunner Reg(XFactory) Registers the CSV-module components Create() instantiates — the shared decoder (CsvRunnerConfig, CsvSegmenter, CsvRowSyntax), the RowTo* syntax chain, and the CSV extension semantics — with the given XFactory. The general components it reuses (BundleSyntax, SpindleSpeedSemantic, CoolantSemantic, CsScriptBeginSemantic, CsScriptEndSemantic) are registered by Reg(XFactory). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.CsvParsers.RowToCoolantSyntax.html": {
    "href": "api/Hi.Numerical.CsvParsers.RowToCoolantSyntax.html",
    "title": "Class RowToCoolantSyntax | HiAPI-C# 2025",
    "summary": "Class RowToCoolantSyntax Namespace Hi.Numerical.CsvParsers Assembly HiMech.dll Translates the coolant column of a decoded CsvRow into the standardized ICoolantDef section consumed by the general CoolantSemantic. The cell may hold a mode name (Flood / Mist / Off) or a boolean / 0-1 on-off flag; an unrecognized value is a no-op. public class RowToCoolantSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object RowToCoolantSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Mode name — consumed from CsvRow, custom survives: #BeforeBuild: { \"CsvRow\": { \"Coolant\": \"Flood\", \"custom\": 1 } } #AfterBuild: { \"CsvRow\": { \"custom\": 1 }, \"Coolant\": { \"IsOn\": true, \"Mode\": \"Flood\" } } Boolean off-flag maps to Off: #BeforeBuild: { \"CsvRow\": { \"Coolant\": \"false\", \"custom\": 1 } } #AfterBuild: { \"CsvRow\": { \"custom\": 1 }, \"Coolant\": { \"IsOn\": false, \"Mode\": \"Off\" } } Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.CsvParsers.RowToCsScriptSyntax.html": {
    "href": "api/Hi.Numerical.CsvParsers.RowToCsScriptSyntax.html",
    "title": "Class RowToCsScriptSyntax | HiAPI-C# 2025",
    "summary": "Class RowToCsScriptSyntax Namespace Hi.Numerical.CsvParsers Assembly HiMech.dll Translates the begin/end C# script columns of a decoded CsvRow (LineBeginCsScriptTag / LineEndCsScriptTag) into the standardized CsScript section consumed by the general CsScriptBeginSemantic / CsScriptEndSemantic. Empty cells are skipped; an all-empty row is a no-op. public class RowToCsScriptSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object RowToCsScriptSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Begin script only — consumed from CsvRow, custom survives: #BeforeBuild: { \"CsvRow\": { \"LineBeginCsScript\": \"Probe();\", \"custom\": 1 } } #AfterBuild: { \"CsvRow\": { \"custom\": 1 }, \"CsScript\": { \"BeginScript\": \"Probe();\" } } No script columns — no-op: #BeforeBuild: { \"CsvRow\": { \"custom\": 1 } } #AfterBuild: { \"CsvRow\": { \"custom\": 1 } } Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.CsvParsers.RowToFeedrateSyntax.html": {
    "href": "api/Hi.Numerical.CsvParsers.RowToFeedrateSyntax.html",
    "title": "Class RowToFeedrateSyntax | HiAPI-C# 2025",
    "summary": "Class RowToFeedrateSyntax Namespace Hi.Numerical.CsvParsers Assembly HiMech.dll Translates the feedrate column of a decoded CsvRow into the standardized IFeedrateDef section. CSV feedrate is recorded in mm/min, so the section is stamped with the G94 (mm/min) term and its derived unit — the same shape ReadFeedrate_mmds(JsonObject, ISentenceCarrier, NcDiagnosticProgress) expects. public class RowToFeedrateSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object RowToFeedrateSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples #BeforeBuild: { \"CsvRow\": { \"Feedrate_mmdmin\": 20000, \"custom\": 1 } } #AfterBuild: { \"CsvRow\": { \"custom\": 1 }, \"Feedrate\": { \"FeedrateValue\": 20000, \"Term\": \"G94\", \"Unit\": \"mm/min\" } } No feedrate column — no-op: #BeforeBuild: { \"CsvRow\": { \"custom\": 1 } } #AfterBuild: { \"CsvRow\": { \"custom\": 1 } } Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.CsvParsers.RowToMachineCoordinateSyntax.html": {
    "href": "api/Hi.Numerical.CsvParsers.RowToMachineCoordinateSyntax.html",
    "title": "Class RowToMachineCoordinateSyntax | HiAPI-C# 2025",
    "summary": "Class RowToMachineCoordinateSyntax Namespace Hi.Numerical.CsvParsers Assembly HiMech.dll Translates the machine-coordinate columns of a decoded CsvRow (prefixed by MachineCoordinatePrefix, e.g. MC.X … MC.C) into the standardized MachineCoordinateState section. Linear axes (X/Y/Z) are millimetres; rotary axes (A/B/C) are raw degrees, matching the convention McAbcSyntax writes and ReadMcXyzabc(JsonObject) reads (degrees → radians). Only axes actually present in the row are written; an all-absent row is a no-op. Must run before RowToMotionEventSyntax. public class RowToMachineCoordinateSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object RowToMachineCoordinateSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples XY + rotary B/C present, Z/A absent — only present axes written, in X,Y,Z,A,B,C order; all MC.* columns consumed from CsvRow, custom survives: #BeforeBuild: { \"CsvRow\": { \"MC.X\": 35, \"MC.Y\": -11.7, \"MC.B\": 0, \"MC.C\": 0, \"custom\": 1 } } #AfterBuild: { \"CsvRow\": { \"custom\": 1 }, \"MachineCoordinateState\": { \"X\": 35, \"Y\": -11.7, \"B\": 0, \"C\": 0 } } No coordinate columns — no-op: #BeforeBuild: { \"CsvRow\": { \"custom\": 1 } } #AfterBuild: { \"CsvRow\": { \"custom\": 1 } } Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.CsvParsers.RowToMotionEventSyntax.html": {
    "href": "api/Hi.Numerical.CsvParsers.RowToMotionEventSyntax.html",
    "title": "Class RowToMotionEventSyntax | HiAPI-C# 2025",
    "summary": "Class RowToMotionEventSyntax Namespace Hi.Numerical.CsvParsers Assembly HiMech.dll Marks every CSV row that carries a MachineCoordinateState section as a McLinear feed move by writing the standardized IMotionEventDef (+ modal IMotionStateDef) sections. This keeps the motion-section contract identical to the one the general McLinearMotionSemantic reads, so the CSV pipeline's CsvMotionSemantic (recorded-duration) can be swapped for the general feedrate-derived semantic by changing only the semantic list. CSV telemetry has no rapid concept, so IsRapid is never set (feed move). Must run after RowToMachineCoordinateSyntax. public class RowToMotionEventSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object RowToMotionEventSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples MachineCoordinateState present — both motion sections written as a G01 feed move: #BeforeBuild: { \"CsvRow\": { \"MC.X\": 10 }, \"MachineCoordinateState\": { \"X\": 10, \"Y\": 20, \"Z\": 30 } } #AfterBuild: { \"CsvRow\": { \"MC.X\": 10 }, \"MachineCoordinateState\": { \"X\": 10, \"Y\": 20, \"Z\": 30 }, \"MotionState\": { \"Term\": \"G01\" }, \"MotionEvent\": { \"Form\": \"McLinear\" } } No MachineCoordinateState — no-op: #BeforeBuild: { \"CsvRow\": { \"custom\": 1 } } #AfterBuild: { \"CsvRow\": { \"custom\": 1 } } Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.CsvParsers.RowToSpindleSyntax.html": {
    "href": "api/Hi.Numerical.CsvParsers.RowToSpindleSyntax.html",
    "title": "Class RowToSpindleSyntax | HiAPI-C# 2025",
    "summary": "Class RowToSpindleSyntax Namespace Hi.Numerical.CsvParsers Assembly HiMech.dll Translates the spindle columns of a decoded CsvRow into the standardized ISpindleSpeedDef section that the general SpindleSpeedSemantic consumes. Reads SpindleSpeedTag_rpm (numeric) and SpindleDirectionTag (enum name); when only the speed is present the direction defaults to CW (matching the legacy CSV behavior). public class RowToSpindleSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object RowToSpindleSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Speed + explicit direction — both mapped into the section and consumed from CsvRow; the unrelated custom column survives: #BeforeBuild: { \"CsvRow\": { \"SpindleSpeed_rpm\": 2000, \"Spd.Dir.\": \"CCW\", \"custom\": 1 } } #AfterBuild: { \"CsvRow\": { \"custom\": 1 }, \"SpindleSpeed\": { \"SpindleSpeed_rpm\": 2000, \"Direction\": \"CCW\" } } Speed only — direction defaults to CW: #BeforeBuild: { \"CsvRow\": { \"SpindleSpeed_rpm\": 1500, \"custom\": 1 } } #AfterBuild: { \"CsvRow\": { \"custom\": 1 }, \"SpindleSpeed\": { \"SpindleSpeed_rpm\": 1500, \"Direction\": \"CW\" } } Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.CsvParsers.RowToTimingSyntax.html": {
    "href": "api/Hi.Numerical.CsvParsers.RowToTimingSyntax.html",
    "title": "Class RowToTimingSyntax | HiAPI-C# 2025",
    "summary": "Class RowToTimingSyntax Namespace Hi.Numerical.CsvParsers Assembly HiMech.dll Moves the recorded-timing columns of a decoded CsvRow (DurationTag / ActualTimeTag) into a dedicated CsvTiming section, consuming them from CsvRow. The cells stay as raw strings (the source format may be a TimeSpan or DateTime literal); parsing happens later in Hi.Numerical.CsvParsers.CsvTimingUtil. Having a syntax own the timing tags — like the other RowTo* syntaxes own their columns — is what lets CsvActDataSemantic treat whatever remains in CsvRow as residual telemetry without a hard-coded consumed-key list. public class RowToTimingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object RowToTimingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples Duration + actual-time present — both moved into CsvTiming and removed from CsvRow; the unrelated custom column survives: #BeforeBuild: { \"CsvRow\": { \"StepDuration\": \"00:00:01\", \"ActualTime\": \"08:00:01\", \"custom\": 1 } } #AfterBuild: { \"CsvRow\": { \"custom\": 1 }, \"CsvTiming\": { \"Duration\": \"00:00:01\", \"ActualTime\": \"08:00:01\" } } No timing columns — no-op: #BeforeBuild: { \"CsvRow\": { \"custom\": 1 } } #AfterBuild: { \"CsvRow\": { \"custom\": 1 } } Fields ActualTimeKey Section key holding the absolute actual-time literal. public const string ActualTimeKey = \"ActualTime\" Field Value string DurationKey Section key holding the recorded per-step duration literal. public const string DurationKey = \"Duration\" Field Value string SectionName JSON section name where the recorded timing is written. public const string SectionName = \"CsvTiming\" Field Value string Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.CsvParsers.RowToToolingSyntax.html": {
    "href": "api/Hi.Numerical.CsvParsers.RowToToolingSyntax.html",
    "title": "Class RowToToolingSyntax | HiAPI-C# 2025",
    "summary": "Class RowToToolingSyntax Namespace Hi.Numerical.CsvParsers Assembly HiMech.dll Translates the tool-id column of a decoded CsvRow into the standardized ToolChange section (SectionName). The active tool number is always written; IsChangeKey is set when the tool id differs from the previous row (including the first occurrence), so the section both drives ToolingTeleportSemantic (teleport-on-change) and stays compatible with the general ToolChangeSemantic. public class RowToToolingSyntax : ISituNcSyntax, INcSyntax, IMakeXmlSource Inheritance object RowToToolingSyntax Implements ISituNcSyntax INcSyntax IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Examples First row (no predecessor) — tool armed, IsChange true; ToolId consumed from CsvRow, custom survives: #BeforeBuild: { \"CsvRow\": { \"ToolId\": 1, \"custom\": 1 } } #AfterBuild: { \"CsvRow\": { \"custom\": 1 }, \"ToolChange\": { \"ToolId\": 1, \"IsChange\": true } } Same tool as previous row — IsChange false: #Previous: { \"ToolChange\": { \"ToolId\": 1, \"IsChange\": true } } #BeforeBuild: { \"CsvRow\": { \"ToolId\": 1, \"custom\": 1 } } #AfterBuild: { \"CsvRow\": { \"custom\": 1 }, \"ToolChange\": { \"ToolId\": 1, \"IsChange\": false } } Tool id changed vs previous row — IsChange true: #Previous: { \"ToolChange\": { \"ToolId\": 1, \"IsChange\": false } } #BeforeBuild: { \"CsvRow\": { \"ToolId\": 2, \"custom\": 1 } } #AfterBuild: { \"CsvRow\": { \"custom\": 1 }, \"ToolChange\": { \"ToolId\": 2, \"IsChange\": true } } Properties Name Syntax kind name (typically the concrete type name). public string Name { get; } Property Value string XName XML element name used to register this syntax with XFactory. public static string XName { get; } Property Value string Methods Build(LazyLinkedListNode<SyntaxPiece>, List<INcDependency>, NcDiagnosticProgress) Build syntax arrangement into the syntaxPieceNode in-place. public void Build(LazyLinkedListNode<SyntaxPiece> syntaxPieceNode, List<INcDependency> ncDependencyList, NcDiagnosticProgress ncDiagnosticProgress) Parameters syntaxPieceNode LazyLinkedListNode<SyntaxPiece> ncDependencyList List<INcDependency> ncDiagnosticProgress NcDiagnosticProgress MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.CsvParsers.html": {
    "href": "api/Hi.Numerical.CsvParsers.html",
    "title": "Namespace Hi.Numerical.CsvParsers | HiAPI-C# 2025",
    "summary": "Namespace Hi.Numerical.CsvParsers Classes CsvActDataSemantic CSV extension semantic: emits ActData from the residual CsvRow columns — those not claimed by any RowTo*Syntax (tool id, spindle, feedrate, coolant, time, csscript) nor by the machine / cutter coordinate prefixes. A caller-supplied ParsingDictionary entry is applied to its column's raw text; the rest pass through as their pre-typed number / bool / string. Carries arbitrary recorded channels (file/line bookkeeping, sensor columns, etc.) onto the step. CsvActualTimeSemantic CSV extension semantic: emits ActActualTimecode from the ActualTimeTag cell of the decoded CsvRow. This is telemetry the general semantic list does not cover — the absolute controller timestamp of the recorded sample. Stateless; the duration that consumes this timestamp is computed independently by CsvMotionSemantic via Hi.Numerical.CsvParsers.CsvTimingUtil. CsvMotionSemantic CSV motion semantic — the recorded-duration counterpart of the general McLinearMotionSemantic. Reads the same standardized sections (IMotionEventDef, MachineCoordinateState, IFeedrateDef) the general motion semantic reads, but derives the move's duration from the recorded CSV timing (ResolveDuration(LazyLinkedListNode<SyntaxPiece>)) instead of feedrate × distance — because CSV is replayed telemetry where time is given, not computed. First coordinate row (no previous MC) → ActMcXyzabcStep to the point; subsequent rows → ActMcXyzabcLinearContour from the previous point. The recorded feedrate is emitted as a standalone ActFeedrate on change. Because the upstream RowToMotionEventSyntax writes the full general motion-section contract, this semantic can be replaced one-for-one with McLinearMotionSemantic to fall back to feedrate-derived timing. CsvRowSyntax Per-row CSV parsing syntax for the soft NC runner. Reads the active TitleList via SegmenterDependency, splits the row text using GetCsvDictionary(IList<string>, string), and stamps the resulting column→value map into JsonObject under the CsvRowKey property for the downstream CSV syntaxes and semantics to consume. Numeric cells are pre-typed to double (or bool) at this stage so downstream readers — including the CSV semantics' backwards walk for the previous machine coordinate — touch native JSON numbers instead of re-parsing strings on every visit. Columns kept as strings: the script / time / spindle-direction tags whose semantic interpretation is non-numeric, plus any column whose key appears in ParsingDictionary (the caller-supplied parsing function expects the raw cell text). CsvRunnerConfig Configuration class for CSV Runner. Lives in PipelineNcDependencyList when wired with GeneralCsvRunner; consumed by CsvRowSyntax and the CSV row syntaxes/semantics for tag-name lookup and custom-field parsing. CsvSegmenter Segments a CSV stream for the SoftNcRunner pipeline. Consumes the first IndexedFileLine as the title row (populating TitleList and registering any new columns as step variables via StepPropertyAccessDictionaryDependency), then yields each subsequent line as a one-line Sentence for CsvRowSyntax to parse. GeneralCsvRunner Factory for a SoftNcRunner that replays CSV telemetry through the general-semantics architecture: a chain of small RowTo*Syntax classes maps each decoded CsvRow into the same standardized JSON sections the brand-NC pipeline writes (SpindleSpeed, Feedrate, Coolant, CsScript, ToolChange, MachineCoordinateState, MotionEvent), and a mostly-general semantic list resolves them into acts. A handful of CSV extension semantics cover telemetry the general list does not (CsvActualTimeSemantic, CsvMotionSemantic, CsvActDataSemantic); tool changes ride the general ToolingTeleportSemantic (the tool jumps to its recorded position — no modelled tool-changer cycle). This is the flagship CSV runner — it superseded an earlier single-syntax / single-semantic pipeline. Recorded vs. computed timing. CSV is replayed telemetry, so CsvMotionSemantic uses the recorded sample duration (StepDuration / ActualTime delta) rather than feedrate × distance. Because RowToMotionEventSyntax still writes the full general motion-section contract, swapping CsvMotionSemantic for the general McLinearMotionSemantic in NcSemanticList flips the runner to feedrate-derived timing with no other change. RowToCoolantSyntax Translates the coolant column of a decoded CsvRow into the standardized ICoolantDef section consumed by the general CoolantSemantic. The cell may hold a mode name (Flood / Mist / Off) or a boolean / 0-1 on-off flag; an unrecognized value is a no-op. RowToCsScriptSyntax Translates the begin/end C# script columns of a decoded CsvRow (LineBeginCsScriptTag / LineEndCsScriptTag) into the standardized CsScript section consumed by the general CsScriptBeginSemantic / CsScriptEndSemantic. Empty cells are skipped; an all-empty row is a no-op. RowToFeedrateSyntax Translates the feedrate column of a decoded CsvRow into the standardized IFeedrateDef section. CSV feedrate is recorded in mm/min, so the section is stamped with the G94 (mm/min) term and its derived unit — the same shape ReadFeedrate_mmds(JsonObject, ISentenceCarrier, NcDiagnosticProgress) expects. RowToMachineCoordinateSyntax Translates the machine-coordinate columns of a decoded CsvRow (prefixed by MachineCoordinatePrefix, e.g. MC.X … MC.C) into the standardized MachineCoordinateState section. Linear axes (X/Y/Z) are millimetres; rotary axes (A/B/C) are raw degrees, matching the convention McAbcSyntax writes and ReadMcXyzabc(JsonObject) reads (degrees → radians). Only axes actually present in the row are written; an all-absent row is a no-op. Must run before RowToMotionEventSyntax. RowToMotionEventSyntax Marks every CSV row that carries a MachineCoordinateState section as a McLinear feed move by writing the standardized IMotionEventDef (+ modal IMotionStateDef) sections. This keeps the motion-section contract identical to the one the general McLinearMotionSemantic reads, so the CSV pipeline's CsvMotionSemantic (recorded-duration) can be swapped for the general feedrate-derived semantic by changing only the semantic list. CSV telemetry has no rapid concept, so IsRapid is never set (feed move). Must run after RowToMachineCoordinateSyntax. RowToSpindleSyntax Translates the spindle columns of a decoded CsvRow into the standardized ISpindleSpeedDef section that the general SpindleSpeedSemantic consumes. Reads SpindleSpeedTag_rpm (numeric) and SpindleDirectionTag (enum name); when only the speed is present the direction defaults to CW (matching the legacy CSV behavior). RowToTimingSyntax Moves the recorded-timing columns of a decoded CsvRow (DurationTag / ActualTimeTag) into a dedicated CsvTiming section, consuming them from CsvRow. The cells stay as raw strings (the source format may be a TimeSpan or DateTime literal); parsing happens later in Hi.Numerical.CsvParsers.CsvTimingUtil. Having a syntax own the timing tags — like the other RowTo* syntaxes own their columns — is what lets CsvActDataSemantic treat whatever remains in CsvRow as residual telemetry without a hard-coded consumed-key list. RowToToolingSyntax Translates the tool-id column of a decoded CsvRow into the standardized ToolChange section (SectionName). The active tool number is always written; IsChangeKey is set when the tool id differs from the previous row (including the first occurrence), so the section both drives ToolingTeleportSemantic (teleport-on-change) and stays compatible with the general ToolChangeSemantic."
  },
  "api/Hi.Numerical.FilePlayers.HardNcRunner.html": {
    "href": "api/Hi.Numerical.FilePlayers.HardNcRunner.html",
    "title": "Class HardNcRunner | HiAPI-C# 2025",
    "summary": "Class HardNcRunner Namespace Hi.Numerical.FilePlayers Assembly HiNc.dll Provides functionality for running and processing NC code lines. public class HardNcRunner : INcRunner Inheritance object HardNcRunner Implements INcRunner Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties NcLines Gets the linked list of NC lines. public LinkedList<HardNcLine> NcLines { get; } Property Value LinkedList<HardNcLine> Methods RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) Runs raw NC lines and yields NcLine and Act pairs. public IEnumerable<SourcedActEntry> RunNcLines(string relNcFilePath, IEnumerable<string> lines, MachiningSession machiningSession, StepDiagnosticProgress stepDiagnosticProgress, NcDiagnosticProgress ncDiagnosticProgress, CancellationToken cancellationToken) Parameters relNcFilePath string The relative path of the NC file lines IEnumerable<string> The enumerable collection of NC code lines machiningSession MachiningSession The machining session that owns runtime state for this run. stepDiagnosticProgress StepDiagnosticProgress Progress sink for cutter-location strip updates emitted during the run. ncDiagnosticProgress NcDiagnosticProgress NC-pipeline sink; receives the parse progress / diagnostics of this legacy runner. cancellationToken CancellationToken Cancellation token to cancel the operation Returns IEnumerable<SourcedActEntry> Enumerable of NcLine and Act pairs"
  },
  "api/Hi.Numerical.FilePlayers.html": {
    "href": "api/Hi.Numerical.FilePlayers.html",
    "title": "Namespace Hi.Numerical.FilePlayers | HiAPI-C# 2025",
    "summary": "Namespace Hi.Numerical.FilePlayers Classes HardNcRunner Provides functionality for running and processing NC code lines."
  },
  "api/Hi.Numerical.FlexDictionaryUtil.html": {
    "href": "api/Hi.Numerical.FlexDictionaryUtil.html",
    "title": "Class FlexDictionaryUtil | HiAPI-C# 2025",
    "summary": "Class FlexDictionaryUtil Namespace Hi.Numerical Assembly HiMech.dll Utility for flexible dictionary operations. public static class FlexDictionaryUtil Inheritance object FlexDictionaryUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods CallFlexDictionary<T>(IFlexDictionaryHost<T>) Calls the flex dictionary of the source, initializing it if null. public static Dictionary<string, T> CallFlexDictionary<T>(this IFlexDictionaryHost<T> src) Parameters src IFlexDictionaryHost<T> The flex dictionary host Returns Dictionary<string, T> The dictionary from the host Type Parameters T The type of values in the dictionary GetFlexDictionaryBytes<T>(IFlexDictionaryHost<T>, IntegerKeyDictionaryConverter<T>) Gets the flex dictionary as a byte array. public static byte[] GetFlexDictionaryBytes<T>(this IFlexDictionaryHost<T> src, IntegerKeyDictionaryConverter<T> converter) Parameters src IFlexDictionaryHost<T> The flex dictionary host converter IntegerKeyDictionaryConverter<T> The converter for integer keys Returns byte[] Byte array representation of the dictionary Type Parameters T The type of values in the dictionary ReadFlexDictionary(BinaryReader, IntegerKeyDictionaryConverter<double>) Reads a flex dictionary from a binary reader. public static Dictionary<string, double> ReadFlexDictionary(BinaryReader reader, IntegerKeyDictionaryConverter<double> converter) Parameters reader BinaryReader The binary reader to read from converter IntegerKeyDictionaryConverter<double> The converter for integer keys Returns Dictionary<string, double> The restored dictionary WriteFlexDictionary<T>(IFlexDictionaryHost<T>, BinaryWriter, IntegerKeyDictionaryConverter<T>) Writes a flex dictionary to a binary writer. public static void WriteFlexDictionary<T>(this IFlexDictionaryHost<T> src, BinaryWriter writer, IntegerKeyDictionaryConverter<T> converter) Parameters src IFlexDictionaryHost<T> The flex dictionary host writer BinaryWriter The binary writer to write to converter IntegerKeyDictionaryConverter<T> The converter for integer keys Type Parameters T The type of values in the dictionary"
  },
  "api/Hi.Numerical.HardNcComment.html": {
    "href": "api/Hi.Numerical.HardNcComment.html",
    "title": "Class HardNcComment | HiAPI-C# 2025",
    "summary": "Class HardNcComment Namespace Hi.Numerical Assembly HiUniNc.dll Represents a comment in NC code. public class HardNcComment Inheritance object HardNcComment Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HardNcComment(string, CommentMark) Initializes a new instance of the HardNcComment class. public HardNcComment(string content, CommentMark commentSignEnum) Parameters content string The content of the comment without comment marks. commentSignEnum CommentMark The type of comment mark to use. Properties CommentMark Gets or sets the type of comment mark used. public CommentMark CommentMark { get; set; } Property Value CommentMark Content Comment Without Comment Mark. public string Content { get; set; } Property Value string FullText Comment With Comment Mark. public string FullText { get; } Property Value string Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.HardNcEnv.html": {
    "href": "api/Hi.Numerical.HardNcEnv.html",
    "title": "Class HardNcEnv | HiAPI-C# 2025",
    "summary": "Class HardNcEnv Namespace Hi.Numerical Assembly HiUniNc.dll Represents the numerical control environment containing configuration for CNC operations. public class HardNcEnv : IMakeXmlSource Inheritance object HardNcEnv Implements IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HardNcEnv(CncBrand) Ctor. public HardNcEnv(CncBrand cncBrand = CncBrand.Fanuc) Parameters cncBrand CncBrand HardNcEnv(XElement, string, string, IProgress<IMessage>) Ctor. public HardNcEnv(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress) Parameters src XElement XML baseDirectory string The base directory for relative paths. relFile string The relative file path. progress IProgress<IMessage> Optional progress reporter for nested XML factory calls. Properties AttacherAtMcZeroOnTableCoordinate Gets the attacher position at machine zero on table coordinate. public Vec3d AttacherAtMcZeroOnTableCoordinate { get; } Property Value Vec3d CncBrand Gets or sets the CNC brand/controller type. public CncBrand CncBrand { get; set; } Property Value CncBrand CommentSymbol Gets the comment symbol used by the current CNC controller. public string CommentSymbol { get; } Property Value string ConfigurationTable Gets a dictionary of CNC configuration parameters used by the system. public Dictionary<string, int> ConfigurationTable { get; } Property Value Dictionary<string, int> EnableArcCornerRadiusCompensation Gets or sets whether arc corner radius compensation is enabled. public bool EnableArcCornerRadiusCompensation { get; set; } Property Value bool EnableIntegerShrinkOnPositionCommand Gets or sets whether integer shrinking is enabled for position commands. e.g., “X1.” is interpreted as X=1.0 when enabled. public bool EnableIntegerShrinkOnPositionCommand { get; set; } Property Value bool EnableShortestRotary Enables shortest rotary path movement. This option does not affect Heidenhain controllers. For Heidenhain controllers, see Hi.UniNc.Heidenhain.IHeidenhainShortestRotaryPathEnabled, Hi.UniNc.Heidenhain.HeidenhainM126 and Hi.UniNc.Heidenhain.HeidenhainM127. public bool EnableShortestRotary { get; set; } Property Value bool FanucPara5003 Fanuc 5003. These bits are used to specify the type of startup/cancellation of tool radius - tool nose radius compensation. 0: type A; 1: type B; 2,3: type C. Assume always zero. Type A: A compensation vector perpendicular to the block next to the startup block or the block preceding the cancellation block is output. Type B: A compensation vector perpendicular to the startup block or cancellation block and an intersection vector are output. Type C: When the startup block or cancellation block specifies no movement operation, the tool is shifted by the cutter compensation amount in a direction perpendicular to the block next to the startup or the block before cancellation block. public byte FanucPara5003 { get; set; } Property Value byte HeidenhainDatumPresetTable For Heidenhain CYCL DEF 247 Datum Preset. public Dictionary<int, Vec3d> HeidenhainDatumPresetTable { get; } Property Value Dictionary<int, Vec3d> Remarks Datum Preset seems an older settings in heidenhain manual relative to Datum Shift. HeidenhainDatumShiftTable For Heidenhain CYCL DEF 7 Datum Shift. Also called Datum table in heidenhain manual. public Dictionary<int, Vec3d> HeidenhainDatumShiftTable { get; } Property Value Dictionary<int, Vec3d> Remarks Datum Preset seems an older settings in heidenhain manual relative to Datum Shift. HeidenhainMasterAxisChar Gets or sets the Heidenhain master rotary axis as a character (A, B, or C). public char HeidenhainMasterAxisChar { get; set; } Property Value char HeidenhainMasterAxisDir The master axis determines the behaviour of SEQ command. ex. PLANE SPATIAL SPA-77.516 SPB+0 SPC-10.365 STAY SEQ-TABLE ROT The master axis is the 1st rotary axis from the tool, or the last rotary axis from the table(depending on the machine configuration). SEQ+ positions the master axis so that it assumes a positive angle. See: TNC 640 | User's ManualDIN/ISO Programming | 1/2015 p432 public int HeidenhainMasterAxisDir { get; set; } Property Value int HomeMc Home machine coordinate. First reference position. The position may not equal to machine zero in real Fanuc controller. public Vec3d HomeMc { get; set; } Property Value Vec3d IsAxisAExisted Gets whether the A axis exists in the machine configuration. public bool IsAxisAExisted { get; } Property Value bool IsAxisBExisted Gets whether the B axis exists in the machine configuration. public bool IsAxisBExisted { get; } Property Value bool IsAxisCExisted Gets whether the C axis exists in the machine configuration. public bool IsAxisCExisted { get; } Property Value bool IsoCoordinateTable ISO coordinate table. i.e., CoordinateTable For G54 series. public IsoCoordinateTable IsoCoordinateTable { get; set; } Property Value IsoCoordinateTable MaxRotarySpeedABC_degds For safety reason, internal use only. Maximum rotary speed in degds. public Vec3d MaxRotarySpeedABC_degds { get; set; } Property Value Vec3d MaxRotarySpeedABC_radds Maximum rotary speed in rad/s. public Vec3d MaxRotarySpeedABC_radds { get; set; } Property Value Vec3d MaxSpindleSpeed_rpm Gets or sets the maximum spindle speed in revolutions per minute. public double MaxSpindleSpeed_rpm { get; set; } Property Value double MillingToolOffsetTable Gets or sets the milling tool offset table for tool compensation. public MillingToolOffsetTable MillingToolOffsetTable { get; set; } Property Value MillingToolOffsetTable RapidFeedrate_mmdmin Rapid move speed in mm/min. public double RapidFeedrate_mmdmin { get; set; } Property Value double RapidFeedrate_mmds Rapid move speed in mm/s. public double RapidFeedrate_mmds { get; set; } Property Value double RefNcLineOnInit Gets or sets the reference NC line used during initialization. public HardNcLine RefNcLineOnInit { get; set; } Property Value HardNcLine StrokeLimitAbc_rad Gets or sets the ABC axis stroke limits in radians. public Box3d StrokeLimitAbc_rad { get; set; } Property Value Box3d StrokeLimitXyz_mm Gets or sets the XYZ axis stroke limits in millimeters. public Box3d StrokeLimitXyz_mm { get; set; } Property Value Box3d ToolingMcAbc_deg Gets or sets the rotary machine coordinate for tooling operations. Defaults to HomeMc if not explicitly set. Set to NaN if tooling motion not apply the axis motion. Unit is degree. public Vec3d ToolingMcAbc_deg { get; set; } Property Value Vec3d ToolingMcAbc_rad Gets or sets the rotary machine coordinate for tooling operations. Set to NaN if tooling motion not apply the axis motion. When not explicitly set, defaults to all-NaN — rotary axes stay during a tool change, matching ToolingMcConfig.Default3Axis. (The old default, (0,0,0), swung every rotary axis home on each M06.) Unit is radian. public Vec3d ToolingMcAbc_rad { get; set; } Property Value Vec3d ToolingMcXyz Gets or sets the translation machine coordinate for tooling operations. Set to NaN if tooling motion not apply the axis motion. When not explicitly set, defaults to (NaN, NaN, 0) — Z retracts to machine zero, X/Y stay — the same shape as the SoftNc pipeline's ToolingMcConfig.Default3Axis, keeping the two runners' M06 paths aligned. (The old default, HomeMc, moved all three axes.) public Vec3d ToolingMcXyz { get; set; } Property Value Vec3d ToolingTime Tool changing duration in sec. public TimeSpan ToolingTime { get; set; } Property Value TimeSpan XName Name for XML IO. public static string XName { get; } Property Value string XyzabcSolver Gets or sets the coordinate converter used for transformations between different coordinate systems. public XyzabcSolver XyzabcSolver { get; set; } Property Value XyzabcSolver Methods CheckStrokeLimit(DVec3d, IProgress<IMessage>) Check stroke limit. public bool CheckStrokeLimit(DVec3d mcXyzabc_mm_rad, IProgress<IMessage> mixedProgress) Parameters mcXyzabc_mm_rad DVec3d Machine coordinates in mm and radians. mixedProgress IProgress<IMessage> Message kit for error reporting. Returns bool Is under stroke limit. IsAxisExisted(int) Determines whether a specific rotary axis exists in the machine configuration. public bool IsAxisExisted(int dir) Parameters dir int The direction index (0=A, 1=B, 2=C). Returns bool True if the specified axis exists; otherwise, false. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.HardNcLine.html": {
    "href": "api/Hi.Numerical.HardNcLine.html",
    "title": "Class HardNcLine | HiAPI-C# 2025",
    "summary": "Class HardNcLine Namespace Hi.Numerical Assembly HiUniNc.dll Represents a line in the NC program with its associated data and operations. public class HardNcLine : IIndexedFileLine, IFileLine, IFileLineIndex, IGetIndexedFileLine, IGetFileLineIndex, IFlagText, ISentenceCarrier, IGetSentence, ISentenceIndexed Inheritance object HardNcLine Implements IIndexedFileLine IFileLine IFileLineIndex IGetIndexedFileLine IGetFileLineIndex IFlagText ISentenceCarrier IGetSentence ISentenceIndexed Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) HardNcUtil.IsFlagChanging(HardNcLine, HardNcLine, NcFlag) HardNcUtil.IsFlagChanging(HardNcLine, HardNcLine, NcFlag, bool) HardNcUtil.IsFlagKeeping(HardNcLine, HardNcLine, NcFlag, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HardNcLine(HardNcEnv, IndexedFileLine, HardNcLine, int, out NcNoteCache, IProgress<IMessage>) Ctor from the reference HardNcLine. public HardNcLine(HardNcEnv ncEnv, IndexedFileLine fileLine, HardNcLine preNcLine, int sentenceIndex, out NcNoteCache ncNoteCache, IProgress<IMessage> mixedProgress) Parameters ncEnv HardNcEnv NC environment fileLine IndexedFileLine file line preNcLine HardNcLine reference HardNcLine that this HardNcLine copy from. If previous HardNcLine is not null, apply previous HardNcLine. sentenceIndex int 0-based ordinal in NC execution order; stamped at construction and exposed via SentenceIndex. ncNoteCache NcNoteCache Output NC note cache mixedProgress IProgress<IMessage> Message host for warnings HardNcLine(HardNcEnv, IProgress<IMessage>) Ctor for initial state. The instance is the pre-pipeline seed (RefNcLineOnInit), so SentenceIndex is set to -1 as a “not in pipeline” sentinel. public HardNcLine(HardNcEnv ncEnv, IProgress<IMessage> mixedProgress) Parameters ncEnv HardNcEnv mixedProgress IProgress<IMessage> Properties ArcNcArg NC arguments for arc commands. public ArcNcArg ArcNcArg { get; set; } Property Value ArcNcArg CoordinateInterpolationMode Gets the current coordinate interpolation mode (Cartesian or Polar). public CoordinateInterpolationMode CoordinateInterpolationMode { get; } Property Value CoordinateInterpolationMode F F. Feedrate on NC code. Note that this may not be the working feedrate. Some NC codes like G00 and G28 doesnt use F code. public double F { get; set; } Property Value double Remarks According to Fanuc manual, the default F is zero. Feedrate_mmdmin Feedrate on NC code in current mode in mm/min. See F. public double Feedrate_mmdmin { get; set; } Property Value double Feedrate_mmds Feedrate on NC code in current mode in mm/sec. public double Feedrate_mmds { get; set; } Property Value double FileIndex File Index. Start on 0. public int FileIndex { get; } Property Value int FileNo Gets the file number. [Present(\"File Number\", \"FileNo\", PhysicsUnit.None, \"G\")] public int FileNo { get; } Property Value int FilePath File path. [Present(\"File\", \"File\", PhysicsUnit.None, \"G\")] public string FilePath { get; } Property Value string FlagsText Gets a string representation of the active NC flags for this line. public string FlagsText { get; } Property Value string G28Arg Arguments for G28 commands. public G28Arg G28Arg { get; set; } Property Value G28Arg G52_Xyz Local coordinate system translation. public Vec3d G52_Xyz { get; set; } Property Value Vec3d G54SeriesCoordinateNum1000 Faunc Group14 value. Note that Heidenhain Datum shift is set by DatumTableId. public int G54SeriesCoordinateNum1000 { get; set; } Property Value int Group07NcArg Arguments for Group07 NC commands (tool radius compensation). public Group07NcArg Group07NcArg { get; set; } Property Value Group07NcArg Group07_D Radius compensation ID. Note that in Siemens controller, each tool ID has several D entry. public int Group07_D { get; set; } Property Value int Group08_H Height compensation ID. For Siemens Traori, the value is Tool ID. For Heidenhain, the value is Tool ID. public int Group08_H { get; set; } Property Value int Group09NcArg NC Argument of NC Group09. public Group09NcArg Group09NcArg { get; set; } Property Value Group09NcArg HeidenhainBlockCacheArg Heidenhain block cache arguments for various Heidenhain commands. public IHeidenhainBlockCacheArg HeidenhainBlockCacheArg { get; set; } Property Value IHeidenhainBlockCacheArg HeidenhainCycleDef247Q339 DATUM SETTING DATUM Number. public int HeidenhainCycleDef247Q339 { get; set; } Property Value int HeidenhainCycleDef7Arg Arguments for Heidenhain Cycle Definition 7 (datum shift). public HeidenhainCycleDef7Arg HeidenhainCycleDef7Arg { get; set; } Property Value HeidenhainCycleDef7Arg HeidenhainM140MB HeidenhainM140(Retract the tool) MB value. MB is the retraction height. double.positiveInf is [MB MAX]. One shot command. public double HeidenhainM140MB { get; set; } Property Value double HeidenhainQMacroMap Dictionary mapping Q macro numbers to their string values for Heidenhain controllers. public Dictionary<int, string> HeidenhainQMacroMap { get; set; } Property Value Dictionary<int, string> HeidenhainToolAxisDir Direction of the tool axis for Heidenhain controllers. public int HeidenhainToolAxisDir { get; set; } Property Value int IndexedFileLine The file line information associated with this NC line. public IndexedFileLine IndexedFileLine { get; } Property Value IndexedFileLine IsAbsolutePositioning Gets a value indicating whether absolute positioning (G90) is active. public bool IsAbsolutePositioning { get; } Property Value bool IsHeightCompensationEnabled Gets a value indicating whether height compensation is enabled. public bool IsHeightCompensationEnabled { get; } Property Value bool IsOnArcCommand Gets a value indicating whether an arc command (G02 or G03) is active. public bool IsOnArcCommand { get; } Property Value bool IsPathPrepared Gets a value indicating whether the path is prepared (no radius compensation). public bool IsPathPrepared { get; } Property Value bool IsRadiusCompensationEnabled Gets a value indicating whether radius compensation is enabled. public bool IsRadiusCompensationEnabled { get; } Property Value bool IsToolCenterPointManagementEnabled Gets a value indicating whether tool center point management is enabled. public bool IsToolCenterPointManagementEnabled { get; } Property Value bool Line The line. [Present(\"Line\", \"Line\", PhysicsUnit.None, \"G\")] public string Line { get; } Property Value string LineIndex Line Index. Start on 0. public int LineIndex { get; } Property Value int LineNo Gets the line number. [Present(\"Line Number\", \"LineNo\", PhysicsUnit.None, \"G\")] public int LineNo { get; } Property Value int MachiningFeedrate_mmdmin Machining Feedrate on NC code in machining mode (such as G01,G02,G03 but not G00) in mm/min. public double MachiningFeedrate_mmdmin { get; set; } Property Value double MachiningFeedrate_mmds Machining Feedrate on NC code in machining mode (such as G01,G02,G03 but not G00) in mm/sec. public double MachiningFeedrate_mmds { get; set; } Property Value double McAbc_deg Gets or sets the machine ABC coordinates in degrees. public Vec3d McAbc_deg { get; set; } Property Value Vec3d McAbc_rad Machine coordinates in ABC format (radians). public Vec3d McAbc_rad { get; } Property Value Vec3d McXyz Gets or sets the machine coordinate XYZ values. public Vec3d McXyz { get; } Property Value Vec3d McXyzabc Machine coordinate ( with side radius compensation if existed). Point is XYZ. the unit is mm. Normal is ABC. the unit is radian. public DVec3d McXyzabc { get; } Property Value DVec3d NcFlagBitArray Internal Used. public BitArray NcFlagBitArray { get; } Property Value BitArray PausingNcArg public PausingNcArg PausingNcArg { get; set; } Property Value PausingNcArg Remarks Since this is base on OneShot Flag, so here has no copy ctor. PolarEntry Data structure for polar coordinates entry. public PolarEntry PolarEntry { get; set; } Property Value PolarEntry PreparationT Tool ID for preparation. public int PreparationT { get; set; } Property Value int ProgramOrthogonalPlaneNormal The orthogonal plane transform after tilting plane transform. Include G17, G18, G19 and plane of called G12p1. public Vec3d ProgramOrthogonalPlaneNormal { get; } Property Value Vec3d ProgramPos ProgramPos can be cartesian XYZ or polar XCZ with radius-based X, depends on CoordinateInterpolationMode. public Vec3d ProgramPos { get; } Property Value Vec3d ProgramXyz XYZ in Feature Coordinate. Cartesian Program Position XYZ, Abs Program Position (as G90 position). NC coordinate position is the position processed by modal flags. NC coordinate position is the position after radius compensation. The NC(Program) coordinate position is comprehensible by User. MC NC conversion may raise floating error. The floating error raise the cutting force issue, especially for bottom cutting force. Hence the NC values have to be memorized. public Vec3d ProgramXyz { get; } Property Value Vec3d Remarks NC is the better source property than MC. Ex. a NC line command: X100. The Y and Z value may vary if using MC converting back to NC. The error of Y and Z will keeps accumulating until the next explicit YZ command assignment. The error maybe up to 3e-5 in current case. the bounding box size of the case is not large (TT.20230815). Also note that if using Arc command for a complete circle, the begin NC XYZ and the end NC XYZ have to be equaled. Otherwise, it will become only a very small arc rather than the circle. So be care that do not change the NC XYZ if not needed. RadiusCompensationBuf Internal use. public RadiusCompensationBuf RadiusCompensationBuf { get; set; } Property Value RadiusCompensationBuf RapidFeedrate_mmdmin Rapid Feedrate on NC code in rapid mode (such as G00 but not G01,G02,G03) in mm/min. public double RapidFeedrate_mmdmin { get; set; } Property Value double RapidFeedrate_mmds Rapid Feedrate on NC code in rapid mode (such as G00 but not G01,G02,G03) in mm/sec. public double RapidFeedrate_mmds { get; set; } Property Value double S S. Spindle speed. public int S { get; set; } Property Value int SentenceIndex 0-based ordinal in NC execution order, stamped at construction by HardNcRunner (source-side) or by NcOptProc (optimized-side, a fresh independent count). Init-state lines (RefNcLineOnInit) carry -1 as a “not in pipeline” sentinel. public int SentenceIndex { get; } Property Value int SpindleSpeed_radds Spindle speed in radian/s. public double SpindleSpeed_radds { get; set; } Property Value double SpindleSpeed_rpm Spindle speed in RPM. public double SpindleSpeed_rpm { get; set; } Property Value double T Current equiped Tool ID. public int T { get; set; } Property Value int TiltPlaneNcArg Arguments related to tilted plane operations. public ITiltPlaneNcArg TiltPlaneNcArg { get; set; } Property Value ITiltPlaneNcArg Methods GetAttacherMat(HardNcEnv) Gets the attacher transformation matrix for the current machine coordinates. public Mat4d GetAttacherMat(HardNcEnv ncEnv) Parameters ncEnv HardNcEnv The NC environment. Returns Mat4d The attacher transformation matrix. GetCompensationHeight(HardNcEnv, IProgress<IMessage>) Gets the tool height compensation value for this NC line. public double GetCompensationHeight(HardNcEnv ncEnv, IProgress<IMessage> mixedProgress) Parameters ncEnv HardNcEnv NC environment mixedProgress IProgress<IMessage> Message host for warnings Returns double Height compensation value GetCompensationRadius(CncBrand, MillingToolOffsetTable, IProgress<IMessage>) Gets the tool radius compensation value for this NC line. public double GetCompensationRadius(CncBrand cncBrand, MillingToolOffsetTable millingToolOffsetTable, IProgress<IMessage> mixedProgress) Parameters cncBrand CncBrand CNC brand millingToolOffsetTable MillingToolOffsetTable Milling tool offset table mixedProgress IProgress<IMessage> Message host for warnings Returns double Radius compensation value GetFileLineIndex() Get FileLineIndex. public FileLineIndex GetFileLineIndex() Returns FileLineIndex FileLineIndex GetG5xCoordinateOffset(HardNcEnv) Gets the G5x coordinate offset for this NC line. public Vec3d GetG5xCoordinateOffset(HardNcEnv ncEnv) Parameters ncEnv HardNcEnv NC environment Returns Vec3d The G5x coordinate offset vector GetIndexedFileLine() Gets the file line associated with this object. public IndexedFileLine GetIndexedFileLine() Returns IndexedFileLine The file line object. GetMcByProgramPos(Vec3d, HardNcEnv, NcNoteCache, IProgress<IMessage>, out Vec3d) Internal Use. public DVec3d GetMcByProgramPos(Vec3d programPos, HardNcEnv ncEnv, NcNoteCache ncNoteCache, IProgress<IMessage> mixedProgress, out Vec3d programXyz) Parameters programPos Vec3d ncEnv HardNcEnv ncNoteCache NcNoteCache mixedProgress IProgress<IMessage> programXyz Vec3d Returns DVec3d GetSentence() Returns the source Sentence carried by this object. public Sentence GetSentence() Returns Sentence GetSourceCommand() public IIndexedFileLine GetSourceCommand() Returns IIndexedFileLine GetTiltMat4d(HardNcEnv, out Mat4d) Internal Use Only. public bool? GetTiltMat4d(HardNcEnv ncEnv, out Mat4d tableToFeatureTransform) Parameters ncEnv HardNcEnv NC environment. tableToFeatureTransform Mat4d Transform from NC to Table without tool compensation and linear coordinate offset (such as G55,G56..). Returns bool? True if G68.2 is successfully applied, false if not, and null if not applicable. HasSyntaxMotion(HardNcEnv) Whether this block's own text commands a motion: XYZ words, the polar C word under G12.1, or — on an arc-modal block — the arc words (an incremental I/J/K center or R) that turn a wordless end point into a full circle. Comments are stripped first, so a CAM path-segment header that quotes the next command does not count, and a Heidenhain ISO absolute pole line (I/J/K alone) is a pole reset, not a circle. A block without syntax motion (a comment, an empty line, a bare G41/G40, an M-only block) only inherits modal state; it has no running direction of its own, so the radius compensation walk carries the neighbouring blocks' axes across it and the act builders emit nothing but a zero-length contour for it. public bool HasSyntaxMotion(HardNcEnv ncEnv) Parameters ncEnv HardNcEnv NC environment Returns bool True if the block's own words command a motion; otherwise, false. HasSyntaxXyz(HardNcEnv) Determines whether the line contains syntactic XYZ coordinates. public bool HasSyntaxXyz(HardNcEnv ncEnv) Parameters ncEnv HardNcEnv NC environment Returns bool True if syntactic XYZ coordinates are present; otherwise, false. RebuildByMc(HardNcEnv, DVec3d, NcNoteCache, IProgress<IMessage>) Internal Use Only. For NC opt. public void RebuildByMc(HardNcEnv ncEnv, DVec3d mc, NcNoteCache ncNoteCache, IProgress<IMessage> mixedProgress) Parameters ncEnv HardNcEnv NC environment. mc DVec3d MC coordinates. ncNoteCache NcNoteCache NC line cache. mixedProgress IProgress<IMessage> Message host for logging and reporting. RebuildByProgramXyz(HardNcEnv, Vec3d, NcNoteCache, IProgress<IMessage>) Internal Use Only. For NC opt. public void RebuildByProgramXyz(HardNcEnv ncEnv, Vec3d programXyz, NcNoteCache ncNoteCache, IProgress<IMessage> mixedProgress) Parameters ncEnv HardNcEnv NC environment. programXyz Vec3d Program XYZ coordinates. ncNoteCache NcNoteCache NC note cache. mixedProgress IProgress<IMessage> Message host for logging and reporting. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.HardNcUtil.html": {
    "href": "api/Hi.Numerical.HardNcUtil.html",
    "title": "Class HardNcUtil | HiAPI-C# 2025",
    "summary": "Class HardNcUtil Namespace Hi.Numerical Assembly HiUniNc.dll Utility class for working with NC code. public static class HardNcUtil Inheritance object HardNcUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields NcNameTemplateReplacingKeyword Keyword for replacing NC name in templates. public const string NcNameTemplateReplacingKeyword = \"[NcName]\" Field Value string RelNcFileTemplateReplacingKeyword Keyword for replacing NC file path in templates. public const string RelNcFileTemplateReplacingKeyword = \"[NcFile]\" Field Value string Properties LineBeginCsScriptRegex Gets the regular expression for matching line-beginning C# script markers. public static Regex LineBeginCsScriptRegex { get; } Property Value Regex LineEndCsScriptRegex Gets the regular expression for matching line-ending C# script markers. public static Regex LineEndCsScriptRegex { get; } Property Value Regex Methods GetSimCsScript(string, CncBrand, out string, out string) Extracts C# scripts from the specified NC line text. public static void GetSimCsScript(string ncLineText, CncBrand cncBrand, out string lineBeginCsScript, out string lineEndCsScript) Parameters ncLineText string The NC line text to process. cncBrand CncBrand The CNC brand to determine the comment style. lineBeginCsScript string When this method returns, contains the line-beginning C# script if found; otherwise, null. lineEndCsScript string When this method returns, contains the line-ending C# script if found; otherwise, null. GrabComment(string, CncBrand, out HardNcComment) Extracts and removes a comment from the given NC line text based on the CNC brand. public static string GrabComment(string srcNcLineText, CncBrand brand, out HardNcComment ncComment) Parameters srcNcLineText string The NC line text to process. brand CncBrand The CNC brand to determine the comment style. ncComment HardNcComment When this method returns, contains the extracted comment, or null if no comment was found. Returns string The NC line text with the comment removed if found; otherwise, the original text. GrabDoubleABC(ref string, bool) Grabs and removes A, B, C rotary axis values from the NC text. public static Vec3d GrabDoubleABC(ref string text, bool enableIntegerShrink) Parameters text string The NC text to search and modify. enableIntegerShrink bool Whether to shrink text's integer values by 0.001. Returns Vec3d A Vec3d containing the A, B, C values. GrabDoubleXYZ(ref string, bool) Grabs and removes X, Y, Z coordinate values from the NC text. public static Vec3d GrabDoubleXYZ(ref string text, bool enableIntegerShrink) Parameters text string The NC text to search and modify. enableIntegerShrink bool Whether to shrink text's integer values by 0.001. Returns Vec3d A Vec3d containing the X, Y, Z values. GrabFlag(ref string, string) Grabs and removes a flag from the NC text. public static bool GrabFlag(ref string text, string tag) Parameters text string The NC text to search and modify. tag string The flag tag to search for. Returns bool True if the flag was found and removed; otherwise, false. GrabHeadPercentComment(string, out HardNcComment) Extracts and removes a head percent comment from the given NC line text. public static string GrabHeadPercentComment(string ncLineText, out HardNcComment ncComment) Parameters ncLineText string The NC line text to process. ncComment HardNcComment When this method returns, contains the extracted comment, or null if no comment was found. Returns string The NC line text with the comment removed if found; otherwise, the original text. IsFlagChanging(HardNcLine, HardNcLine, NcFlag) Determines if a flag is changing between two NcLines public static bool IsFlagChanging(this HardNcLine curNcLine, HardNcLine preNcLine, NcFlag ncFlag) Parameters curNcLine HardNcLine The current NcLine preNcLine HardNcLine The previous NcLine ncFlag NcFlag The flag to check Returns bool True if the flag is changing, false otherwise IsFlagChanging(HardNcLine, HardNcLine, NcFlag, bool) Checks if the flag is changing with a specific direction (on or off) between two NC lines. public static bool IsFlagChanging(this HardNcLine curNcLine, HardNcLine preNcLine, NcFlag ncFlag, bool changingOn) Parameters curNcLine HardNcLine The current NC line. preNcLine HardNcLine The previous NC line. ncFlag NcFlag The flag to check. changingOn bool true if flag set to on; otherwise, the flag set to off Returns bool True if the flag is changing in the specified direction; otherwise, false. IsFlagChanging(LinkedListNode<HardNcLine>, NcFlag) Determines if a flag is changing in the current NcLine node compared to the previous node public static bool IsFlagChanging(this LinkedListNode<HardNcLine> curNcLineNode, NcFlag ncFlag) Parameters curNcLineNode LinkedListNode<HardNcLine> The current NcLine node ncFlag NcFlag The flag to check Returns bool True if the flag is changing, false otherwise IsFlagChanging(LinkedListNode<HardNcLine>, NcFlag, bool) Checks if the flag is changing with a specific direction (on or off). public static bool IsFlagChanging(this LinkedListNode<HardNcLine> curNcLineNode, NcFlag ncFlag, bool changingOn) Parameters curNcLineNode LinkedListNode<HardNcLine> The current NC line node. ncFlag NcFlag The flag to check. changingOn bool true if flag set to on; otherwise, the flag set to off Returns bool True if the flag is changing in the specified direction; otherwise, false. IsFlagKeeping(HardNcLine, HardNcLine, NcFlag, bool) Checks if the flag is keeping the same state between two NC lines. public static bool IsFlagKeeping(this HardNcLine curNcLine, HardNcLine preNcLine, NcFlag ncFlag, bool keepingOn) Parameters curNcLine HardNcLine The current NC line. preNcLine HardNcLine The previous NC line. ncFlag NcFlag The flag to check. keepingOn bool true if checking for kept on state; otherwise, checking for kept off state Returns bool True if the flag is keeping the specified state; otherwise, false. RemoveAllCsScript(string, CncBrand) Removes all C# script markers and their contents from the specified NC line text. public static string RemoveAllCsScript(string ncLineText, CncBrand cncBrand) Parameters ncLineText string The NC line text to process. cncBrand CncBrand The CNC brand to determine the comment style. Returns string The NC line text with all C# scripts removed. SetTagNumber(ref string, string, double, string) SetTagNumberWithoutDecimalTailZero. public static void SetTagNumber(ref string ncLineTextWithoutComment, string tag, double tagNumber, string tagNumberFormat) Parameters ncLineTextWithoutComment string tag string tagNumber double tagNumberFormat string"
  },
  "api/Hi.Numerical.IFlexDictionaryHost-1.html": {
    "href": "api/Hi.Numerical.IFlexDictionaryHost-1.html",
    "title": "Interface IFlexDictionaryHost<T> | HiAPI-C# 2025",
    "summary": "Interface IFlexDictionaryHost<T> Namespace Hi.Numerical Assembly HiMech.dll Interface of FlexDictionary. Provider of additional quantity source. public interface IFlexDictionaryHost<T> Type Parameters T Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) FlexDictionaryUtil.CallFlexDictionary<T>(IFlexDictionaryHost<T>) FlexDictionaryUtil.GetFlexDictionaryBytes<T>(IFlexDictionaryHost<T>, IntegerKeyDictionaryConverter<T>) FlexDictionaryUtil.WriteFlexDictionary<T>(IFlexDictionaryHost<T>, BinaryWriter, IntegerKeyDictionaryConverter<T>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties FlexDictionary Gets or sets the flexible dictionary. Dictionary<string, T> FlexDictionary { get; set; } Property Value Dictionary<string, T>"
  },
  "api/Hi.Numerical.IGetFeedrate.html": {
    "href": "api/Hi.Numerical.IGetFeedrate.html",
    "title": "Interface IGetFeedrate | HiAPI-C# 2025",
    "summary": "Interface IGetFeedrate Namespace Hi.Numerical Assembly HiGeom.dll Interface for retrieving feedrate information. public interface IGetFeedrate Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) NumericUtil.GetFeedrate_mmdmin(IGetFeedrate) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetFeedrate_mmds() Gets the program feedrate in millimeters per second. double GetFeedrate_mmds() Returns double Feedrate in mm/s"
  },
  "api/Hi.Numerical.IGetSpindleSpeed.html": {
    "href": "api/Hi.Numerical.IGetSpindleSpeed.html",
    "title": "Interface IGetSpindleSpeed | HiAPI-C# 2025",
    "summary": "Interface IGetSpindleSpeed Namespace Hi.Numerical Assembly HiGeom.dll Interface for retrieving spindle speed and direction information. public interface IGetSpindleSpeed Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) NumericUtil.GetSpindleCyclePeriod(IGetSpindleSpeed) NumericUtil.GetSpindleCyclePeriod_s(IGetSpindleSpeed) NumericUtil.GetSpindleSpeed_rpm(IGetSpindleSpeed) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetSpindleDirection() Gets the spindle rotation direction. SpindleDirection GetSpindleDirection() Returns SpindleDirection The spindle direction (clockwise, counterclockwise, or stopped) GetSpindleSpeed_radds() Gets the spindle speed in radians per second. double GetSpindleSpeed_radds() Returns double Spindle speed in rad/s"
  },
  "api/Hi.Numerical.INcRunner.html": {
    "href": "api/Hi.Numerical.INcRunner.html",
    "title": "Interface INcRunner | HiAPI-C# 2025",
    "summary": "Interface INcRunner Namespace Hi.Numerical Assembly HiMech.dll NC runner — parses and executes NC program lines. Nc is the umbrella term for any machine-readable control program (famous-brand controller code, NX-CL, CSV): the same runner contract serves all of them, and NcKind names the kinds where they must be distinguished. public interface INcRunner Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks Renamed from IControlRunner (with RunControlLines) — the implementors were already named SoftNcRunner / HardNcRunner, and the whole soft pipeline (session state, syntax layers, dependencies) carries the Nc prefix while serving CL and CSV too. Methods RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) Runs raw NC program lines and yields source sentence and Act pairs. IEnumerable<SourcedActEntry> RunNcLines(string relFilePath, IEnumerable<string> lines, MachiningSession machiningSession, StepDiagnosticProgress stepDiagnosticProgress, NcDiagnosticProgress ncDiagnosticProgress, CancellationToken cancellationToken) Parameters relFilePath string The relative path of the NC program file lines IEnumerable<string> The enumerable collection of NC program lines machiningSession MachiningSession Session-scoped state shared across multiple RunNcLines(string, IEnumerable<string>, MachiningSession, StepDiagnosticProgress, NcDiagnosticProgress, CancellationToken) calls (e.g. lazy-initialized pipeline state, file-index counter). stepDiagnosticProgress StepDiagnosticProgress Step-anchored IMessage-channel sink. ncDiagnosticProgress NcDiagnosticProgress NC-pipeline diagnostic sink, threaded in as an input so the runner stays host-agnostic (the caller injects it; the production caller passes the service-scoped instance, standalone tests pass their own). cancellationToken CancellationToken Cancellation token to cancel the operation Returns IEnumerable<SourcedActEntry> Enumerable of source sentence and Act pairs"
  },
  "api/Hi.Numerical.ISetFeedrate.html": {
    "href": "api/Hi.Numerical.ISetFeedrate.html",
    "title": "Interface ISetFeedrate | HiAPI-C# 2025",
    "summary": "Interface ISetFeedrate Namespace Hi.Numerical Assembly HiGeom.dll Interface for setting feedrate information. public interface ISetFeedrate Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) NumericUtil.SetFeedrate_mmdmin(ISetFeedrate, double) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods SetFeedrate_mmds(double) Sets the feedrate in millimeters per second. void SetFeedrate_mmds(double feedrate_mmds) Parameters feedrate_mmds double Feedrate value in mm/s"
  },
  "api/Hi.Numerical.ISetSpindleSpeed.html": {
    "href": "api/Hi.Numerical.ISetSpindleSpeed.html",
    "title": "Interface ISetSpindleSpeed | HiAPI-C# 2025",
    "summary": "Interface ISetSpindleSpeed Namespace Hi.Numerical Assembly HiGeom.dll Interface for setting spindle speed. public interface ISetSpindleSpeed Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) NumericUtil.SetSpindleSpeed_rpm(ISetSpindleSpeed, double) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods SetSpindleSpeed_radds(double) Sets the spindle speed in radians per second. void SetSpindleSpeed_radds(double spindleSpeed_radds) Parameters spindleSpeed_radds double Spindle speed value in rad/s"
  },
  "api/Hi.Numerical.MachiningMotionResolutionUtils.FeedPerCycleMachiningMotionResolution.html": {
    "href": "api/Hi.Numerical.MachiningMotionResolutionUtils.FeedPerCycleMachiningMotionResolution.html",
    "title": "Class FeedPerCycleMachiningMotionResolution | HiAPI-C# 2025",
    "summary": "Class FeedPerCycleMachiningMotionResolution Namespace Hi.Numerical.MachiningMotionResolutionUtils Assembly HiMech.dll Automatic resolution by feed per spindle cycle. public class FeedPerCycleMachiningMotionResolution : IMachiningMotionResolution, IMakeXmlSource, IToXElement Inheritance object FeedPerCycleMachiningMotionResolution Implements IMachiningMotionResolution IMakeXmlSource IToXElement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FeedPerCycleMachiningMotionResolution() Ctor. public FeedPerCycleMachiningMotionResolution() FeedPerCycleMachiningMotionResolution(XElement) Ctor. public FeedPerCycleMachiningMotionResolution(XElement src) Parameters src XElement XML Properties LinearResolution_mm Linear axis resolution in millimeter. public double LinearResolution_mm { get; } Property Value double Remarks setter is for internal usage MinLinearResolution_mm Optional floor (millimetres) for LinearResolution_mm after feed-per-cycle scaling; zero disables clamping. public double MinLinearResolution_mm { get; set; } Property Value double RotaryAxisResolution_rad Resolution in radian for a rotary-axis (A/B/C) swing — the posture change of the tool. Always finite: a swing is bounded by this angle whether or not the spindle turns, so a rapid 90° table swing is never left to a single step. public double RotaryAxisResolution_rad { get; } Property Value double Remarks 15° regardless of the spindle: a rapid table swing is bounded by posture change even when RotaryResolution_rad is infinite. RotaryResolution_deg RotaryResolution_rad in degree. public double RotaryResolution_deg { get; } Property Value double Remarks setter is for internal usage RotaryResolution_rad Angular resolution in radian for an arc's swept angle (and, on a fixed resolution, for rotary-axis swings as well — see RotaryAxisResolution_rad). A feed-derived resolution reports infinity here while the spindle turns: an arc is then split by its length per spindle cycle alone. public double RotaryResolution_rad { get; } Property Value double Remarks setter is for internal usage. Infinite while the spindle turns and a feed is set: an arc is then split by its length per cycle alone; rotary-axis swings use RotaryAxisResolution_rad. Scale Gets or sets the scale factor for resolution calculation. Default value is 1. public double Scale { get; set; } Property Value double SpindleSpeed_radds The spindle speed the last AdjustMotionResolution(double, double) saw (rad/s); zero or negative means the spindle is not turning and the time criterion does not apply. public double SpindleSpeed_radds { get; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods AdjustMotionResolution(double, double) Adjusts the resolution based on feed rate and spindle speed. public void AdjustMotionResolution(double feedrate_mmds, double spindleSpeed_radds) Parameters feedrate_mmds double Feed rate in mm per second spindleSpeed_radds double Spindle speed in radians per second GetStepNumByDuration(TimeSpan, double) Step count the time criterion assigns to an act of the given duration, or null when this resolution has no time criterion — a fixed geometric resolution, or a feed-derived one while the spindle is not turning. Feed per cycle means one step per spindle revolution, feed per tooth one per tooth pass; the value is the revolutions (or tooth passes) the act spans, scaled by the resolution's own knobs. This is the criterion a rotary-bearing act uses instead of \"tool-tip travel ÷ LinearResolution_mm\". The linear resolution is derived from the controller's commanded CL feedrate, but the real tool tip (the equipped tool, possibly not the length the controller's H describes) travels with the posture change while that CL point may stand still; dividing the one by the other mixes two motions, and for a pure RTCP rapid swing it saturated the step count to MaxValue (a customer program, 2026-09-08). Counting spindle cycles over the act's duration is the same number whenever tip and CL point coincide, and the honest one when they do not. public int? GetStepNumByDuration(TimeSpan duration, double travel_mm) Parameters duration TimeSpan The act's duration. travel_mm double The real tool-tip travel of the act in mm, or NaN when unknown; a resolution with a user floor on per-step travel caps the count so a step never covers less than that floor. Returns int? Remarks One step per spindle revolution over the act, divided by Scale; with a user floor (MinLinearResolution_mm) the count is also capped so a step covers at least that much real tool-tip travel. Null while the spindle is not turning or the act has no duration. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.Numerical.MachiningMotionResolutionUtils.FeedPerToothMachiningMotionResolution.html": {
    "href": "api/Hi.Numerical.MachiningMotionResolutionUtils.FeedPerToothMachiningMotionResolution.html",
    "title": "Class FeedPerToothMachiningMotionResolution | HiAPI-C# 2025",
    "summary": "Class FeedPerToothMachiningMotionResolution Namespace Hi.Numerical.MachiningMotionResolutionUtils Assembly HiMech.dll Automatic resolution by feed per tooth. public class FeedPerToothMachiningMotionResolution : IMachiningMotionResolution, IMakeXmlSource, IToXElement Inheritance object FeedPerToothMachiningMotionResolution Implements IMachiningMotionResolution IMakeXmlSource IToXElement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FeedPerToothMachiningMotionResolution() Ctor. public FeedPerToothMachiningMotionResolution() Properties FluteNum Flute count the last AdjustResolution(int, double, double) saw. public int FluteNum { get; } Property Value int LinearResolution_mm Linear axis resolution in millimeter. public double LinearResolution_mm { get; } Property Value double Remarks setter is for internal usage RotaryAxisResolution_rad Resolution in radian for a rotary-axis (A/B/C) swing — the posture change of the tool. Always finite: a swing is bounded by this angle whether or not the spindle turns, so a rapid 90° table swing is never left to a single step. public double RotaryAxisResolution_rad { get; } Property Value double RotaryResolution_deg RotaryResolution_rad in degree. public double RotaryResolution_deg { get; set; } Property Value double Remarks setter is for internal usage RotaryResolution_rad Angular resolution in radian for an arc's swept angle (and, on a fixed resolution, for rotary-axis swings as well — see RotaryAxisResolution_rad). A feed-derived resolution reports infinity here while the spindle turns: an arc is then split by its length per spindle cycle alone. public double RotaryResolution_rad { get; } Property Value double Remarks setter is for internal usage SpindleSpeed_radds Spindle speed (rad/s) the last AdjustResolution(int, double, double) saw. public double SpindleSpeed_radds { get; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods AdjustResolution(int, double, double) Adjusts the resolution based on flute number, feed rate and spindle speed. public void AdjustResolution(int fluteNum, double feedrate_mmds, double spindleSpeed_radds) Parameters fluteNum int Number of flutes in the cutting tool feedrate_mmds double Feed rate in mm per second spindleSpeed_radds double Spindle speed in radians per second GetStepNumByDuration(TimeSpan, double) Step count the time criterion assigns to an act of the given duration, or null when this resolution has no time criterion — a fixed geometric resolution, or a feed-derived one while the spindle is not turning. Feed per cycle means one step per spindle revolution, feed per tooth one per tooth pass; the value is the revolutions (or tooth passes) the act spans, scaled by the resolution's own knobs. This is the criterion a rotary-bearing act uses instead of \"tool-tip travel ÷ LinearResolution_mm\". The linear resolution is derived from the controller's commanded CL feedrate, but the real tool tip (the equipped tool, possibly not the length the controller's H describes) travels with the posture change while that CL point may stand still; dividing the one by the other mixes two motions, and for a pure RTCP rapid swing it saturated the step count to MaxValue (a customer program, 2026-09-08). Counting spindle cycles over the act's duration is the same number whenever tip and CL point coincide, and the honest one when they do not. public int? GetStepNumByDuration(TimeSpan duration, double travel_mm) Parameters duration TimeSpan The act's duration. travel_mm double The real tool-tip travel of the act in mm, or NaN when unknown; a resolution with a user floor on per-step travel caps the count so a step never covers less than that floor. Returns int? Remarks One step per tooth pass (revolutions × flutes) over the act; null while the spindle is not turning, the flute count is unknown or the act has no duration. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.Numerical.MachiningMotionResolutionUtils.FixedMachiningMotionResolution.html": {
    "href": "api/Hi.Numerical.MachiningMotionResolutionUtils.FixedMachiningMotionResolution.html",
    "title": "Class FixedMachiningMotionResolution | HiAPI-C# 2025",
    "summary": "Class FixedMachiningMotionResolution Namespace Hi.Numerical.MachiningMotionResolutionUtils Assembly HiMech.dll Represents a fixed machining motion resolution with user-defined values. public class FixedMachiningMotionResolution : IMachiningMotionResolution, IMakeXmlSource, IToXElement Inheritance object FixedMachiningMotionResolution Implements IMachiningMotionResolution IMakeXmlSource IToXElement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors FixedMachiningMotionResolution() Ctor. public FixedMachiningMotionResolution() FixedMachiningMotionResolution(double, double) Ctor. public FixedMachiningMotionResolution(double linearResolution_mm, double rotaryResolution_deg) Parameters linearResolution_mm double rotaryResolution_deg double FixedMachiningMotionResolution(XElement) Ctor. public FixedMachiningMotionResolution(XElement src) Parameters src XElement XML Properties LinearResolution_mm Linear axis resolution in millimeter. public double LinearResolution_mm { get; set; } Property Value double RotaryAxisResolution_rad Resolution in radian for a rotary-axis (A/B/C) swing — the posture change of the tool. Always finite: a swing is bounded by this angle whether or not the spindle turns, so a rapid 90° table swing is never left to a single step. public double RotaryAxisResolution_rad { get; } Property Value double Remarks A fixed resolution bounds arcs and axis swings by the same angle; a zero or non-finite user value falls back to 15° here so the posture bound stays finite. RotaryResolution_deg Rotary axis resolution in degree. public double RotaryResolution_deg { get; set; } Property Value double RotaryResolution_rad Rotary axis resolution in radian. public double RotaryResolution_rad { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods GetStepNumByDuration(TimeSpan, double) Step count the time criterion assigns to an act of the given duration, or null when this resolution has no time criterion — a fixed geometric resolution, or a feed-derived one while the spindle is not turning. Feed per cycle means one step per spindle revolution, feed per tooth one per tooth pass; the value is the revolutions (or tooth passes) the act spans, scaled by the resolution's own knobs. This is the criterion a rotary-bearing act uses instead of \"tool-tip travel ÷ LinearResolution_mm\". The linear resolution is derived from the controller's commanded CL feedrate, but the real tool tip (the equipped tool, possibly not the length the controller's H describes) travels with the posture change while that CL point may stand still; dividing the one by the other mixes two motions, and for a pure RTCP rapid swing it saturated the step count to MaxValue (a customer program, 2026-09-08). Counting spindle cycles over the act's duration is the same number whenever tip and CL point coincide, and the honest one when they do not. public int? GetStepNumByDuration(TimeSpan duration, double travel_mm) Parameters duration TimeSpan The act's duration. travel_mm double The real tool-tip travel of the act in mm, or NaN when unknown; a resolution with a user floor on per-step travel caps the count so a step never covers less than that floor. Returns int? Remarks Purely geometric — there is no time criterion, so always null. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.Numerical.MachiningMotionResolutionUtils.IMachiningMotionResolution.html": {
    "href": "api/Hi.Numerical.MachiningMotionResolutionUtils.IMachiningMotionResolution.html",
    "title": "Interface IMachiningMotionResolution | HiAPI-C# 2025",
    "summary": "Interface IMachiningMotionResolution Namespace Hi.Numerical.MachiningMotionResolutionUtils Assembly HiMech.dll Interface of Machining Cycle Resolution. public interface IMachiningMotionResolution : IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties LinearResolution_mm Linear axis resolution in millimeter. double LinearResolution_mm { get; } Property Value double RotaryAxisResolution_rad Resolution in radian for a rotary-axis (A/B/C) swing — the posture change of the tool. Always finite: a swing is bounded by this angle whether or not the spindle turns, so a rapid 90° table swing is never left to a single step. double RotaryAxisResolution_rad { get; } Property Value double RotaryResolution_deg RotaryResolution_rad in degree. double RotaryResolution_deg { get; } Property Value double RotaryResolution_rad Angular resolution in radian for an arc's swept angle (and, on a fixed resolution, for rotary-axis swings as well — see RotaryAxisResolution_rad). A feed-derived resolution reports infinity here while the spindle turns: an arc is then split by its length per spindle cycle alone. double RotaryResolution_rad { get; } Property Value double Methods GetStepNumByDuration(TimeSpan, double) Step count the time criterion assigns to an act of the given duration, or null when this resolution has no time criterion — a fixed geometric resolution, or a feed-derived one while the spindle is not turning. Feed per cycle means one step per spindle revolution, feed per tooth one per tooth pass; the value is the revolutions (or tooth passes) the act spans, scaled by the resolution's own knobs. This is the criterion a rotary-bearing act uses instead of \"tool-tip travel ÷ LinearResolution_mm\". The linear resolution is derived from the controller's commanded CL feedrate, but the real tool tip (the equipped tool, possibly not the length the controller's H describes) travels with the posture change while that CL point may stand still; dividing the one by the other mixes two motions, and for a pure RTCP rapid swing it saturated the step count to MaxValue (a customer program, 2026-09-08). Counting spindle cycles over the act's duration is the same number whenever tip and CL point coincide, and the honest one when they do not. int? GetStepNumByDuration(TimeSpan duration, double travel_mm) Parameters duration TimeSpan The act's duration. travel_mm double The real tool-tip travel of the act in mm, or NaN when unknown; a resolution with a user floor on per-step travel caps the count so a step never covers less than that floor. Returns int?"
  },
  "api/Hi.Numerical.MachiningMotionResolutionUtils.html": {
    "href": "api/Hi.Numerical.MachiningMotionResolutionUtils.html",
    "title": "Namespace Hi.Numerical.MachiningMotionResolutionUtils | HiAPI-C# 2025",
    "summary": "Namespace Hi.Numerical.MachiningMotionResolutionUtils Classes FeedPerCycleMachiningMotionResolution Automatic resolution by feed per spindle cycle. FeedPerToothMachiningMotionResolution Automatic resolution by feed per tooth. FixedMachiningMotionResolution Represents a fixed machining motion resolution with user-defined values. Interfaces IMachiningMotionResolution Interface of Machining Cycle Resolution."
  },
  "api/Hi.Numerical.MechNcUtil.html": {
    "href": "api/Hi.Numerical.MechNcUtil.html",
    "title": "Class MechNcUtil | HiAPI-C# 2025",
    "summary": "Class MechNcUtil Namespace Hi.Numerical Assembly HiMech.dll NC Utility. public static class MechNcUtil Inheritance object MechNcUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetNoInterpolationOrdinaryProgramXcz_rad(Vec3d, double, Vec3d) Internal Use Only. No interpolation may occur angle cycle problem. The function is usable only if ensuring the angle difference is within helf cycle. public static Vec3d GetNoInterpolationOrdinaryProgramXcz_rad(Vec3d curProgramPolarXcz, double preMcC_rad, Vec3d preProgramPolarXcz) Parameters curProgramPolarXcz Vec3d Current program polar XCZ preMcC_rad double Previous machine C angle in radians preProgramPolarXcz Vec3d Previous program polar XCZ Returns Vec3d Ordinary program XCZ coordinates in radians GetOrdinaryProgramXcz_rad(Vec3d, double, Vec3d) In Polar coordinate interpolation mode (G12.1), rotary is assigned by hypothesis value (called C. Some controller accepts Y as equivalent.). While converting the hypothesis value to rotary angle occurs problem of angle cycle. The function get the resolved angle. public static Vec3d GetOrdinaryProgramXcz_rad(Vec3d curCentralProgramPolarPos, double preMcC_rad, Vec3d preCentralProgramPolarPos) Parameters curCentralProgramPolarPos Vec3d Current central program polar position preMcC_rad double Previous machine C angle in radians preCentralProgramPolarPos Vec3d Previous central program polar position Returns Vec3d Ordinary program XCZ coordinates in radians GetProgramPolarRxczByOrdinaryProgramXcz(Vec3d) Converts ordinary program XCZ coordinates to program polar RXCZ coordinates. public static Vec3d GetProgramPolarRxczByOrdinaryProgramXcz(Vec3d ordinaryProgramXcz_rad) Parameters ordinaryProgramXcz_rad Vec3d Ordinary program XCZ coordinates in radians Returns Vec3d Program polar RXCZ coordinates GetUnresolvedAngleOrdinaryProgramXcz_rad(Vec3d) OrdinaryProgramPos: Cartesian X (radius) and Rotation C in ard. the C rotation angle has not been unresolved from angle cycling. central(X=0,C=0) is coordinate origin. public static Vec3d GetUnresolvedAngleOrdinaryProgramXcz_rad(Vec3d centralProgramPolarXcz) Parameters centralProgramPolarXcz Vec3d Returns Vec3d"
  },
  "api/Hi.Numerical.MillingToolOffsetTable.html": {
    "href": "api/Hi.Numerical.MillingToolOffsetTable.html",
    "title": "Class MillingToolOffsetTable | HiAPI-C# 2025",
    "summary": "Class MillingToolOffsetTable Namespace Hi.Numerical Assembly HiUniNc.dll Offset table for milling tool. The key is Offset ID (H or D in NC code). public class MillingToolOffsetTable : Dictionary<int, MillingToolOffsetTableRow>, IDictionary<int, MillingToolOffsetTableRow>, ICollection<KeyValuePair<int, MillingToolOffsetTableRow>>, IReadOnlyDictionary<int, MillingToolOffsetTableRow>, IReadOnlyCollection<KeyValuePair<int, MillingToolOffsetTableRow>>, IEnumerable<KeyValuePair<int, MillingToolOffsetTableRow>>, IDictionary, ICollection, IEnumerable, IDeserializationCallback, ISerializable, IMakeXmlSource Inheritance object Dictionary<int, MillingToolOffsetTableRow> MillingToolOffsetTable Implements IDictionary<int, MillingToolOffsetTableRow> ICollection<KeyValuePair<int, MillingToolOffsetTableRow>> IReadOnlyDictionary<int, MillingToolOffsetTableRow> IReadOnlyCollection<KeyValuePair<int, MillingToolOffsetTableRow>> IEnumerable<KeyValuePair<int, MillingToolOffsetTableRow>> IDictionary ICollection IEnumerable IDeserializationCallback ISerializable IMakeXmlSource Inherited Members Dictionary<int, MillingToolOffsetTableRow>.Add(int, MillingToolOffsetTableRow) Dictionary<int, MillingToolOffsetTableRow>.Clear() Dictionary<int, MillingToolOffsetTableRow>.ContainsKey(int) Dictionary<int, MillingToolOffsetTableRow>.ContainsValue(MillingToolOffsetTableRow) Dictionary<int, MillingToolOffsetTableRow>.EnsureCapacity(int) Dictionary<int, MillingToolOffsetTableRow>.GetAlternateLookup<TAlternateKey>() Dictionary<int, MillingToolOffsetTableRow>.GetEnumerator() Dictionary<int, MillingToolOffsetTableRow>.OnDeserialization(object) Dictionary<int, MillingToolOffsetTableRow>.Remove(int) Dictionary<int, MillingToolOffsetTableRow>.Remove(int, out MillingToolOffsetTableRow) Dictionary<int, MillingToolOffsetTableRow>.TrimExcess() Dictionary<int, MillingToolOffsetTableRow>.TrimExcess(int) Dictionary<int, MillingToolOffsetTableRow>.TryAdd(int, MillingToolOffsetTableRow) Dictionary<int, MillingToolOffsetTableRow>.TryGetAlternateLookup<TAlternateKey>(out Dictionary<int, MillingToolOffsetTableRow>.AlternateLookup<TAlternateKey>) Dictionary<int, MillingToolOffsetTableRow>.TryGetValue(int, out MillingToolOffsetTableRow) Dictionary<int, MillingToolOffsetTableRow>.Comparer Dictionary<int, MillingToolOffsetTableRow>.Count Dictionary<int, MillingToolOffsetTableRow>.Capacity Dictionary<int, MillingToolOffsetTableRow>.this[int] Dictionary<int, MillingToolOffsetTableRow>.Keys Dictionary<int, MillingToolOffsetTableRow>.Values object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) DictionaryUtil.Retrieve<K, V>(Dictionary<K, V>, K, out V, bool) DictionaryUtil.GetOrCreate<TKey, TValue>(IDictionary<TKey, TValue>, TKey) DictionaryUtil.GetOrCreate<TKey, TValue>(IDictionary<TKey, TValue>, TKey, TValue) DictionaryUtil.GetOrCreate<TKey, TValue>(IDictionary<TKey, TValue>, TKey, Func<TValue>) DictionaryUtil.TryGetValueByKeys<TKey, TValue>(IDictionary<TKey, TValue>, IEnumerable<TKey>, out TValue) StringUtil.ToDotSplitedString<T>(IEnumerable<T>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MillingToolOffsetTable() Initializes a new instance of the MillingToolOffsetTable class. public MillingToolOffsetTable() MillingToolOffsetTable(MillingToolOffsetTable) Initializes a new instance of the MillingToolOffsetTable class by copying an existing table. public MillingToolOffsetTable(MillingToolOffsetTable src) Parameters src MillingToolOffsetTable The source table to copy. MillingToolOffsetTable(XElement) Initializes a new instance of the MillingToolOffsetTable class from XML. public MillingToolOffsetTable(XElement src) Parameters src XElement The XML element containing tool offset data. Fields XName Gets the XML element name for the MillingToolOffsetTable. public static string XName Field Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of this offset table. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for relative paths. relFile string The relative file path. exhibitionOnly bool Returns XElement An XML element representing this offset table. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory UpdateIdealMillingToolOffsetTableByToolHouse(MachiningToolHouse) Updates the ideal tool offsets in this table based on a tool house. public void UpdateIdealMillingToolOffsetTableByToolHouse(MachiningToolHouse millingToolHouse) Parameters millingToolHouse MachiningToolHouse The machining tool house containing tool information."
  },
  "api/Hi.Numerical.MillingToolOffsetTableRow.html": {
    "href": "api/Hi.Numerical.MillingToolOffsetTableRow.html",
    "title": "Class MillingToolOffsetTableRow | HiAPI-C# 2025",
    "summary": "Class MillingToolOffsetTableRow Namespace Hi.Numerical Assembly HiUniNc.dll Raw of MillingToolOffsetTable public class MillingToolOffsetTableRow Inheritance object MillingToolOffsetTableRow Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MillingToolOffsetTableRow() Ctor. public MillingToolOffsetTableRow() MillingToolOffsetTableRow(XElement) Initializes a new instance of the MillingToolOffsetTableRow class from XML. public MillingToolOffsetTableRow(XElement src) Parameters src XElement The XML element containing tool offset row data. Properties AxialWear_mm Gets or sets the axial wear of the tool in millimeters. public double AxialWear_mm { get; set; } Property Value double FullHeight_mm Gets the total height of the tool including wear in millimeters. public double FullHeight_mm { get; } Property Value double FullRadius_mm Gets the total radius of the tool including wear in millimeters. public double FullRadius_mm { get; } Property Value double IdealHeight_mm Gets or sets the ideal height of the tool in millimeters. public double IdealHeight_mm { get; set; } Property Value double IdealRadius_mm Gets or sets the ideal radius of the tool in millimeters. public double IdealRadius_mm { get; set; } Property Value double RadialWear_mm Gets or sets the radial wear of the tool in millimeters. public double RadialWear_mm { get; set; } Property Value double XName XML Name. public static string XName { get; } Property Value string Methods Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Converts this offset table row to an XML element. public XElement ToXElement() Returns XElement An XML element representing this offset table row."
  },
  "api/Hi.Numerical.NcArgs.ArcNcArg.html": {
    "href": "api/Hi.Numerical.NcArgs.ArcNcArg.html",
    "title": "Class ArcNcArg | HiAPI-C# 2025",
    "summary": "Class ArcNcArg Namespace Hi.Numerical.NcArgs Assembly HiUniNc.dll Arc parameters for HardNcLine. Arc comes from G02,G03. public class ArcNcArg Inheritance object ArcNcArg Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ArcNcArg() Initializes a new instance of the ArcNcArg class. public ArcNcArg() ArcNcArg(ArcNcArg) Initializes a new instance of the ArcNcArg class by copying an existing instance. public ArcNcArg(ArcNcArg src) Parameters src ArcNcArg The source instance to copy. Properties Ijk Gets or sets the I, J, K values that define the center of the arc. public Vec3d Ijk { get; set; } Property Value Vec3d IsIjkAbsolute Whether Ijk addresses the circle center as absolute program coordinates instead of offsets from the arc start. Heidenhain DIN/ISO reads I/J/K this way (the ISO twin of the Klartext CC pole); Fanuc/Siemens/Syntec/Mazak — and Heidenhain under G91 — use start-to-center offsets. Stamped by HardNcLine.BuildArcNcArg from the brand and the G91 state. public bool IsIjkAbsolute { get; set; } Property Value bool L circle number. count as once cycle if not approach one cycle. public int L { get; set; } Property Value int Q Gets or sets the Q parameter value. public double Q { get; set; } Property Value double R Gets or sets the radius value for defining the arc. public double R { get; set; } Property Value double Methods GetCenterOrCenterOnBeginPlane(Vec3d, Vec3d, Vec3d, bool) Calculates the center point of the arc. public Vec3d GetCenterOrCenterOnBeginPlane(Vec3d beginXyz, Vec3d endXyz, Vec3d programOrthogonalPlaneNormal, bool isCcw) Parameters beginXyz Vec3d The start point of the arc. endXyz Vec3d The end point of the arc. programOrthogonalPlaneNormal Vec3d The normal vector of the plane containing the arc. isCcw bool True if the arc is counter-clockwise, false if clockwise. Returns Vec3d The center point of the arc."
  },
  "api/Hi.Numerical.NcArgs.G28Arg.html": {
    "href": "api/Hi.Numerical.NcArgs.G28Arg.html",
    "title": "Class G28Arg | HiAPI-C# 2025",
    "summary": "Class G28Arg Namespace Hi.Numerical.NcArgs Assembly HiUniNc.dll Represents arguments for the G28 command (Return to Reference Point). public class G28Arg Inheritance object G28Arg Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties IntermediateNcAbc_deg Gets or sets the intermediate NC A, B, C values in degrees. public Vec3d IntermediateNcAbc_deg { set; } Property Value Vec3d IntermediateNcAbc_rad Gets or sets the intermediate NC A, B, C values in radians. public Vec3d IntermediateNcAbc_rad { get; set; } Property Value Vec3d IntermediateNcXyz Nc: the program coordinate without tool height and radius compensation. public Vec3d IntermediateNcXyz { get; set; } Property Value Vec3d IntermediateNcXyzabc abc unit is in radian. public DVec3d IntermediateNcXyzabc { get; set; } Property Value DVec3d"
  },
  "api/Hi.Numerical.NcArgs.Group07NcArg.html": {
    "href": "api/Hi.Numerical.NcArgs.Group07NcArg.html",
    "title": "Class Group07NcArg | HiAPI-C# 2025",
    "summary": "Class Group07NcArg Namespace Hi.Numerical.NcArgs Assembly HiUniNc.dll parameters of NcGroup07. Radius compensation. public class Group07NcArg Inheritance object Group07NcArg Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties PreAbsoluteXyzOnProgramCoordinate For Radius Compensation. Previous Nc XYZ by absolute feature (G90). Program coordinate is the last coordinate in the NC editing stack. public Vec3d PreAbsoluteXyzOnProgramCoordinate { get; set; } Property Value Vec3d"
  },
  "api/Hi.Numerical.NcArgs.Group09NcArg.html": {
    "href": "api/Hi.Numerical.NcArgs.Group09NcArg.html",
    "title": "Class Group09NcArg | HiAPI-C# 2025",
    "summary": "Class Group09NcArg Namespace Hi.Numerical.NcArgs Assembly HiUniNc.dll NC Argument of NC Group09. public class Group09NcArg Inheritance object Group09NcArg Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Group09NcArg() Ctor. public Group09NcArg() Group09NcArg(Group09NcArg) Copy ctor. public Group09NcArg(Group09NcArg src) Parameters src Group09NcArg Properties K Repeated times. Available for G81,G85,G86,G82,G83. public int K { get; set; } Property Value int P Bottom staying duration. unit is seconds. Available for G82. public double P { get; set; } Property Value double Q Feeding depth per stroke. Available for G83. public double Q { get; set; } Property Value double R Reference height. Available for G81,G85,G86,G82,G83. public double R { get; set; } Property Value double SiemensCycleType Siemens cycle type for MCALL mode. 81 = CYCLE81 (G81), 82 = CYCLE82 (G82), 83 = CYCLE83 (G83). 0 = not set / Fanuc mode. public int SiemensCycleType { get; set; } Property Value int Z Z at pass-through point. The pass-through point is at bottom. Available for G81,G85,G86,G82,G83. public double Z { get; set; } Property Value double"
  },
  "api/Hi.Numerical.NcArgs.HeidenhainCycleDef7Arg.html": {
    "href": "api/Hi.Numerical.NcArgs.HeidenhainCycleDef7Arg.html",
    "title": "Class HeidenhainCycleDef7Arg | HiAPI-C# 2025",
    "summary": "Class HeidenhainCycleDef7Arg Namespace Hi.Numerical.NcArgs Assembly HiUniNc.dll Argument of Heidenhain CYCL DEF 7. Datum Shift. public class HeidenhainCycleDef7Arg : IHeidenhainBlockCacheArg Inheritance object HeidenhainCycleDef7Arg Implements IHeidenhainBlockCacheArg Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties DatumTableId If table Id ==-1, the cycle does not use the table from this property. TableId is exclusive with SyntaxShift. public int DatumTableId { get; set; } Property Value int SyntaxShift If value is null, the cycle does not use the shift from this property. SyntaxShift is exclusive with DatumTableId. public Vec3d SyntaxShift { get; set; } Property Value Vec3d Methods ToString() Returns a string representation of the datum shift value. public override string ToString() Returns string A string representation based on either the datum table ID or the syntax shift value."
  },
  "api/Hi.Numerical.NcArgs.HeidenhainPlaneSpatialArg.html": {
    "href": "api/Hi.Numerical.NcArgs.HeidenhainPlaneSpatialArg.html",
    "title": "Class HeidenhainPlaneSpatialArg | HiAPI-C# 2025",
    "summary": "Class HeidenhainPlaneSpatialArg Namespace Hi.Numerical.NcArgs Assembly HiUniNc.dll Represents a Heidenhain spatial plane defined by rotation angles. public class HeidenhainPlaneSpatialArg : IHeidenhainPlaneArg, ITiltPlaneNcArg Inheritance object HeidenhainPlaneSpatialArg Implements IHeidenhainPlaneArg ITiltPlaneNcArg Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HeidenhainPlaneSpatialArg(Vec3d, Mat4d) Initializes a new instance of the HeidenhainPlaneSpatialArg class. public HeidenhainPlaneSpatialArg(Vec3d spatialABC_rad, Mat4d tiltingTransformation) Parameters spatialABC_rad Vec3d The spatial rotation angles (A, B, C) in radians. tiltingTransformation Mat4d The transformation matrix representing the tilting operation. Properties SpatialABC_rad Gets the spatial rotation angles (A, B, C) in radians. public Vec3d SpatialABC_rad { get; } Property Value Vec3d TiltingTransformation Gets the transformation matrix representing the tilting operation. public Mat4d TiltingTransformation { get; } Property Value Mat4d Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.NcArgs.IHeidenhainBlockCacheArg.html": {
    "href": "api/Hi.Numerical.NcArgs.IHeidenhainBlockCacheArg.html",
    "title": "Interface IHeidenhainBlockCacheArg | HiAPI-C# 2025",
    "summary": "Interface IHeidenhainBlockCacheArg Namespace Hi.Numerical.NcArgs Assembly HiUniNc.dll Interface for Heidenhain block cache arguments. public interface IHeidenhainBlockCacheArg Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Numerical.NcArgs.IHeidenhainPlaneArg.html": {
    "href": "api/Hi.Numerical.NcArgs.IHeidenhainPlaneArg.html",
    "title": "Interface IHeidenhainPlaneArg | HiAPI-C# 2025",
    "summary": "Interface IHeidenhainPlaneArg Namespace Hi.Numerical.NcArgs Assembly HiUniNc.dll Interface for Heidenhain plane arguments. public interface IHeidenhainPlaneArg : ITiltPlaneNcArg Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties SpatialABC_rad Gets the spatial rotation angles (A, B, C) in radians. Vec3d SpatialABC_rad { get; } Property Value Vec3d"
  },
  "api/Hi.Numerical.NcArgs.ITiltPlaneNcArg.html": {
    "href": "api/Hi.Numerical.NcArgs.ITiltPlaneNcArg.html",
    "title": "Interface ITiltPlaneNcArg | HiAPI-C# 2025",
    "summary": "Interface ITiltPlaneNcArg Namespace Hi.Numerical.NcArgs Assembly HiUniNc.dll Interface of Tilt plane NC Arg. i.e. Group16 and Heidenhain Plane argument. public interface ITiltPlaneNcArg Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.Numerical.NcArgs.NcArgCycle800.html": {
    "href": "api/Hi.Numerical.NcArgs.NcArgCycle800.html",
    "title": "Class NcArgCycle800 | HiAPI-C# 2025",
    "summary": "Class NcArgCycle800 Namespace Hi.Numerical.NcArgs Assembly HiUniNc.dll Represents parameters for Siemens CYCLE800 (Plane Tilting / Swivel). public class NcArgCycle800 : ITiltPlaneNcArg Inheritance object NcArgCycle800 Implements ITiltPlaneNcArg Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks CYCLE800 is used for 5-axis machining to define tilted working planes. The MODE parameter controls how angles A, B, C are interpreted. Properties A First rotation angle in degrees. Interpretation depends on MODE: Solid angle mode: Rotation about Z axis in XY plane Axial mode: Rotation of first rotary axis (typically A) public double A { get; set; } Property Value double AxisForA Gets the rotation axis for parameter A from bits 1-0. 01=X, 10=Y, 11=Z (00 is invalid/not used) public int AxisForA { get; } Property Value int AxisForB Gets the rotation axis for parameter B from bits 3-2. 01=X, 10=Y, 11=Z (00 is invalid/not used) public int AxisForB { get; } Property Value int AxisForC Gets the rotation axis for parameter C from bits 5-4. 01=X, 10=Y, 11=Z (00 is invalid/not used) public int AxisForC { get; } Property Value int B Second rotation angle in degrees. Interpretation depends on MODE: Solid angle mode: Rotation about Y axis in space Axial mode: Rotation of second rotary axis (typically B) public double B { get; set; } Property Value double C Third rotation angle in degrees. Interpretation depends on MODE: Axial mode: Rotation of third rotary axis (typically C) public double C { get; set; } Property Value double DIR Direction of rotation for positioning the rotary axes. public int DIR { get; set; } Property Value int FR Retract mode. Values: 0: No retraction 1: Retract Z axis (default) 2: Retract Z, X, Y axes 4: Maximum retraction in tool direction 5: Incremental retraction in tool direction public int FR { get; set; } Property Value int FR_I Value of incremental retraction in tool direction. public double FR_I { get; set; } Property Value double IsAxisByAxisMode Gets whether this is Axis by Axis mode (bits 7-6 = 00). public bool IsAxisByAxisMode { get; } Property Value bool IsDirectRotaryAxisMode Gets whether this is Direct Rotary Axis mode (bits 7-6 = 11). public bool IsDirectRotaryAxisMode { get; } Property Value bool IsProjectionAngleMode Gets whether this is Projection Angle mode (bits 7-6 = 10). public bool IsProjectionAngleMode { get; } Property Value bool IsSolidAngleMode Gets whether this is Solid Angle mode (bits 7-6 = 01). public bool IsSolidAngleMode { get; } Property Value bool MODE Swivel mode - controls angle interpretation. Binary coded decimal parameter: Bit 0 (1): 0=new, 1=additive Bit 1 (2): Reserved Bit 2 (4): Reserved Bit 3 (8): 0=solid angles (Euler), 1=RPY angles Bit 4 (16): 0=direct, 1=indirect Bit 5 (32): 0=XYZ rotation sequence, 1=ZYX rotation sequence Bit 6 (64): 0=angle refers to rotary axis, 1=angle refers to workpiece public int MODE { get; set; } Property Value int ST Swivel plane mode. UNITS DIGIT: 0: New (absolute) 1: Additive (relative to current) public int ST { get; set; } Property Value int SwivelModeType Gets the swivel mode type from bits 7-6. 00 = Axis by Axis, 01 = Solid Angle, 10 = Projection Angle, 11 = Direct Rotary Axis public int SwivelModeType { get; } Property Value int TC Name of swivel data record. “0” = Deselection of data record (cancels swivel) public string TC { get; set; } Property Value string XYZ0 Reference point prior to rotation (absolute coordinates). public Vec3d XYZ0 { get; set; } Property Value Vec3d XYZ1 Zero point offset after rotation. public Vec3d XYZ1 { get; set; } Property Value Vec3d Methods GetTableToFeatureMat4d() Gets the transformation matrix for this CYCLE800 swivel. public Mat4d GetTableToFeatureMat4d() Returns Mat4d The 4x4 transformation matrix from base to tilted coordinate system. ToString() Returns a string representation of this CYCLE800 argument. public override string ToString() Returns string"
  },
  "api/Hi.Numerical.NcArgs.NcArgG68.html": {
    "href": "api/Hi.Numerical.NcArgs.NcArgG68.html",
    "title": "Class NcArgG68 | HiAPI-C# 2025",
    "summary": "Class NcArgG68 Namespace Hi.Numerical.NcArgs Assembly HiUniNc.dll Represents arguments for G68 coordinate rotation command. public class NcArgG68 : ITiltPlaneNcArg Inheritance object NcArgG68 Implements ITiltPlaneNcArg Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NcArgG68(Vec3d, Vec3d, double) Ctor. public NcArgG68(Vec3d rotationCenter, Vec3d IJK, double R) Parameters rotationCenter Vec3d IJK Vec3d R double Properties IJK Direction of the axis of rotation. public Vec3d IJK { get; set; } Property Value Vec3d Remarks in most case that cnc engineer made, ijk is zero. the cnc engineer used to use G17,G18,G19. R Angular displacement. public double R { get; set; } Property Value double RotationCenter Center of rotation on the X, Y, and Z axis or parallel axes. On NC coordinate. NC: the absolute program coordinate without tool height and radius compensation. public Vec3d RotationCenter { get; set; } Property Value Vec3d Methods GetTransformation(NcGroup02) Apply IJK first if ijk not all nan. public Mat4d GetTransformation(NcGroup02 group02) Parameters group02 NcGroup02 Returns Mat4d"
  },
  "api/Hi.Numerical.NcArgs.NcArgG68p2.html": {
    "href": "api/Hi.Numerical.NcArgs.NcArgG68p2.html",
    "title": "Class NcArgG68p2 | HiAPI-C# 2025",
    "summary": "Class NcArgG68p2 Namespace Hi.Numerical.NcArgs Assembly HiUniNc.dll Represents arguments for G68.2 three-dimensional coordinate conversion command. public class NcArgG68p2 : ITiltPlaneNcArg Inheritance object NcArgG68p2 Implements ITiltPlaneNcArg Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties FeatureCoordinateOrigin by FANUC document: When specification is omitted, the X, Y, and Z of the basic three axes are assumed to be 0. On NC coordinate. NC: the absolute program coordinate without tool height and radius compensation. public Vec3d FeatureCoordinateOrigin { get; set; } Property Value Vec3d Ijk IJK follow zxz transformation on default. The IJK is the angle in degree. public Vec3d Ijk { get; set; } Property Value Vec3d PostMcAbc_rad The ABC flags have not been found on controller's document. However, in xxxx20180926, xxxxxxxxxxxxxxxxxN10.EIA contains the code like: G98 G81 X0.0 Y9.652 Z279.075 C20. R295.075 F72. public Vec3d PostMcAbc_rad { get; set; } Property Value Vec3d Methods GetTransformation(IMachineKinematics, out Mat4d) Gets transformation matrix from table to feature. public bool GetTransformation(IMachineKinematics coordinateConverter, out Mat4d tableToFeatureTransform) Parameters coordinateConverter IMachineKinematics The coordinate converter instance. tableToFeatureTransform Mat4d The resulting transformation matrix from table to feature coordinate system. Returns bool True if transformation was successful; otherwise, false."
  },
  "api/Hi.Numerical.NcArgs.NcArgSiemensFrame.html": {
    "href": "api/Hi.Numerical.NcArgs.NcArgSiemensFrame.html",
    "title": "Class NcArgSiemensFrame | HiAPI-C# 2025",
    "summary": "Class NcArgSiemensFrame Namespace Hi.Numerical.NcArgs Assembly HiUniNc.dll Represents Siemens frame transformation (AROT/ROT/TRANS/ATRANS). Similar to Heidenhain PLANE SPATIAL or FANUC G68. public class NcArgSiemensFrame : ITiltPlaneNcArg Inheritance object NcArgSiemensFrame Implements ITiltPlaneNcArg Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks All transformations (rotation and translation) are composed into a single matrix in the order they appear in NC code. e.g., AROT X-90. then TRANS X10 means: first rotate, then translate in rotated frame. This is different from separating rotation and translation. Properties TableToFeatureCdnTransformMat4d Gets or sets the accumulated transformation matrix. All operations (AROT, ROT, TRANS, ATRANS) are composed in sequence. public Mat4d TableToFeatureCdnTransformMat4d { get; set; } Property Value Mat4d Methods AddRotation(double, double, double) Add rotation (for AROT command - additive). Composes rotation with existing transformation in sequence. public void AddRotation(double rotX_rad, double rotY_rad, double rotZ_rad) Parameters rotX_rad double Rotation around X axis in radians rotY_rad double Rotation around Y axis in radians rotZ_rad double Rotation around Z axis in radians AddTranslation(double, double, double) Add translation (for ATRANS command - additive). Composes translation with existing transformation in sequence. Translation is applied in the current (possibly rotated) coordinate frame. public void AddTranslation(double x, double y, double z) Parameters x double y double z double GetTransformation() Gets the full transformation matrix. public Mat4d GetTransformation() Returns Mat4d Reset() Reset frame to identity (no transformation). public void Reset() SetRotation(double, double, double) Set rotation (for ROT command - resets all transformations and sets rotation). public void SetRotation(double rotX_rad, double rotY_rad, double rotZ_rad) Parameters rotX_rad double Rotation around X axis in radians rotY_rad double Rotation around Y axis in radians rotZ_rad double Rotation around Z axis in radians SetTranslation(double, double, double) Set translation (for TRANS command - resets all transformations and sets translation). public void SetTranslation(double x, double y, double z) Parameters x double y double z double ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.NcArgs.PausingNcArg.html": {
    "href": "api/Hi.Numerical.NcArgs.PausingNcArg.html",
    "title": "Class PausingNcArg | HiAPI-C# 2025",
    "summary": "Class PausingNcArg Namespace Hi.Numerical.NcArgs Assembly HiUniNc.dll Pausing, i.e. G04, parameters for HardNcLine. public class PausingNcArg Inheritance object PausingNcArg Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties P Entered pause time in milli-seconds. Note that in fanuc, the behavior may be altered by configuration. public double P { get; set; } Property Value double S Entered pause time in seconds. public double S { get; set; } Property Value double TotalPauseTime G04 total pausing time. public TimeSpan TotalPauseTime { get; } Property Value TimeSpan X Entered pause time in seconds. Fanuc. Note that in fanuc, the behavior may be altered by configuration. public double X { get; set; } Property Value double"
  },
  "api/Hi.Numerical.NcArgs.html": {
    "href": "api/Hi.Numerical.NcArgs.html",
    "title": "Namespace Hi.Numerical.NcArgs | HiAPI-C# 2025",
    "summary": "Namespace Hi.Numerical.NcArgs Classes ArcNcArg Arc parameters for HardNcLine. Arc comes from G02,G03. G28Arg Represents arguments for the G28 command (Return to Reference Point). Group07NcArg parameters of NcGroup07. Radius compensation. Group09NcArg NC Argument of NC Group09. HeidenhainCycleDef7Arg Argument of Heidenhain CYCL DEF 7. Datum Shift. HeidenhainPlaneSpatialArg Represents a Heidenhain spatial plane defined by rotation angles. NcArgCycle800 Represents parameters for Siemens CYCLE800 (Plane Tilting / Swivel). NcArgG68 Represents arguments for G68 coordinate rotation command. NcArgG68p2 Represents arguments for G68.2 three-dimensional coordinate conversion command. NcArgSiemensFrame Represents Siemens frame transformation (AROT/ROT/TRANS/ATRANS). Similar to Heidenhain PLANE SPATIAL or FANUC G68. PausingNcArg Pausing, i.e. G04, parameters for HardNcLine. Interfaces IHeidenhainBlockCacheArg Interface for Heidenhain block cache arguments. IHeidenhainPlaneArg Interface for Heidenhain plane arguments. ITiltPlaneNcArg Interface of Tilt plane NC Arg. i.e. Group16 and Heidenhain Plane argument."
  },
  "api/Hi.Numerical.NcFlag.html": {
    "href": "api/Hi.Numerical.NcFlag.html",
    "title": "Enum NcFlag | HiAPI-C# 2025",
    "summary": "Enum NcFlag Namespace Hi.Numerical Assembly HiUniNc.dll NC Flag. public enum NcFlag Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) NcFlagUtil.GetNcLifeCycleMode(NcFlag) NcFlagUtil.GetNcName(NcFlag) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields [NcLifeCycle(NcLifeCycleMode.Modal)] Cooling = 79 Cooling enabled. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup01))] G00 = 0 Group01. Rapid move. Although fanuc document says that G00 is an one shot command, (I think it may send warning if use G0 as modal.) set it to modal may fit other CNC controller and is much conservative from collision. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup01))] G01 = 1 Group01. Move by feedrate. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup01))] G02 = 2 Group01. Move in CW arc. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup01))] G03 = 3 Group01. Move in CCW arc. [NcLifeCycle(NcLifeCycleMode.OneShot)] [NcGroup(typeof(NcGroup00))] G04 = 6 Group00. Dwell. [NcLifeCycle(NcLifeCycleMode.OneShot)] G10p9 = 7 Not standard code. For Mazak NC. Generally not supported. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup21))] [NcName(\"G12.1\")] G12p1 = 8 Group21. Polar coordinate interpolation mode ON. Use G13p1 to turn off polar coordinate interpolation mode. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup21))] [NcName(\"G13.1\")] G13p1 = 9 Group21. Polar coordinate interpolation mode OFF. Use G12p1 to turn on polar coordinate interpolation mode. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup02))] G17 = 10 Group02. XY plane selection. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup02))] G18 = 11 Group02. ZX plane selection. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup02))] G19 = 12 Group02. YZ plane selection. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup06))] G20 = 13 Group06. Input in inch. For Fanuc specification A,B. RS274D specification is G70. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup06))] G21 = 14 Group06. Input in mm. For Fanuc specification A,B. RS274D specification is G71. [NcLifeCycle(NcLifeCycleMode.OneShot)] [NcGroup(typeof(NcGroup01))] G28 = 15 Group01. Automatic reference position return. Positioning to the intermediate or reference positions are performed at the rapid traverse rate of each axis. Therefore, for safety, the compensation functions, such as the tool radius compensation and tool length compensation, should be cancelled before executing this command. The coordinates for the intermediate position are stored in the CNC for the axes for which a value is specified in a G28 block. For the other axes, the previously specified coordinates are used. G28 Fanuc parameters Nos. 1240 to 1243. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup07))] G40 = 16 Group07. Cancel radius compensation. See G41 and G42 for left and right compensation. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup07))] G41 = 17 Group07. Tool radius/tool nose radius compensation. Left compensation: the updated tool tip location is at +y direction compensation from tool running direction. See G40 to cancel compensation and G42 for right compensation. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup07))] G42 = 18 Group07. Tool radius/tool nose radius compensation. Right compensation: the updated tool tip location is at -y direction compensation from tool running direction. See G40 to cancel compensation and G41 for left compensation. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup08))] G43 = 19 Group08 Positive height compensation. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup08))] [NcName(\"G43.4\")] G43p4 = 20 Group08 G43.4: start RTCP (Rotational Tool Center Point). [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup08))] G44 = 21 Group08 Negative height compensation. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup08))] G49 = 22 Group08. Cancel height compensation. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup00))] G52 = 27 Group00. Local coordinate system setting. It can be cancelled by G52X0Y0Z0 or M30. [NcLifeCycle(NcLifeCycleMode.OneShot)] [NcGroup(typeof(NcGroup00))] G53 = 28 Group00. Machine coordinate system setting. When an incremental command is specified, the G53 command is ignored. [NcLifeCycle(NcLifeCycleMode.OneShot)] [NcName(\"G53P1\")] G53WithP1Flag = 29 Enables the high-speed G53 function. P1 flag accompanies with G53. [NcLifeCycle(NcLifeCycleMode.OneShot)] [NcGroup(typeof(NcGroup00))] [NcName(\"G53.1\")] G53p1 = 32 Group00. Tool axis direction control. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup14))] G54Series = 34 Group14. Coordinate settings. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup15))] G60 = 35 Group15. Siemens: Exact stop / positioning mode. Machine decelerates to complete stop at each programmed point. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup15))] G61 = 36 Group15. Exact stop mode. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup15))] G62 = 37 Group15. Automatic corner override. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup15))] G63 = 38 Group15. Tapping mode. Not support. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup15))] G64 = 39 Group15. Cutting mode. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup16))] G68 = 44 Group16. 3-dimensional coordinate system conversion. run a pattern of operations in a rotated angle. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup16))] [NcName(\"G68.2\")] G68p2 = 45 Group16. Tilted working plane command. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup16))] G69 = 46 Group16. Coordinate system rotation cancel or 3-dimensional coordinate conversion mode off [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup06))] G70 = 48 Group06. Input in inch. Fanuc system C specification. Syntec specification. For RS274D specification. Fanuc system A,B specification is G20. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup06))] G71 = 49 Group06. Input in mm. Fanuc system C specification. Syntec specification. For RS274D specification. Fanuc system A,B specification is G21. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup09))] G80 = 50 Group09. Canned cycle cancel. Electronic gear box : synchronization cancellation. See G81, G82, G83, G85, G86 for available canned cycles. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup09))] G81 = 51 Group09. Drilling cycle or spot boring cycle. Electronic gear box : synchronization start. The same parsing behavior group: G81,G85,G86. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup09))] G82 = 52 Group09. Drilling cycle or spot boring cycle with bottom staying time. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup09))] G83 = 53 Group09. Drilling cycle or spot boring cycle. drilling cycle in form of pecking. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup09))] G85 = 54 Group09. Drilling cycle or spot boring cycle. Electronic gear box : synchronization start. The same parsing behavior group: G81,G85,G86. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup09))] G86 = 55 Group09. Drilling cycle or spot boring cycle. Electronic gear box : synchronization start. The same parsing behavior group: G81,G85,G86. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup03))] G90 = 56 Group03. Absolute coordinate system. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup03))] G91 = 57 Group03. Relative coordinate system. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup05))] G94 = 58 Group05. Use F as mm/min. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup13))] G96 = 59 Group13. Constant surface speed control cancel. not support. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup13))] G97 = 60 Group13. Constant surface speed control cancel. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup10))] G98 = 61 Group10. Canned cycle : return to initial level. See G99 for R point level return. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup10))] G99 = 62 Group10. Canned cycle : return to R point level. See G98 for initial level return. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup14))] [NcName(\"DATUM\")] HeidenhainDatum = 43 Group14. Heidenhain flag. Coordinate settings for CYCL DEF 7 and CYCL DEF 247. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcName(\"FMAX\")] HeidenhainFMax = 63 Heidenhain flag. Flag Name ‘FMAX’. [NcLifeCycle(NcLifeCycleMode.OneShot)] [NcGroup(typeof(NcGroup01))] [NcName(\"L\")] HeidenhainL = 4 Group01. Heidenhain flag. Straight linear motion. [NcLifeCycle(NcLifeCycleMode.OneShot)] [NcGroup(typeof(NcGroup01))] [NcName(\"LN\")] HeidenhainLN = 5 Group01. Heidenhain flag. Nonlinear motion. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroupHeidenhainM107M108))] [NcName(\"M107\")] HeidenhainM107 = 86 Heidenhain flag. Enable Suppress error message for replacement tools with oversize. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroupHeidenhainM107M108))] [NcName(\"M108\")] HeidenhainM108 = 87 Heidenhain flag. Reset M107. disable Suppress error message for replacement tools with oversize. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroupHeidenhainShortestRotaryPath))] [NcName(\"M126\")] HeidenhainM126 = 88 NcGroup.HeidenhainShortestRotaryPath. Heidenhain flag. Shortest rotation for commands of ABC axise. The M126 will be canceled automatically at the end of the program. For Heidenhain. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroupHeidenhainShortestRotaryPath))] [NcName(\"M127\")] HeidenhainM127 = 89 NcGroup.HeidenhainShortestRotaryPath. Heidenhain flag. Cancel HeidenhainM126, i.e. disable shortest rotation for ABC axises. For Heidenhain. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup08))] [NcName(\"M128\")] HeidenhainM128 = 25 Group08. Heidenhain flag. M128: start RTCP (Rotational Tool Center Point). [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup08))] [NcName(\"M129\")] HeidenhainM129 = 26 Group08. Heidenhain flag. M129: cancel RTCP (Rotational Tool Center Point). [NcLifeCycle(NcLifeCycleMode.OneShot)] [NcName(\"M140\")] HeidenhainM140 = 90 From TNC640 documentation: Retraction from the contour in the tool-axis direction: M140. If you do not enter a feed rate, the TNC moves the tool along the entered path at rapid traverse. M140 is also effective if the tilted-working-plane function is active. On machines with swivel heads, the TNC then moves the tool in the tilted coordinate system. With M140 MB MAX you can only retract in the positive direction. Always define a TOOL CALL with a tool axis before entering M140, otherwise the direction of traverse is not defined. [NcLifeCycle(NcLifeCycleMode.OneShot)] [NcName(\"M140\")] HeidenhainM140InitiativeF = 91 Feedrate on HeidenhainM140. The TNC640 documentation does not show that the Feedrate on M140 is one shot or modal. HiNC assumes Feedrate on M140 is one shot feedrate with M140 command. [NcLifeCycle(NcLifeCycleMode.OneShot)] [NcName(\"M91\")] HeidenhainM91 = 85 Heidenhain flag. If you want the coordinates in a positioning block to be referenced to the machine datum, end the block with M91. [NcLifeCycle(NcLifeCycleMode.OneShot)] [NcName(\"MOVE\")] HeidenhainMove = 84 Heidenhain flag. MOVE indicates to position the rotary axes and simultaneously compensate position. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroupHeidenhainPlane))] [NcName(\"PLANE RESET\")] HeidenhainPlaneReset = 80 Heidenhain Plane command is exclusive [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroupHeidenhainPlane))] [NcName(\"PLANE SPATIAL\")] HeidenhainPlaneSpatial = 81 Heidenhain Plane command is exclusive [NcLifeCycle(NcLifeCycleMode.OneShot)] [NcName(\"STAY\")] HeidenhainStay = 82 Heidenhain flag. STAY indicates to maintain the current rotary axis positioning. [NcLifeCycle(NcLifeCycleMode.OneShot)] [NcName(\"TOOL CALL\")] HeidenhainToolCall = 68 Heidenhain flag. Tool call. Flag Name ‘TOOL CALL’. [NcLifeCycle(NcLifeCycleMode.OneShot)] [NcName(\"TOOL DEF\")] HeidenhainToolDef = 69 Heidenhain flag. tool definition. Flag Name ‘TOOL DEF’. [NcLifeCycle(NcLifeCycleMode.OneShot)] [NcName(\"TURN\")] HeidenhainTurn = 83 Heidenhain flag. TURN indicates to automatically position the rotary axes. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup14))] [NcName(\"CYCL DEF 247\")] Heidenhain_CYCL_DEF_247 = 41 Group14. Heidenhain flag. With the DATUM SETTING cycle you can activate as the new datum a preset defined in a preset table. After a DATUM SETTING cycle definition, all of the coordinate inputs and datum shifts(absolute and incremental) are referenced to the new preset. When activating a datum from the preset table, the TNC resets the datum shift, mirroring, rotation, scaling factor and axis-specific scaling factor. If you activate preset number 0 (line 0), then you activate the datum that you last set in the Manual Operation or El. Handwheel operating mode. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup14))] [NcName(\"CYCL DEF 7\")] Heidenhain_CYCL_DEF_7 = 40 Group14. Heidenhain flag. For shifting contours directly within the program or from datum tables. [NcLifeCycle(NcLifeCycleMode.Modal)] M02 = 70 Program end. [NcLifeCycle(NcLifeCycleMode.OneShot)] M03 = 64 Activate spindle rotation in CW. [NcLifeCycle(NcLifeCycleMode.OneShot)] M04 = 65 Activate spindle rotation in CCW. [NcLifeCycle(NcLifeCycleMode.OneShot)] M05 = 66 deactivate spindle rotation. [NcLifeCycle(NcLifeCycleMode.OneShot)] M06 = 67 Tool changed. [NcLifeCycle(NcLifeCycleMode.OneShot)] M08 = 71 Start cooling. [NcLifeCycle(NcLifeCycleMode.OneShot)] M09 = 72 Stop cooling. [NcLifeCycle(NcLifeCycleMode.OneShot)] M13 = 73 Spindle CW & Coolant ON. [NcLifeCycle(NcLifeCycleMode.OneShot)] M14 = 74 Spindle CCW & Coolant ON [NcLifeCycle(NcLifeCycleMode.Modal)] M30 = 75 Program end. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup16))] [NcName(\"CYCLE800\")] SiemensCycle800 = 47 Group16. Siemens flag. Tilted working plane command. CYCLE800() cancels the previous transformation. [NcLifeCycle(NcLifeCycleMode.OneShot)] [NcGroup(typeof(NcGroup00))] [NcName(\"CYCLE800_SWIVEL\")] SiemensCycle800Swivel = 33 Group00. Siemens CYCLE800 swivel motion - rotary axis positioning with RTCP. Similar to G53.1 but specific to CYCLE800 behavior. Includes: rotary axis motion + tool center point management. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup14))] [NcName(\"G500\")] SiemensG500 = 42 Group14. Siemens command. Deactivation of the current settable zero offset. G500指令在没有赋值的时候为机床坐标系，可以把机床从工件坐标系转换到机床坐标系 [NcLifeCycle(NcLifeCycleMode.Modal)] [NcName(\"MCALL\")] SiemensMcall = 31 Siemens flag. Modal call active - drilling cycle executes on subsequent positioning lines. When MCALL CYCLE81/82/83 is called, the cycle parameters are stored but drilling doesn't execute until the next positioning command. Cancelled by MCALL without parameters. [NcLifeCycle(NcLifeCycleMode.OneShot)] [NcName(\"SUPA\")] SiemensSupa = 30 Group00. Siemens command. G53: G53 suppresses the settable zero offset and the programmable zero offset non-modally. G153: G153 has the same effect as G53 and also suppresses the entire basic frame. SUPA: SUPA has the same effect as G153 and also suppresses: Handwheel offsets (DRF) Overlaid movements External zero offset PRESET offset [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup08))] [NcName(\"TRAFOOF\")] SiemensTrafoof = 23 Group08. Siemens flag. Disable RTCP (Rotational Tool Center Point) (=Tool Center Point Management, TCPM). [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroup08))] [NcName(\"TRAORI\")] SiemensTraori = 24 Group08. Siemens flag. Enable RTCP (Rotational Tool Center Point) (=Tool Center Point Management, TCPM). [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroupSpindleRotation))] SpindleCcw = 78 NcGroupSpindleRotation. Rotate spindle counter-clockwise (CCW). See SpindleStop to stop rotation and SpindleCw for clockwise rotation. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroupSpindleRotation))] SpindleCw = 77 NcGroupSpindleRotation. Rotate spindle clockwise (CW). See SpindleStop to stop rotation and SpindleCcw for counter-clockwise rotation. [NcLifeCycle(NcLifeCycleMode.Modal)] [NcGroup(typeof(NcGroupSpindleRotation))] SpindleStop = 76 NcGroupSpindleRotation. Stop spindle rotation. See SpindleCw and SpindleCcw for clockwise and counter-clockwise rotation."
  },
  "api/Hi.Numerical.NcFlagUtil.html": {
    "href": "api/Hi.Numerical.NcFlagUtil.html",
    "title": "Class NcFlagUtil | HiAPI-C# 2025",
    "summary": "Class NcFlagUtil Namespace Hi.Numerical Assembly HiUniNc.dll Utility class for working with NC flags and their lifecycle modes. public static class NcFlagUtil Inheritance object NcFlagUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetCompensationHeight(BitArray, int, MillingToolOffsetTable, CncBrand, IProgress<IMessage>) Gets the tool height compensation value based on the NC flags and CNC brand. public static double GetCompensationHeight(this BitArray ncFlagBitArray, int H, MillingToolOffsetTable millingToolOffsetTable, CncBrand cncBrand, IProgress<IMessage> mixedProgress) Parameters ncFlagBitArray BitArray NC flag bit array H int Height offset index millingToolOffsetTable MillingToolOffsetTable Tool offset table cncBrand CncBrand CNC brand mixedProgress IProgress<IMessage> Message host for warnings Returns double Height compensation value GetCompensationRadius(BitArray, int, MillingToolOffsetTable, CncBrand, IProgress<IMessage>) Gets the tool radius compensation value from the flag bit array and tool offset table. public static double GetCompensationRadius(this BitArray ncFlagBitArray, int D, MillingToolOffsetTable millingToolOffsetTable, CncBrand cncBrand, IProgress<IMessage> mixedProgress) Parameters ncFlagBitArray BitArray The bit array of NC flags. D int The tool diameter offset number. millingToolOffsetTable MillingToolOffsetTable The milling tool offset table. cncBrand CncBrand The CNC controller brand. mixedProgress IProgress<IMessage> The message host for reporting warnings or errors. Returns double The compensation radius value. GetCoordinateOffset(bool, string, int, HeidenhainCycleDef7Arg, HardNcEnv) Gets the coordinate offset based on the CNC controller and coordinate settings. public static Vec3d GetCoordinateOffset(bool hasSiemensG500, string isoCoordinateId, int heidenhainCycleDef247Q339, HeidenhainCycleDef7Arg heidenhainCycleDef7Arg, HardNcEnv ncEnv) Parameters hasSiemensG500 bool Whether Siemens G500 is active. isoCoordinateId string The ISO coordinate ID. heidenhainCycleDef247Q339 int The Heidenhain cycle def 247 Q339 value. heidenhainCycleDef7Arg HeidenhainCycleDef7Arg The Heidenhain cycle def 7 arguments. ncEnv HardNcEnv The NC environment. Returns Vec3d The coordinate offset vector. GetFlags(NcLifeCycleMode) Gets all NC flags for a specific lifecycle mode. public static NcFlag[] GetFlags(this NcLifeCycleMode ncLifeCycleMode) Parameters ncLifeCycleMode NcLifeCycleMode The lifecycle mode to get flags for. Returns NcFlag[] An array of NC flags for the specified lifecycle mode. GetHeidenhainCoordinateOffset(int, HeidenhainCycleDef7Arg, HardNcEnv) Gets the coordinate offset for Heidenhain controllers. public static Vec3d GetHeidenhainCoordinateOffset(int heidenhainCycleDef247Q339, HeidenhainCycleDef7Arg heidenhainCycleDef7Arg, HardNcEnv ncEnv) Parameters heidenhainCycleDef247Q339 int The preset number for CYCL DEF 247. heidenhainCycleDef7Arg HeidenhainCycleDef7Arg The argument for CYCL DEF 7. ncEnv HardNcEnv The NC environment. Returns Vec3d The calculated coordinate offset. GetModalNcFlag<T>(BitArray) Gets the modal NC flag of the specified type from the bit array. public static T GetModalNcFlag<T>(this BitArray ncFlagBitArray) where T : Enum Parameters ncFlagBitArray BitArray The bit array of NC flags. Returns T The modal NC flag of the specified type. Type Parameters T The enum type of the modal flag. GetNcFlag<T>(BitArray) Gets the NC flag of the specified type from the bit array. public static T GetNcFlag<T>(this BitArray ncFlagBitArray) Parameters ncFlagBitArray BitArray The bit array of NC flags. Returns T The NC flag of the specified type. Type Parameters T The enum type of the NC flag. GetNcFlags(BitArray) Gets all active NC flags from the bit array. public static IEnumerable<NcFlag> GetNcFlags(this BitArray ncFlagBitArray) Parameters ncFlagBitArray BitArray The bit array of NC flags. Returns IEnumerable<NcFlag> An enumerable collection of active NC flags. GetNcFromSyntax<TVec>(NcGroup03, TVec, TVec) Converts syntactic coordinates to NC coordinates based on the positioning mode. public static TVec GetNcFromSyntax<TVec>(this NcGroup03 group03Flag, TVec syntexPosition, TVec preProgramPosition) where TVec : IVec<double>, new() Parameters group03Flag NcGroup03 The positioning mode flag syntexPosition TVec Syntactic position from the input preProgramPosition TVec Previous program position Returns TVec Converted NC coordinates Type Parameters TVec Vector type implementing IVec interface GetNcFromSyntax<TVec>(NcGroup03, TVec, TVec, int, Func<int, TVec, double>, Action<int, TVec, double>) Converts syntactic position to NC position based on the positioning mode (absolute or incremental). public static TVec GetNcFromSyntax<TVec>(this NcGroup03 group03Flag, TVec syntexPosition, TVec preProgramPosition, int vecSize, Func<int, TVec, double> getter, Action<int, TVec, double> setter) where TVec : new() Parameters group03Flag NcGroup03 The positioning mode flag syntexPosition TVec Syntactic position from the input preProgramPosition TVec Previous program position vecSize int Size of the vector getter Func<int, TVec, double> Function to get value at specified index setter Action<int, TVec, double> Function to set value at specified index Returns TVec Converted NC coordinates Type Parameters TVec Vector type Exceptions InternalException Thrown when group03Flag is not managed GetNcGroupType(NcFlag) Gets the NC group type for the specified NC flag. public static Type GetNcGroupType(NcFlag ncFlag) Parameters ncFlag NcFlag The NC flag to get the group type for. Returns Type The NC group type or null if not found. GetNcLifeCycleMode(NcFlag) Gets the lifecycle mode of the specified NC flag. public static NcLifeCycleMode GetNcLifeCycleMode(this NcFlag flag) Parameters flag NcFlag The NC flag to check. Returns NcLifeCycleMode The lifecycle mode of the flag. GetNcName(NcFlag) Gets the display name of an NC flag. public static string GetNcName(this NcFlag flag) Parameters flag NcFlag The NC flag to get the name of. Returns string The display name of the NC flag. GetNcXyzFromSyntax(NcGroup03, Vec3d, Vec3d) Converts syntactic XYZ coordinates to NC XYZ coordinates based on the positioning mode. public static Vec3d GetNcXyzFromSyntax(this NcGroup03 group03Flag, Vec3d syntexXyz, Vec3d preNcXyz) Parameters group03Flag NcGroup03 The Group03 flag specifying the positioning mode. syntexXyz Vec3d The syntactic XYZ coordinates to convert. preNcXyz Vec3d The previous NC XYZ coordinates, used for incremental positioning. Returns Vec3d The converted NC XYZ coordinates. GetNcXyzabcFromSyntax(NcGroup03, DVec3d, DVec3d) Gets NC XYZABC coordinates from syntactic coordinates based on the positioning mode. public static DVec3d GetNcXyzabcFromSyntax(this NcGroup03 group03Flag, DVec3d syntexXyzabc, DVec3d preNcXyzabc) Parameters group03Flag NcGroup03 The positioning mode flag (G90 or G91). syntexXyzabc DVec3d The syntactic XYZABC coordinates. preNcXyzabc DVec3d The previous NC XYZABC coordinates. Returns DVec3d The calculated NC XYZABC coordinates. GetPlaneDir(NcGroup02) Gets the direction index of the selected plane. public static int GetPlaneDir(this NcGroup02 ncFlag) Parameters ncFlag NcGroup02 The NC plane selection flag (G17, G18, or G19). Returns int The direction index (0=X, 1=Y, 2=Z). GetPlaneNormal(NcGroup02) Gets the normal vector of the selected plane. public static Vec3d GetPlaneNormal(this NcGroup02 ncFlag) Parameters ncFlag NcGroup02 The NC plane selection flag (G17, G18, or G19). Returns Vec3d The normal vector of the plane. GetTiltMat4d(BitArray, ITiltPlaneNcArg, NcGroup02, IMachineKinematics, out bool?) public static Mat4d GetTiltMat4d(this BitArray ncFlagBitArray, ITiltPlaneNcArg ncArgGroup16, NcGroup02 ncGroup02flagForG68, IMachineKinematics coordinateConverterForG68p2, out bool? isG68p2Successed) Parameters ncFlagBitArray BitArray ncArgGroup16 ITiltPlaneNcArg ncGroup02flagForG68 NcGroup02 coordinateConverterForG68p2 IMachineKinematics isG68p2Successed bool? Returns Mat4d GetValue(NcGroup03, double, double) public static double GetValue(this NcGroup03 group03Flag, double v, double preV) Parameters group03Flag NcGroup03 v double value preV double previous value Returns double HasModalFlag<T>(BitArray, out T) Checks if the bit array has a modal flag of the specified type and retrieves it. public static bool HasModalFlag<T>(this BitArray ncFlagBitArray, out T dst) where T : Enum Parameters ncFlagBitArray BitArray The bit array of NC flags. dst T When this method returns, contains the modal flag if found; otherwise, the default value. Returns bool True if a modal flag was found; otherwise, false. Type Parameters T The enum type of the modal flag. IsAbsolutePositioning(BitArray) Checks if the positioning mode is absolute (G90) rather than incremental (G91). public static bool IsAbsolutePositioning(this BitArray ncFlagBitArray) Parameters ncFlagBitArray BitArray The bit array of NC flags. Returns bool True if absolute positioning is active; otherwise, false. IsFlagActivated(BitArray, NcFlag) Determines whether a specific NC flag is activated in the flag bit array. public static bool IsFlagActivated(this BitArray ncFlagBitArray, NcFlag ncFlag) Parameters ncFlagBitArray BitArray The bit array of NC flags. ncFlag NcFlag The NC flag to check. Returns bool True if the flag is activated; otherwise, false. IsHeightCompensationEnabled(BitArray) Determines whether height compensation is enabled. public static bool IsHeightCompensationEnabled(this BitArray ncFlagBitArray) Parameters ncFlagBitArray BitArray The bit array of NC flags. Returns bool True if height compensation is enabled; otherwise, false. IsMacro(BitArray) Is macro such as drilling cycle, rapid home, tool center alignment. public static bool IsMacro(this BitArray ncFlagBitArray) Parameters ncFlagBitArray BitArray The bit array of NC flags. Returns bool Is macro mode IsOnArcCommand(BitArray) Determines whether an arc command is active. public static bool IsOnArcCommand(this BitArray ncFlagBitArray) Parameters ncFlagBitArray BitArray The bit array of NC flags. Returns bool True if an arc command is active; otherwise, false. IsOnSimpleMachiningMode(BitArray) Determines whether simple machining mode is active (linear or circular interpolation). public static bool IsOnSimpleMachiningMode(this BitArray ncFlagBitArray) Parameters ncFlagBitArray BitArray The bit array of NC flags. Returns bool True if simple machining mode is active; otherwise, false. IsRadiusCompensationEnabled(BitArray) Determines whether radius compensation is enabled. public static bool IsRadiusCompensationEnabled(this BitArray ncFlagBitArray) Parameters ncFlagBitArray BitArray The bit array of NC flags. Returns bool True if radius compensation is enabled; otherwise, false. IsRadiusOrHeightCompensationEnabled(BitArray) Determines whether radius or height compensation is enabled. public static bool IsRadiusOrHeightCompensationEnabled(this BitArray ncFlagBitArray) Parameters ncFlagBitArray BitArray The bit array of NC flags. Returns bool True if radius or height compensation is enabled; otherwise, false. IsRapid(BitArray) Determines whether rapid traverse mode is active. public static bool IsRapid(this BitArray ncFlagBitArray) Parameters ncFlagBitArray BitArray The bit array of NC flags. Returns bool True if rapid traverse is active; otherwise, false. IsToolCenterPointManagementEnabled(NcGroup08) obosoleted. use BitArray version instead. Is the flag enabled RTCP (Rotational Tool Center Point) (=Tool Center Point Management, TCPM). Check for NcGroup08. public static bool IsToolCenterPointManagementEnabled(this NcGroup08 flag) Parameters flag NcGroup08 Returns bool IsToolCenterPointManagementEnabled(BitArray) Is the flag enabled RTCP (Rotational Tool Center Point) (=Tool Center Point Management, TCPM). public static bool IsToolCenterPointManagementEnabled(this BitArray ncFlagBitArray) Parameters ncFlagBitArray BitArray Returns bool IsToolChanging(BitArray) Determines if a tool change operation is active in the NC flag bit array. public static bool IsToolChanging(this BitArray ncFlagBitArray) Parameters ncFlagBitArray BitArray The bit array of NC flags. Returns bool True if a tool change is active; otherwise, false. IsToolNormalTiltable(BitArray) Determines whether the tool normal is tiltable based on the flag bit array. public static bool IsToolNormalTiltable(this BitArray ncFlagBitArray) Parameters ncFlagBitArray BitArray The bit array of NC flags. Returns bool True if the tool normal is tiltable; otherwise, false. ModalExclusiveAssign(BitArray, NcFlag) Modal exclusive assign in the belonging NC Group. public static BitArray ModalExclusiveAssign(this BitArray ncFlagBitArray, NcFlag assigningNcFlag) Parameters ncFlagBitArray BitArray assigningNcFlag NcFlag Returns BitArray ModalExclusiveAssign<T>(BitArray, T) Modal exclusive assign in the belonging NC Group. public static BitArray ModalExclusiveAssign<T>(this BitArray ncFlagBitArray, T assigningNcGroupFlag) where T : struct, Enum Parameters ncFlagBitArray BitArray assigningNcGroupFlag T Returns BitArray Type Parameters T ResetOneShotFlag(BitArray) Resets all one-shot flags in the specified bit array. public static BitArray ResetOneShotFlag(this BitArray ncFlagBitArray) Parameters ncFlagBitArray BitArray The bit array of NC flags. Returns BitArray The modified bit array with one-shot flags reset. ToNcFlagString(BitArray) Converts the active NC flags in the bit array to a string representation. public static string ToNcFlagString(this BitArray ncFlagBitArray) Parameters ncFlagBitArray BitArray The bit array of NC flags. Returns string A string representation of the active NC flags."
  },
  "api/Hi.Numerical.NcGroup00.html": {
    "href": "api/Hi.Numerical.NcGroup00.html",
    "title": "Enum NcGroup00 | HiAPI-C# 2025",
    "summary": "Enum NcGroup00 Namespace Hi.Numerical Assembly HiUniNc.dll NcGroup enum. GCode Group00. Include G04,G52,G53,G53p1,SiemensCycle800Swivel,SiemensSupa. public enum NcGroup00 Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields G04 = 6 Group00. Dwell. G52 = 27 Group00. Local coordinate system setting. It can be cancelled by G52X0Y0Z0 or M30. G53 = 28 Group00. Machine coordinate system setting. When an incremental command is specified, the G53 command is ignored. G53p1 = 32 Group00. Tool axis direction control. SiemensCycle800Swivel = 33 Group00. Siemens CYCLE800 swivel motion - rotary axis positioning with RTCP. Similar to G53.1 but specific to CYCLE800 behavior. Includes: rotary axis motion + tool center point management."
  },
  "api/Hi.Numerical.NcGroup01.html": {
    "href": "api/Hi.Numerical.NcGroup01.html",
    "title": "Enum NcGroup01 | HiAPI-C# 2025",
    "summary": "Enum NcGroup01 Namespace Hi.Numerical Assembly HiUniNc.dll NcGroup enum. For linear move mode: G00 or G01. G00 is rapid move. G01 is linear cut. G02 is CW cut; G03 is CCW cut. public enum NcGroup01 Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields G00 = 0 Group01. Rapid move. Although fanuc document says that G00 is an one shot command, (I think it may send warning if use G0 as modal.) set it to modal may fit other CNC controller and is much conservative from collision. G01 = 1 Group01. Move by feedrate. G02 = 2 Group01. Move in CW arc. G03 = 3 Group01. Move in CCW arc. G28 = 15 Group01. Automatic reference position return. Positioning to the intermediate or reference positions are performed at the rapid traverse rate of each axis. Therefore, for safety, the compensation functions, such as the tool radius compensation and tool length compensation, should be cancelled before executing this command. The coordinates for the intermediate position are stored in the CNC for the axes for which a value is specified in a G28 block. For the other axes, the previously specified coordinates are used. G28 Fanuc parameters Nos. 1240 to 1243. HeidenhainL = 4 Group01. Heidenhain flag. Straight linear motion. HeidenhainLN = 5 Group01. Heidenhain flag. Nonlinear motion."
  },
  "api/Hi.Numerical.NcGroup02.html": {
    "href": "api/Hi.Numerical.NcGroup02.html",
    "title": "Enum NcGroup02 | HiAPI-C# 2025",
    "summary": "Enum NcGroup02 Namespace Hi.Numerical Assembly HiUniNc.dll NcGroup enum. Plane selection. Include G17,G18,G19. public enum NcGroup02 Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) NcFlagUtil.GetPlaneDir(NcGroup02) NcFlagUtil.GetPlaneNormal(NcGroup02) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields G17 = 10 Group02. XY plane selection. G18 = 11 Group02. ZX plane selection. G19 = 12 Group02. YZ plane selection."
  },
  "api/Hi.Numerical.NcGroup03.html": {
    "href": "api/Hi.Numerical.NcGroup03.html",
    "title": "Enum NcGroup03 | HiAPI-C# 2025",
    "summary": "Enum NcGroup03 Namespace Hi.Numerical Assembly HiUniNc.dll NcGroup enum. Absolute(G90) or increment(G91) coordinate. public enum NcGroup03 Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) NcFlagUtil.GetNcFromSyntax<TVec>(NcGroup03, TVec, TVec) NcFlagUtil.GetNcFromSyntax<TVec>(NcGroup03, TVec, TVec, int, Func<int, TVec, double>, Action<int, TVec, double>) NcFlagUtil.GetNcXyzFromSyntax(NcGroup03, Vec3d, Vec3d) NcFlagUtil.GetNcXyzabcFromSyntax(NcGroup03, DVec3d, DVec3d) NcFlagUtil.GetValue(NcGroup03, double, double) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields G90 = 56 Group03. Absolute coordinate system. G91 = 57 Group03. Relative coordinate system."
  },
  "api/Hi.Numerical.NcGroup05.html": {
    "href": "api/Hi.Numerical.NcGroup05.html",
    "title": "Enum NcGroup05 | HiAPI-C# 2025",
    "summary": "Enum NcGroup05 Namespace Hi.Numerical Assembly HiUniNc.dll NcGroup enum. For feedrate. public enum NcGroup05 Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields G94 = 58 Group05. Use F as mm/min."
  },
  "api/Hi.Numerical.NcGroup06.html": {
    "href": "api/Hi.Numerical.NcGroup06.html",
    "title": "Enum NcGroup06 | HiAPI-C# 2025",
    "summary": "Enum NcGroup06 Namespace Hi.Numerical Assembly HiUniNc.dll NcGroup enum. Group of unit. In mm or in inch. public enum NcGroup06 Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields G20 = 13 Group06. Input in inch. For Fanuc specification A,B. RS274D specification is G70. G21 = 14 Group06. Input in mm. For Fanuc specification A,B. RS274D specification is G71. G70 = 48 Group06. Input in inch. Fanuc system C specification. Syntec specification. For RS274D specification. Fanuc system A,B specification is G20. G71 = 49 Group06. Input in mm. Fanuc system C specification. Syntec specification. For RS274D specification. Fanuc system A,B specification is G21."
  },
  "api/Hi.Numerical.NcGroup07.html": {
    "href": "api/Hi.Numerical.NcGroup07.html",
    "title": "Enum NcGroup07 | HiAPI-C# 2025",
    "summary": "Enum NcGroup07 Namespace Hi.Numerical Assembly HiUniNc.dll NcGroup enum. Left or right compensation for tool radius, etc.. See G40, G41, G42 for available compensation modes. public enum NcGroup07 Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields G40 = 16 Group07. Cancel radius compensation. See G41 and G42 for left and right compensation. G41 = 17 Group07. Tool radius/tool nose radius compensation. Left compensation: the updated tool tip location is at +y direction compensation from tool running direction. See G40 to cancel compensation and G42 for right compensation. G42 = 18 Group07. Tool radius/tool nose radius compensation. Right compensation: the updated tool tip location is at -y direction compensation from tool running direction. See G40 to cancel compensation and G41 for left compensation."
  },
  "api/Hi.Numerical.NcGroup08.html": {
    "href": "api/Hi.Numerical.NcGroup08.html",
    "title": "Enum NcGroup08 | HiAPI-C# 2025",
    "summary": "Enum NcGroup08 Namespace Hi.Numerical Assembly HiUniNc.dll NcGroup enum. Tool length compensation, etc.. G43,G43p4,G44,G49,SiemensTraori,SiemensTrafoof,HeidenhainM128,HeidenhainM129. public enum NcGroup08 Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) NcFlagUtil.IsToolCenterPointManagementEnabled(NcGroup08) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields G43 = 19 Group08 Positive height compensation. G43p4 = 20 Group08 G43.4: start RTCP (Rotational Tool Center Point). G44 = 21 Group08 Negative height compensation. G49 = 22 Group08. Cancel height compensation. HeidenhainM128 = 25 Group08. Heidenhain flag. M128: start RTCP (Rotational Tool Center Point). HeidenhainM129 = 26 Group08. Heidenhain flag. M129: cancel RTCP (Rotational Tool Center Point). SiemensTrafoof = 23 Group08. Siemens flag. Disable RTCP (Rotational Tool Center Point) (=Tool Center Point Management, TCPM). SiemensTraori = 24 Group08. Siemens flag. Enable RTCP (Rotational Tool Center Point) (=Tool Center Point Management, TCPM)."
  },
  "api/Hi.Numerical.NcGroup09.html": {
    "href": "api/Hi.Numerical.NcGroup09.html",
    "title": "Enum NcGroup09 | HiAPI-C# 2025",
    "summary": "Enum NcGroup09 Namespace Hi.Numerical Assembly HiUniNc.dll NcGroup enum. Canned cycle. public enum NcGroup09 Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields G80 = 50 Group09. Canned cycle cancel. Electronic gear box : synchronization cancellation. See G81, G82, G83, G85, G86 for available canned cycles. G81 = 51 Group09. Drilling cycle or spot boring cycle. Electronic gear box : synchronization start. The same parsing behavior group: G81,G85,G86. G82 = 52 Group09. Drilling cycle or spot boring cycle with bottom staying time. G83 = 53 Group09. Drilling cycle or spot boring cycle. drilling cycle in form of pecking. G85 = 54 Group09. Drilling cycle or spot boring cycle. Electronic gear box : synchronization start. The same parsing behavior group: G81,G85,G86. G86 = 55 Group09. Drilling cycle or spot boring cycle. Electronic gear box : synchronization start. The same parsing behavior group: G81,G85,G86."
  },
  "api/Hi.Numerical.NcGroup10.html": {
    "href": "api/Hi.Numerical.NcGroup10.html",
    "title": "Enum NcGroup10 | HiAPI-C# 2025",
    "summary": "Enum NcGroup10 Namespace Hi.Numerical Assembly HiUniNc.dll NcGroup enum. Canned cycle return point. G98,G99. public enum NcGroup10 Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields G98 = 61 Group10. Canned cycle : return to initial level. See G99 for R point level return. G99 = 62 Group10. Canned cycle : return to R point level. See G98 for initial level return."
  },
  "api/Hi.Numerical.NcGroup13.html": {
    "href": "api/Hi.Numerical.NcGroup13.html",
    "title": "Enum NcGroup13 | HiAPI-C# 2025",
    "summary": "Enum NcGroup13 Namespace Hi.Numerical Assembly HiUniNc.dll NC Group 13 for constant surface speed control. public enum NcGroup13 Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields G96 = 59 Group13. Constant surface speed control cancel. not support. G97 = 60 Group13. Constant surface speed control cancel."
  },
  "api/Hi.Numerical.NcGroup14.html": {
    "href": "api/Hi.Numerical.NcGroup14.html",
    "title": "Enum NcGroup14 | HiAPI-C# 2025",
    "summary": "Enum NcGroup14 Namespace Hi.Numerical Assembly HiUniNc.dll NcGroup enum. Coordinate system. Such as G54Series. public enum NcGroup14 Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields G54Series = 34 Group14. Coordinate settings. HeidenhainDatum = 43 Group14. Heidenhain flag. Coordinate settings for CYCL DEF 7 and CYCL DEF 247. Heidenhain_CYCL_DEF_247 = 41 Group14. Heidenhain flag. With the DATUM SETTING cycle you can activate as the new datum a preset defined in a preset table. After a DATUM SETTING cycle definition, all of the coordinate inputs and datum shifts(absolute and incremental) are referenced to the new preset. When activating a datum from the preset table, the TNC resets the datum shift, mirroring, rotation, scaling factor and axis-specific scaling factor. If you activate preset number 0 (line 0), then you activate the datum that you last set in the Manual Operation or El. Handwheel operating mode. Heidenhain_CYCL_DEF_7 = 40 Group14. Heidenhain flag. For shifting contours directly within the program or from datum tables. SiemensG500 = 42 Group14. Siemens command. Deactivation of the current settable zero offset. G500指令在没有赋值的时候为机床坐标系，可以把机床从工件坐标系转换到机床坐标系"
  },
  "api/Hi.Numerical.NcGroup15.html": {
    "href": "api/Hi.Numerical.NcGroup15.html",
    "title": "Enum NcGroup15 | HiAPI-C# 2025",
    "summary": "Enum NcGroup15 Namespace Hi.Numerical Assembly HiUniNc.dll NcGroup enum. public enum NcGroup15 Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields G60 = 35 Group15. Siemens: Exact stop / positioning mode. Machine decelerates to complete stop at each programmed point. G61 = 36 Group15. Exact stop mode. G62 = 37 Group15. Automatic corner override. G63 = 38 Group15. Tapping mode. Not support. G64 = 39 Group15. Cutting mode."
  },
  "api/Hi.Numerical.NcGroup16.html": {
    "href": "api/Hi.Numerical.NcGroup16.html",
    "title": "Enum NcGroup16 | HiAPI-C# 2025",
    "summary": "Enum NcGroup16 Namespace Hi.Numerical Assembly HiUniNc.dll NcGroup enum. Rotation plane related. Interface of get transformation. Heidenhain equivalent group is NcGroupHeidenhainPlane. public enum NcGroup16 Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields G68 = 44 Group16. 3-dimensional coordinate system conversion. run a pattern of operations in a rotated angle. G68p2 = 45 Group16. Tilted working plane command. G69 = 46 Group16. Coordinate system rotation cancel or 3-dimensional coordinate conversion mode off SiemensCycle800 = 47 Group16. Siemens flag. Tilted working plane command. CYCLE800() cancels the previous transformation."
  },
  "api/Hi.Numerical.NcGroup21.html": {
    "href": "api/Hi.Numerical.NcGroup21.html",
    "title": "Enum NcGroup21 | HiAPI-C# 2025",
    "summary": "Enum NcGroup21 Namespace Hi.Numerical Assembly HiUniNc.dll NcGroup enum. Polar coordinate interpolation mode. public enum NcGroup21 Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields G12p1 = 8 Group21. Polar coordinate interpolation mode ON. Use G13p1 to turn off polar coordinate interpolation mode. G13p1 = 9 Group21. Polar coordinate interpolation mode OFF. Use G12p1 to turn on polar coordinate interpolation mode."
  },
  "api/Hi.Numerical.NcGroupAttribute.html": {
    "href": "api/Hi.Numerical.NcGroupAttribute.html",
    "title": "Class NcGroupAttribute | HiAPI-C# 2025",
    "summary": "Class NcGroupAttribute Namespace Hi.Numerical Assembly HiUniNc.dll NC Group Attribute. [AttributeUsage(AttributeTargets.Field)] public class NcGroupAttribute : Attribute Inheritance object Attribute NcGroupAttribute Inherited Members Attribute.Equals(object) Attribute.GetCustomAttribute(Assembly, Type) Attribute.GetCustomAttribute(Assembly, Type, bool) Attribute.GetCustomAttribute(MemberInfo, Type) Attribute.GetCustomAttribute(MemberInfo, Type, bool) Attribute.GetCustomAttribute(Module, Type) Attribute.GetCustomAttribute(Module, Type, bool) Attribute.GetCustomAttribute(ParameterInfo, Type) Attribute.GetCustomAttribute(ParameterInfo, Type, bool) Attribute.GetCustomAttributes(Assembly) Attribute.GetCustomAttributes(Assembly, bool) Attribute.GetCustomAttributes(Assembly, Type) Attribute.GetCustomAttributes(Assembly, Type, bool) Attribute.GetCustomAttributes(MemberInfo) Attribute.GetCustomAttributes(MemberInfo, bool) Attribute.GetCustomAttributes(MemberInfo, Type) Attribute.GetCustomAttributes(MemberInfo, Type, bool) Attribute.GetCustomAttributes(Module) Attribute.GetCustomAttributes(Module, bool) Attribute.GetCustomAttributes(Module, Type) Attribute.GetCustomAttributes(Module, Type, bool) Attribute.GetCustomAttributes(ParameterInfo) Attribute.GetCustomAttributes(ParameterInfo, bool) Attribute.GetCustomAttributes(ParameterInfo, Type) Attribute.GetCustomAttributes(ParameterInfo, Type, bool) Attribute.GetHashCode() Attribute.IsDefaultAttribute() Attribute.IsDefined(Assembly, Type) Attribute.IsDefined(Assembly, Type, bool) Attribute.IsDefined(MemberInfo, Type) Attribute.IsDefined(MemberInfo, Type, bool) Attribute.IsDefined(Module, Type) Attribute.IsDefined(Module, Type, bool) Attribute.IsDefined(ParameterInfo, Type) Attribute.IsDefined(ParameterInfo, Type, bool) Attribute.Match(object) Attribute.TypeId object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NcGroupAttribute(Type) Ctor. public NcGroupAttribute(Type ncGroup) Parameters ncGroup Type Properties NcGroupType Gets or sets the NC group type. public Type NcGroupType { get; set; } Property Value Type"
  },
  "api/Hi.Numerical.NcGroupHeidenhainM107M108.html": {
    "href": "api/Hi.Numerical.NcGroupHeidenhainM107M108.html",
    "title": "Enum NcGroupHeidenhainM107M108 | HiAPI-C# 2025",
    "summary": "Enum NcGroupHeidenhainM107M108 Namespace Hi.Numerical Assembly HiUniNc.dll NcGroup enum. Heidenhain group. Enable or disable Suppress error message for replacement tools with oversize. public enum NcGroupHeidenhainM107M108 Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields HeidenhainM107 = 86 Heidenhain flag. Enable Suppress error message for replacement tools with oversize. HeidenhainM108 = 87 Heidenhain flag. Reset M107. disable Suppress error message for replacement tools with oversize."
  },
  "api/Hi.Numerical.NcGroupHeidenhainPlane.html": {
    "href": "api/Hi.Numerical.NcGroupHeidenhainPlane.html",
    "title": "Enum NcGroupHeidenhainPlane | HiAPI-C# 2025",
    "summary": "Enum NcGroupHeidenhainPlane Namespace Hi.Numerical Assembly HiUniNc.dll Heidenhain Group Plane related. ISO equivalent group is NcGroup16. public enum NcGroupHeidenhainPlane Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields HeidenhainPlaneReset = 80 Heidenhain Plane command is exclusive HeidenhainPlaneSpatial = 81 Heidenhain Plane command is exclusive"
  },
  "api/Hi.Numerical.NcGroupHeidenhainShortestRotaryPath.html": {
    "href": "api/Hi.Numerical.NcGroupHeidenhainShortestRotaryPath.html",
    "title": "Enum NcGroupHeidenhainShortestRotaryPath | HiAPI-C# 2025",
    "summary": "Enum NcGroupHeidenhainShortestRotaryPath Namespace Hi.Numerical Assembly HiUniNc.dll NcGroup enum. Heidenhain group. shortest rotary state. HeidenhainM126,HeidenhainM127 public enum NcGroupHeidenhainShortestRotaryPath Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields HeidenhainM126 = 88 NcGroup.HeidenhainShortestRotaryPath. Heidenhain flag. Shortest rotation for commands of ABC axise. The M126 will be canceled automatically at the end of the program. For Heidenhain. HeidenhainM127 = 89 NcGroup.HeidenhainShortestRotaryPath. Heidenhain flag. Cancel HeidenhainM126, i.e. disable shortest rotation for ABC axises. For Heidenhain."
  },
  "api/Hi.Numerical.NcGroupSpindleRotation.html": {
    "href": "api/Hi.Numerical.NcGroupSpindleRotation.html",
    "title": "Enum NcGroupSpindleRotation | HiAPI-C# 2025",
    "summary": "Enum NcGroupSpindleRotation Namespace Hi.Numerical Assembly HiUniNc.dll NcGroup enum. Spindle rotation control. See SpindleStop, SpindleCw, SpindleCcw for available rotation modes. public enum NcGroupSpindleRotation Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields SpindleCcw = 78 NcGroupSpindleRotation. Rotate spindle counter-clockwise (CCW). See SpindleStop to stop rotation and SpindleCw for clockwise rotation. SpindleCw = 77 NcGroupSpindleRotation. Rotate spindle clockwise (CW). See SpindleStop to stop rotation and SpindleCcw for counter-clockwise rotation. SpindleStop = 76 NcGroupSpindleRotation. Stop spindle rotation. See SpindleCw and SpindleCcw for clockwise and counter-clockwise rotation."
  },
  "api/Hi.Numerical.NcLifeCycleAttribute.html": {
    "href": "api/Hi.Numerical.NcLifeCycleAttribute.html",
    "title": "Class NcLifeCycleAttribute | HiAPI-C# 2025",
    "summary": "Class NcLifeCycleAttribute Namespace Hi.Numerical Assembly HiUniNc.dll Attribute to specify the lifecycle mode of an NC flag. [AttributeUsage(AttributeTargets.Field)] public class NcLifeCycleAttribute : Attribute Inheritance object Attribute NcLifeCycleAttribute Inherited Members Attribute.Equals(object) Attribute.GetCustomAttribute(Assembly, Type) Attribute.GetCustomAttribute(Assembly, Type, bool) Attribute.GetCustomAttribute(MemberInfo, Type) Attribute.GetCustomAttribute(MemberInfo, Type, bool) Attribute.GetCustomAttribute(Module, Type) Attribute.GetCustomAttribute(Module, Type, bool) Attribute.GetCustomAttribute(ParameterInfo, Type) Attribute.GetCustomAttribute(ParameterInfo, Type, bool) Attribute.GetCustomAttributes(Assembly) Attribute.GetCustomAttributes(Assembly, bool) Attribute.GetCustomAttributes(Assembly, Type) Attribute.GetCustomAttributes(Assembly, Type, bool) Attribute.GetCustomAttributes(MemberInfo) Attribute.GetCustomAttributes(MemberInfo, bool) Attribute.GetCustomAttributes(MemberInfo, Type) Attribute.GetCustomAttributes(MemberInfo, Type, bool) Attribute.GetCustomAttributes(Module) Attribute.GetCustomAttributes(Module, bool) Attribute.GetCustomAttributes(Module, Type) Attribute.GetCustomAttributes(Module, Type, bool) Attribute.GetCustomAttributes(ParameterInfo) Attribute.GetCustomAttributes(ParameterInfo, bool) Attribute.GetCustomAttributes(ParameterInfo, Type) Attribute.GetCustomAttributes(ParameterInfo, Type, bool) Attribute.GetHashCode() Attribute.IsDefaultAttribute() Attribute.IsDefined(Assembly, Type) Attribute.IsDefined(Assembly, Type, bool) Attribute.IsDefined(MemberInfo, Type) Attribute.IsDefined(MemberInfo, Type, bool) Attribute.IsDefined(Module, Type) Attribute.IsDefined(Module, Type, bool) Attribute.IsDefined(ParameterInfo, Type) Attribute.IsDefined(ParameterInfo, Type, bool) Attribute.Match(object) Attribute.TypeId object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NcLifeCycleAttribute(NcLifeCycleMode) Initializes a new instance of the NcLifeCycleAttribute class. public NcLifeCycleAttribute(NcLifeCycleMode ncLifeCycleMode) Parameters ncLifeCycleMode NcLifeCycleMode The lifecycle mode of the NC flag. Properties NcLifeCycleMode Gets or sets the lifecycle mode of the NC flag. public NcLifeCycleMode NcLifeCycleMode { get; set; } Property Value NcLifeCycleMode"
  },
  "api/Hi.Numerical.NcLifeCycleMode.html": {
    "href": "api/Hi.Numerical.NcLifeCycleMode.html",
    "title": "Enum NcLifeCycleMode | HiAPI-C# 2025",
    "summary": "Enum NcLifeCycleMode Namespace Hi.Numerical Assembly HiUniNc.dll Defines the lifecycle mode of NC commands. public enum NcLifeCycleMode Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) NcFlagUtil.GetFlags(NcLifeCycleMode) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Modal = 1 Command remains active until superseded by another command in the same group. OneShot = 2 Command is active only for the block in which it is specified. Undefined = 0 Undefined lifecycle mode."
  },
  "api/Hi.Numerical.NcNameAttribute.html": {
    "href": "api/Hi.Numerical.NcNameAttribute.html",
    "title": "Class NcNameAttribute | HiAPI-C# 2025",
    "summary": "Class NcNameAttribute Namespace Hi.Numerical Assembly HiUniNc.dll Attribute used to define a name for NC flags and other enumeration fields. [AttributeUsage(AttributeTargets.Field)] public class NcNameAttribute : Attribute Inheritance object Attribute NcNameAttribute Inherited Members Attribute.Equals(object) Attribute.GetCustomAttribute(Assembly, Type) Attribute.GetCustomAttribute(Assembly, Type, bool) Attribute.GetCustomAttribute(MemberInfo, Type) Attribute.GetCustomAttribute(MemberInfo, Type, bool) Attribute.GetCustomAttribute(Module, Type) Attribute.GetCustomAttribute(Module, Type, bool) Attribute.GetCustomAttribute(ParameterInfo, Type) Attribute.GetCustomAttribute(ParameterInfo, Type, bool) Attribute.GetCustomAttributes(Assembly) Attribute.GetCustomAttributes(Assembly, bool) Attribute.GetCustomAttributes(Assembly, Type) Attribute.GetCustomAttributes(Assembly, Type, bool) Attribute.GetCustomAttributes(MemberInfo) Attribute.GetCustomAttributes(MemberInfo, bool) Attribute.GetCustomAttributes(MemberInfo, Type) Attribute.GetCustomAttributes(MemberInfo, Type, bool) Attribute.GetCustomAttributes(Module) Attribute.GetCustomAttributes(Module, bool) Attribute.GetCustomAttributes(Module, Type) Attribute.GetCustomAttributes(Module, Type, bool) Attribute.GetCustomAttributes(ParameterInfo) Attribute.GetCustomAttributes(ParameterInfo, bool) Attribute.GetCustomAttributes(ParameterInfo, Type) Attribute.GetCustomAttributes(ParameterInfo, Type, bool) Attribute.GetHashCode() Attribute.IsDefaultAttribute() Attribute.IsDefined(Assembly, Type) Attribute.IsDefined(Assembly, Type, bool) Attribute.IsDefined(MemberInfo, Type) Attribute.IsDefined(MemberInfo, Type, bool) Attribute.IsDefined(Module, Type) Attribute.IsDefined(Module, Type, bool) Attribute.IsDefined(ParameterInfo, Type) Attribute.IsDefined(ParameterInfo, Type, bool) Attribute.Match(object) Attribute.TypeId object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NcNameAttribute(string) Initializes a new instance of the NcNameAttribute class. public NcNameAttribute(string name) Parameters name string The name to associate with the enum field Properties Name Gets or sets the name associated with the enum field. public string Name { get; set; } Property Value string"
  },
  "api/Hi.Numerical.NcNoteCache.html": {
    "href": "api/Hi.Numerical.NcNoteCache.html",
    "title": "Class NcNoteCache | HiAPI-C# 2025",
    "summary": "Class NcNoteCache Namespace Hi.Numerical Assembly HiUniNc.dll Cache for notes and warnings generated during NC line parsing. public class NcNoteCache Inheritance object NcNoteCache Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties IndexNote Gets or sets the index note (N number) from the NC line. public int? IndexNote { get; set; } Property Value int? SkippedFlags Known flags and sure to skip. public List<string> SkippedFlags { get; set; } Property Value List<string> Text Gets a text representation of all non-empty flag lists. public string Text { get; } Property Value string UnExpectedFlags known flags but not shown on an expected way. public List<string> UnExpectedFlags { get; set; } Property Value List<string> UnSupportedFlags Known flags but not support. public List<string> UnSupportedFlags { get; set; } Property Value List<string> UnknownFlags Unknown flags. public List<string> UnknownFlags { get; set; } Property Value List<string> Warnings Gets or sets the list of warnings generated during parsing. public List<string> Warnings { get; set; } Property Value List<string>"
  },
  "api/Hi.Numerical.NcProc.html": {
    "href": "api/Hi.Numerical.NcProc.html",
    "title": "Class NcProc | HiAPI-C# 2025",
    "summary": "Class NcProc Namespace Hi.Numerical Assembly HiUniNc.dll Provides processing utilities for NC programming. public static class NcProc Inheritance object NcProc Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetActs(HardNcEnv, SeqPair<HardNcLine>, IProgress<IMessage>) Gets the acts from a sequence pair of NcLines public static IEnumerable<IAct> GetActs(HardNcEnv ncEnv, SeqPair<HardNcLine> ncLineSeq, IProgress<IMessage> mixedProgress) Parameters ncEnv HardNcEnv The numerical control environment ncLineSeq SeqPair<HardNcLine> The sequence pair of NcLines mixedProgress IProgress<IMessage> The message host for logging Returns IEnumerable<IAct> Enumerable of acts GetActs(HardNcEnv, HardNcLine, HardNcLine, IProgress<IMessage>) Gets the acts from a pair of NcLines public static IEnumerable<IAct> GetActs(HardNcEnv ncEnv, HardNcLine preNcLine, HardNcLine curNcLine, IProgress<IMessage> mixedProgress) Parameters ncEnv HardNcEnv The numerical control environment preNcLine HardNcLine The previous NcLine curNcLine HardNcLine The current NcLine mixedProgress IProgress<IMessage> The message host for logging Returns IEnumerable<IAct> Enumerable of acts GetActs(HardNcEnv, LinkedListNode<HardNcLine>, IProgress<IMessage>) Gets the acts from a linked list node containing an NcLine public static IEnumerable<IAct> GetActs(HardNcEnv ncEnv, LinkedListNode<HardNcLine> ncLineNode, IProgress<IMessage> mixedProgress) Parameters ncEnv HardNcEnv The numerical control environment ncLineNode LinkedListNode<HardNcLine> The linked list node containing the NcLine mixedProgress IProgress<IMessage> The message host for logging Returns IEnumerable<IAct> Enumerable of acts"
  },
  "api/Hi.Numerical.NcWarningSceneEnum.html": {
    "href": "api/Hi.Numerical.NcWarningSceneEnum.html",
    "title": "Enum NcWarningSceneEnum | HiAPI-C# 2025",
    "summary": "Enum NcWarningSceneEnum Namespace Hi.Numerical Assembly HiUniNc.dll Defines scene types for NC warnings. public enum NcWarningSceneEnum Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Skip = 1 Skip operation warning. TransformFailed = 4 Transform operation failed warning. UnExpect = 3 Unexpected result warning. UnSupport = 2 Unsupported operation warning. Unknown = 0 Unknown warning scene."
  },
  "api/Hi.Numerical.NumericUtil.html": {
    "href": "api/Hi.Numerical.NumericUtil.html",
    "title": "Class NumericUtil | HiAPI-C# 2025",
    "summary": "Class NumericUtil Namespace Hi.Numerical Assembly HiGeom.dll Utility class for numeric operations and unit conversions. public static class NumericUtil Inheritance object NumericUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetFeedrate_mmdmin(IGetFeedrate) Gets the feedrate in millimeters per minute. public static double GetFeedrate_mmdmin(this IGetFeedrate src) Parameters src IGetFeedrate The feedrate source Returns double Feedrate in mm/min GetSpindleCyclePeriod(IGetSpindleSpeed) Gets the spindle cycle period as a TimeSpan. public static TimeSpan GetSpindleCyclePeriod(this IGetSpindleSpeed src) Parameters src IGetSpindleSpeed The spindle speed source Returns TimeSpan Cycle period as a TimeSpan GetSpindleCyclePeriod_s(IGetSpindleSpeed) Gets the spindle cycle period in seconds. public static double GetSpindleCyclePeriod_s(this IGetSpindleSpeed src) Parameters src IGetSpindleSpeed The spindle speed source Returns double Cycle period in seconds GetSpindleSpeed_rpm(IGetSpindleSpeed) Gets the spindle speed in revolutions per minute. public static double GetSpindleSpeed_rpm(this IGetSpindleSpeed src) Parameters src IGetSpindleSpeed The spindle speed source Returns double Spindle speed in rpm IsRotating(SpindleDirection) Determines whether the spindle is rotating (either clockwise or counter-clockwise). public static bool IsRotating(this SpindleDirection spindleDirection) Parameters spindleDirection SpindleDirection The spindle direction to check Returns bool True if the spindle is rotating; otherwise, false SetFeedrate_mmdmin(ISetFeedrate, double) Sets the feedrate in millimeters per minute. public static void SetFeedrate_mmdmin(this ISetFeedrate src, double feedrate_mmdmin) Parameters src ISetFeedrate The feedrate target feedrate_mmdmin double Feedrate value in mm/min SetSpindleSpeed_rpm(ISetSpindleSpeed, double) Sets the spindle speed in revolutions per minute. public static void SetSpindleSpeed_rpm(this ISetSpindleSpeed src, double spindleSpeed_rpm) Parameters src ISetSpindleSpeed The spindle speed target spindleSpeed_rpm double Spindle speed value in rpm"
  },
  "api/Hi.Numerical.PolarEntry.html": {
    "href": "api/Hi.Numerical.PolarEntry.html",
    "title": "Class PolarEntry | HiAPI-C# 2025",
    "summary": "Class PolarEntry Namespace Hi.Numerical Assembly HiUniNc.dll The class for G12.1 Polar mode. In G12.1 Polar mode, NC code applies (X,C) as (linear axis, hypothetical axis). XC, YA, ZB are available. public class PolarEntry Inheritance object PolarEntry Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties CentralProgramPolarRxcz ProgramPolarPos on no-shifting polar coordinate (e.g. coordinate on the c axis center and x-zero). public Vec3d CentralProgramPolarRxcz { get; set; } Property Value Vec3d CodePolarDxcz In Polar coordinate interpolation mode (G12.1), the X value is the diameter value. and also, rotary is assigned by hypothesis value (called C. Some controller accepts Y as equivalent.). Dx: X is diameter. public Vec3d CodePolarDxcz { get; set; } Property Value Vec3d InitProgramPolarRxcz InitProgramPolarXcz. z is always zero. Const session data. Only set at the G12.1 line once. public Vec3d InitProgramPolarRxcz { get; set; } Property Value Vec3d PolarModeDir Gets or sets the polar mode direction public PolarModeDirEnum PolarModeDir { get; set; } Property Value PolarModeDirEnum ProgramPolarRxcz ProgramPos. XC, YA or ZB. The Last is Z (for XC). According to PolarModeDir. Rx: x is radius . Pos.X is linear axis position (X,Y,Z); Pos.Y is hypothetical axis position (C,A,B). Unit of Pos.Y is linear. In contrast to term “OrdinaryProgramXcz”, the Unit of “OrdinaryProgramXcz”.Y is angle. In Polar coordinate interpolation mode (G12.1), the X value is the diameter value. So remark R to X here, emphasize x is different from the G12.1 convention. Use x as radius so that the dimension is uniform on the three axises (XCZ). public Vec3d ProgramPolarRxcz { get; set; } Property Value Vec3d Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.RadiusCompensationBuf.html": {
    "href": "api/Hi.Numerical.RadiusCompensationBuf.html",
    "title": "Class RadiusCompensationBuf | HiAPI-C# 2025",
    "summary": "Class RadiusCompensationBuf Namespace Hi.Numerical Assembly HiUniNc.dll Buffer for radius compensation (G41/G42) operations in numerical control. At each line junction, the offset paths of adjacent lines may form an intersection (intersected rays) or align directly (parallel rays). For straight lines, the tool goes to the intersection point. For arcs, the offset curve doesn't pass through the intersection, so transient points bridge the gap: Arc → TransientEnd → (linear) → Intersection → (linear) → TransientBegin → NextArc. Transient properties are null when rays are parallel (offset paths align, no corner needed) or when the adjacent line is not an arc. public class RadiusCompensationBuf Inheritance object RadiusCompensationBuf Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors RadiusCompensationBuf() Initializes a new instance of the RadiusCompensationBuf class. public RadiusCompensationBuf() Properties CenterProgramPos Arc only. The circle center in program coordinates, computed from the arc's IJK values and the begin position. Used by NcProc to generate spiral contours. public Vec3d CenterProgramPos { get; set; } Property Value Vec3d CompensatedPosOnProgramCoordinate The compensated tool-tip position on program coordinates (after radius offset). For straight lines, this is the intersection of the adjacent offset lines. For parallel rays, this is a direct perpendicular offset from the program position. Can be Cartesian XYZ or Polar Coordinate Interpolation Mode (G12.1) XCZ. public Vec3d CompensatedPosOnProgramCoordinate { get; set; } Property Value Vec3d TransientBeginMc Arc only. Machine coordinates corresponding to TransientBeginProgramPos. public DVec3d TransientBeginMc { get; set; } Property Value DVec3d TransientBeginProgramPos Arc only. The point on this arc's offset curve where the arc motion begins, when the previous line's offset path intersects at a corner. Null when rays are parallel (no corner) or the previous line is not intersecting. Set by the previous line's iteration in ResolveRadiusCompensation(LinkedListNode<HardNcLine>, HardNcEnv, NcNoteCache, IProgress<IMessage>). public Vec3d TransientBeginProgramPos { get; set; } Property Value Vec3d TransientEndMc Arc only. Machine coordinates corresponding to TransientEndProgramPos. public DVec3d TransientEndMc { get; set; } Property Value DVec3d TransientEndProgramPos Arc only. The point on this arc's offset curve where the arc motion ends, when the next line's offset path intersects at a corner. Null when rays are parallel (no corner) or the next line is not intersecting. Set by the current line's iteration in ResolveRadiusCompensation(LinkedListNode<HardNcLine>, HardNcEnv, NcNoteCache, IProgress<IMessage>). public Vec3d TransientEndProgramPos { get; set; } Property Value Vec3d Methods ResolveRadiusCompensation(LinkedListNode<HardNcLine>, HardNcEnv, NcNoteCache, IProgress<IMessage>) Resolves radius compensation for the given node. public static bool ResolveRadiusCompensation(LinkedListNode<HardNcLine> srcNode, HardNcEnv ncEnv, NcNoteCache ncLineCache, IProgress<IMessage> mixedProgress) Parameters srcNode LinkedListNode<HardNcLine> The source node to resolve radius compensation for. ncEnv HardNcEnv The numerical control environment. ncLineCache NcNoteCache The NC line cache for storing messages. mixedProgress IProgress<IMessage> The message host for reporting issues. Returns bool True if radius compensation was resolved; otherwise, false. Remarks Blocks without in-plane movement of their own (comments, empty lines, a bare G41/G40, M/F/S-only blocks, dwells, Z-only plunges, zero-length moves) never take part in a corner. Before the region's first moving block the start-up is pending (Fanuc: a G41/G42 block without movement starts up on the next movement block), so such blocks keep their nominal position; afterwards they carry the previous block's offset vector. Corners are resolved between the moving blocks on either side of them, and a region that ends without further movement (a bare G40) ends with the perpendicular offset of its last moving block, so a comment or empty line inserted anywhere in the region leaves the compensated path unchanged. The controller's overcut rule for two or more consecutive executable blocks without movement is not emulated: the corner is always the intersection. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.Numerical.SourcedActEntry.html": {
    "href": "api/Hi.Numerical.SourcedActEntry.html",
    "title": "Class SourcedActEntry | HiAPI-C# 2025",
    "summary": "Class SourcedActEntry Namespace Hi.Numerical Assembly HiMech.dll Represents an entry containing a source command and its associated act. public record SourcedActEntry : IEquatable<SourcedActEntry> Inheritance object SourcedActEntry Implements IEquatable<SourcedActEntry> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SourcedActEntry(ISentenceCarrier, IAct) Represents an entry containing a source command and its associated act. public SourcedActEntry(ISentenceCarrier SentenceSource, IAct Act) Parameters SentenceSource ISentenceCarrier The source sentence carrier, carrying both the Sentence and the execution-order SentenceIndex. Act IAct The act associated with the source command. Properties Act The act associated with the source command. public IAct Act { get; init; } Property Value IAct SentenceSource The source sentence carrier, carrying both the Sentence and the execution-order SentenceIndex. public ISentenceCarrier SentenceSource { get; init; } Property Value ISentenceCarrier"
  },
  "api/Hi.Numerical.SpindleDirection.html": {
    "href": "api/Hi.Numerical.SpindleDirection.html",
    "title": "Enum SpindleDirection | HiAPI-C# 2025",
    "summary": "Enum SpindleDirection Namespace Hi.Numerical Assembly HiGeom.dll Enumeration of spindle rotation directions. public enum SpindleDirection Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) NumericUtil.IsRotating(SpindleDirection) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields CCW = 2 Counter-clockwise rotation (M04 command). CW = 1 Clockwise rotation (M03 command). STOP = 0 Spindle is stopped (M05 command). UnDefined = 3 Undefined direction state."
  },
  "api/Hi.Numerical.StepSelectionUtils.AnchorMode.html": {
    "href": "api/Hi.Numerical.StepSelectionUtils.AnchorMode.html",
    "title": "Enum AnchorMode | HiAPI-C# 2025",
    "summary": "Enum AnchorMode Namespace Hi.Numerical.StepSelectionUtils Assembly HiMech.dll Defines the mode for anchoring boundaries when selecting steps. public enum AnchorMode Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields FirstTouch = 4 Anchor at the first touch point. LastTouch = 8 Anchor at the last touch point. LineBegin = 1 Anchor at the beginning of a line. LineEnd = 2 Anchor at the end of a line. Undefined = 0 Undefined anchor mode."
  },
  "api/Hi.Numerical.StepSelectionUtils.BoundSelector.html": {
    "href": "api/Hi.Numerical.StepSelectionUtils.BoundSelector.html",
    "title": "Class BoundSelector | HiAPI-C# 2025",
    "summary": "Class BoundSelector Namespace Hi.Numerical.StepSelectionUtils Assembly HiMech.dll Mark on source command line for managing step. public class BoundSelector : IFileLineIndex, IGetFileLineIndex, IMakeXmlSource Inheritance object BoundSelector Implements IFileLineIndex IGetFileLineIndex IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors BoundSelector(AnchorMode, IStepShift, FileLineIndex, int) Initializes a new instance of the BoundSelector class. public BoundSelector(AnchorMode anchorMode, IStepShift shift, FileLineIndex fileLineIndex, int boundStepIndex) Parameters anchorMode AnchorMode The anchor mode for the bound. shift IStepShift The step shift to apply. fileLineIndex FileLineIndex The file line index. boundStepIndex int The step index at the boundary. BoundSelector(XElement, string, IProgress<IMessage>) Ctor. public BoundSelector(XElement src, string baseDirectory, IProgress<IMessage> progress) Parameters src XElement XML source element baseDirectory string Base directory for resolving relative paths progress IProgress<IMessage> Progress reporter for nested XML factory calls. Properties BoundStepIndex If locale on begin, the step index should be the first step of the line; if locale on end, the step index should be the last step of the line. i.e. the index is inclusive. public int BoundStepIndex { get; set; } Property Value int FileIndex File Index. Start on 0. public int FileIndex { get; set; } Property Value int FileLineIndex Gets or sets the file line index. public FileLineIndex FileLineIndex { get; set; } Property Value FileLineIndex FileNo Gets or sets the file number. public int FileNo { get; set; } Property Value int KeyAnchorMode Gets or sets the key anchor mode that determines how the boundary is anchored. public AnchorMode KeyAnchorMode { get; set; } Property Value AnchorMode LineIndex Line Index. Start on 0. public int LineIndex { get; set; } Property Value int LineNo Gets or sets the line number. public int LineNo { get; set; } Property Value int Shift Gets or sets the shift to apply to the step index. public IStepShift Shift { get; set; } Property Value IStepShift XName Name for XML IO. public static string XName { get; } Property Value string Methods GetFileLineIndex() Get FileLineIndex. public FileLineIndex GetFileLineIndex() Returns FileLineIndex FileLineIndex MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.StepSelectionUtils.BoundSelectorHost.html": {
    "href": "api/Hi.Numerical.StepSelectionUtils.BoundSelectorHost.html",
    "title": "Class BoundSelectorHost | HiAPI-C# 2025",
    "summary": "Class BoundSelectorHost Namespace Hi.Numerical.StepSelectionUtils Assembly HiMech.dll Hosts bound selectors and manages step sections within a CL strip. public class BoundSelectorHost : IMakeXmlSource Inheritance object BoundSelectorHost Implements IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors BoundSelectorHost() Initializes a new instance of the BoundSelectorHost class. public BoundSelectorHost() BoundSelectorHost(XElement, string, IProgress<IMessage>) Ctor. public BoundSelectorHost(XElement src, string baseDirectory, IProgress<IMessage> progress) Parameters src XElement XML source element baseDirectory string Base directory for resolving relative paths progress IProgress<IMessage> Progress reporter for nested bundle XML. Properties XName Name for XML IO. public static string XName { get; } Property Value string Methods Begin(string, AnchorMode, IStepShift, FileLineIndex, int) Marks the beginning of a step section with the specified key and parameters. public void Begin(string key, AnchorMode anchorMode, IStepShift shift, FileLineIndex fileLineIndex, int boundStepIndex) Parameters key string The key identifying the step section. anchorMode AnchorMode The anchor mode for the bound. shift IStepShift The step shift to apply. fileLineIndex FileLineIndex The file line index. boundStepIndex int The step index at the boundary. Begin(string, BoundSelector) Marks the beginning of a step section with the specified key. public void Begin(string key, BoundSelector beginMark) Parameters key string The key identifying the step section. beginMark BoundSelector The bound selector marking the beginning. Clear() Clears all unclosed sections and bound selector bundles. public void Clear() End(string, AnchorMode, IStepShift, FileLineIndex, int) Marks the end of a step section with the specified key and parameters. public void End(string key, AnchorMode anchorMode, IStepShift shift, FileLineIndex fileLineIndex, int boundStepIndex) Parameters key string The key identifying the step section. anchorMode AnchorMode The anchor mode for the bound. shift IStepShift The step shift to apply. fileLineIndex FileLineIndex The file line index. boundStepIndex int The step index at the boundary. End(string, BoundSelector) Marks the end of a step section with the specified key. public void End(string key, BoundSelector endMark) Parameters key string The key identifying the step section. endMark BoundSelector The bound selector marking the end. GetKeyToStepSectionDictionary(ClStrip) Gets a dictionary mapping keys to their corresponding step section ranges in the CL strip. public Dictionary<string, Range<int>> GetKeyToStepSectionDictionary(ClStrip clStrip) Parameters clStrip ClStrip The CL strip containing the steps. Returns Dictionary<string, Range<int>> A dictionary mapping keys to step section ranges. GetStepSection(string, ClStrip) Gets the step section range for the specified key in the CL strip. public Range<int> GetStepSection(string key, ClStrip clStrip) Parameters key string The key identifying the step section. clStrip ClStrip The CL strip containing the steps. Returns Range<int> The step section range, or null if the key is not found. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.StepSelectionUtils.BoundSelectorPair.BoundLocale.html": {
    "href": "api/Hi.Numerical.StepSelectionUtils.BoundSelectorPair.BoundLocale.html",
    "title": "Enum BoundSelectorPair.BoundLocale | HiAPI-C# 2025",
    "summary": "Enum BoundSelectorPair.BoundLocale Namespace Hi.Numerical.StepSelectionUtils Assembly HiMech.dll Defines the location of a bound within the pair. public enum BoundSelectorPair.BoundLocale Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Begin = 1 The beginning bound. End = 2 The ending bound."
  },
  "api/Hi.Numerical.StepSelectionUtils.BoundSelectorPair.html": {
    "href": "api/Hi.Numerical.StepSelectionUtils.BoundSelectorPair.html",
    "title": "Class BoundSelectorPair | HiAPI-C# 2025",
    "summary": "Class BoundSelectorPair Namespace Hi.Numerical.StepSelectionUtils Assembly HiMech.dll Represents a pair of bound selectors defining the beginning and end of a step section. public class BoundSelectorPair : IMakeXmlSource Inheritance object BoundSelectorPair Implements IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors BoundSelectorPair(BoundSelector, BoundSelector) Initializes a new instance of the BoundSelectorPair class with specified begin and end bound selectors. public BoundSelectorPair(BoundSelector begin, BoundSelector end) Parameters begin BoundSelector The beginning bound selector. end BoundSelector The ending bound selector. BoundSelectorPair(XElement, string, IProgress<IMessage>) Ctor. public BoundSelectorPair(XElement src, string baseDirectory, IProgress<IMessage> progress) Parameters src XElement XML source element baseDirectory string Base directory for resolving relative paths progress IProgress<IMessage> Progress reporter for nested selector XML. Properties Begin Gets the beginning bound selector. public BoundSelector Begin { get; } Property Value BoundSelector End Gets the ending bound selector. public BoundSelector End { get; } Property Value BoundSelector XName Name for XML IO. public static string XName { get; } Property Value string Methods GetStepSectionBound(BoundLocale) Gets the bound selector for the specified location. public BoundSelector GetStepSectionBound(BoundSelectorPair.BoundLocale locale) Parameters locale BoundSelectorPair.BoundLocale The location of the bound to retrieve. Returns BoundSelector The bound selector at the specified location. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.StepSelectionUtils.BoundSelectorStepSectionBundle.html": {
    "href": "api/Hi.Numerical.StepSelectionUtils.BoundSelectorStepSectionBundle.html",
    "title": "Class BoundSelectorStepSectionBundle | HiAPI-C# 2025",
    "summary": "Class BoundSelectorStepSectionBundle Namespace Hi.Numerical.StepSelectionUtils Assembly HiMech.dll Represents a bundle containing a boundary selector pair and the corresponding step section range. public class BoundSelectorStepSectionBundle : IMakeXmlSource Inheritance object BoundSelectorStepSectionBundle Implements IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors BoundSelectorStepSectionBundle(BoundSelectorPair, Range<int>) Initializes a new instance of the BoundSelectorStepSectionBundle class with the specified boundary selector pair and step section. public BoundSelectorStepSectionBundle(BoundSelectorPair boundSelectorPair, Range<int> stepSection) Parameters boundSelectorPair BoundSelectorPair The boundary selector pair. stepSection Range<int> The step section range. BoundSelectorStepSectionBundle(XElement, string, IProgress<IMessage>) Ctor. public BoundSelectorStepSectionBundle(XElement src, string baseDirectory, IProgress<IMessage> progress) Parameters src XElement XML source element baseDirectory string Base directory for resolving relative paths progress IProgress<IMessage> Progress reporter for nested selector XML. Properties BoundSelectorPair Gets or sets the boundary selector pair that defines the step section. public BoundSelectorPair BoundSelectorPair { get; set; } Property Value BoundSelectorPair XName Name for XML IO. public static string XName { get; } Property Value string Methods BuildStepSection(ClStrip) Builds the step section range from the CL strip using the boundary selector pair. public Range<int> BuildStepSection(ClStrip clStrip) Parameters clStrip ClStrip The CL strip to build the step section from. Returns Range<int> The built step section range. CallStepSection(ClStrip) Gets the existing step section or builds it if it doesn't exist. public Range<int> CallStepSection(ClStrip clStrip) Parameters clStrip ClStrip The CL strip to use for building the step section if needed. Returns Range<int> The step section range. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.StepSelectionUtils.BoundSelectorUtil.html": {
    "href": "api/Hi.Numerical.StepSelectionUtils.BoundSelectorUtil.html",
    "title": "Class BoundSelectorUtil | HiAPI-C# 2025",
    "summary": "Class BoundSelectorUtil Namespace Hi.Numerical.StepSelectionUtils Assembly HiMech.dll Utility class for selecting steps within boundaries in a CL strip. public static class BoundSelectorUtil Inheritance object BoundSelectorUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetStepRange(ClStrip, BoundSelectorPair) Gets the range of step indices based on the provided boundary selector pair. public static Range<int> GetStepRange(this ClStrip clStrip, BoundSelectorPair rangeStepLineMark) Parameters clStrip ClStrip The CL strip containing the steps. rangeStepLineMark BoundSelectorPair The boundary selector pair defining the range. Returns Range<int> A range of step indices."
  },
  "api/Hi.Numerical.StepSelectionUtils.DistanceShift.html": {
    "href": "api/Hi.Numerical.StepSelectionUtils.DistanceShift.html",
    "title": "Class DistanceShift | HiAPI-C# 2025",
    "summary": "Class DistanceShift Namespace Hi.Numerical.StepSelectionUtils Assembly HiMech.dll A step shift implementation that shifts based on distance along the tool path. public class DistanceShift : IStepShift, IMakeXmlSource Inheritance object DistanceShift Implements IStepShift IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors DistanceShift(double) Constructor with specified distance shift in millimeters. public DistanceShift(double distanceShift_mm) Parameters distanceShift_mm double The distance to shift in millimeters. DistanceShift(XElement) Ctor. public DistanceShift(XElement src) Parameters src XElement XML Properties DistanceShift_mm The distance to shift in millimeters. public double DistanceShift_mm { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods GetShiftedStepIndex(ClStrip, int) Gets the shifted step index based on distance along the tool path. public int GetShiftedStepIndex(ClStrip host, int originalStepIndex) Parameters host ClStrip The CL strip hosting the steps. originalStepIndex int The original step index to shift from. Returns int The shifted step index after applying the distance shift. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.StepSelectionUtils.IStepShift.html": {
    "href": "api/Hi.Numerical.StepSelectionUtils.IStepShift.html",
    "title": "Interface IStepShift | HiAPI-C# 2025",
    "summary": "Interface IStepShift Namespace Hi.Numerical.StepSelectionUtils Assembly HiMech.dll Interface for defining step shift behavior. public interface IStepShift : IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetShiftedStepIndex(ClStrip, int) Gets the shifted step index based on the original step index. int GetShiftedStepIndex(ClStrip host, int originalStepIndex) Parameters host ClStrip The CL strip hosting the steps. originalStepIndex int The original step index to shift from. Returns int The shifted step index."
  },
  "api/Hi.Numerical.StepSelectionUtils.TimeShift.html": {
    "href": "api/Hi.Numerical.StepSelectionUtils.TimeShift.html",
    "title": "Class TimeShift | HiAPI-C# 2025",
    "summary": "Class TimeShift Namespace Hi.Numerical.StepSelectionUtils Assembly HiMech.dll Represents a time-based shift operation for machining steps. This class provides functionality to shift step indices based on time offsets. public class TimeShift : IStepShift, IMakeXmlSource Inheritance object TimeShift Implements IStepShift IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors TimeShift(TimeSpan, bool) Initializes a new instance of the TimeShift class with the specified parameters. public TimeShift(TimeSpan timeShift, bool isBackward) Parameters timeShift TimeSpan The amount of time to shift. isBackward bool True to shift backward in time, false to shift forward. TimeShift(XElement) Initializes a new instance of the TimeShift class from XML. public TimeShift(XElement src) Parameters src XElement The XML element containing the time shift configuration. Properties IsBackward Gets or sets a value indicating whether the shift is backward in time. When true, shifts steps earlier in time; when false, shifts steps later in time. public bool IsBackward { get; set; } Property Value bool ShiftTimeSpan Gets or sets the amount of time to shift. public TimeSpan ShiftTimeSpan { get; set; } Property Value TimeSpan XName Gets the XML element name used for serialization. public static string XName { get; } Property Value string Remarks This name is used as the XML tag when serializing/deserializing TimeShift instances. The value is the unqualified name of the class (TimeShift). Methods GetShiftedStepIndex(ClStrip, int) Gets the shifted step index based on the original index and the time shift configuration. public int GetShiftedStepIndex(ClStrip host, int originalStepIndex) Parameters host ClStrip The cutter location strip containing the steps. originalStepIndex int The original step index to shift. Returns int The shifted step index, or -1 if the shift results in an invalid index. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.StepSelectionUtils.html": {
    "href": "api/Hi.Numerical.StepSelectionUtils.html",
    "title": "Namespace Hi.Numerical.StepSelectionUtils | HiAPI-C# 2025",
    "summary": "Namespace Hi.Numerical.StepSelectionUtils Classes BoundSelector Mark on source command line for managing step. BoundSelectorHost Hosts bound selectors and manages step sections within a CL strip. BoundSelectorPair Represents a pair of bound selectors defining the beginning and end of a step section. BoundSelectorStepSectionBundle Represents a bundle containing a boundary selector pair and the corresponding step section range. BoundSelectorUtil Utility class for selecting steps within boundaries in a CL strip. DistanceShift A step shift implementation that shifts based on distance along the tool path. TimeShift Represents a time-based shift operation for machining steps. This class provides functionality to shift step indices based on time offsets. Interfaces IStepShift Interface for defining step shift behavior. Enums AnchorMode Defines the mode for anchoring boundaries when selecting steps. BoundSelectorPair.BoundLocale Defines the location of a bound within the pair."
  },
  "api/Hi.Numerical.SubStringKit.ActivationMode.html": {
    "href": "api/Hi.Numerical.SubStringKit.ActivationMode.html",
    "title": "Enum SubStringKit.ActivationMode | HiAPI-C# 2025",
    "summary": "Enum SubStringKit.ActivationMode Namespace Hi.Numerical Assembly HiGeom.dll Defines the mode of activation for substring extraction. public enum SubStringKit.ActivationMode Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields TailSymbol = 0 Activates extraction based on a tail symbol."
  },
  "api/Hi.Numerical.SubStringKit.html": {
    "href": "api/Hi.Numerical.SubStringKit.html",
    "title": "Class SubStringKit | HiAPI-C# 2025",
    "summary": "Class SubStringKit Namespace Hi.Numerical Assembly HiGeom.dll Utility class for extracting and manipulating substrings based on specific activation patterns. public class SubStringKit Inheritance object SubStringKit Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties ActivationRaw Gets or sets the raw activation string used for pattern matching. public string ActivationRaw { get; set; } Property Value string Mode Gets or sets the activation mode for substring extraction. public SubStringKit.ActivationMode Mode { get; set; } Property Value SubStringKit.ActivationMode Methods GetScript(string) Gets the script part from the raw text based on the activation pattern. public string GetScript(string rawText) Parameters rawText string The raw text to extract script from. Returns string The extracted script, or null if no match is found. RemoveScript(string, out string) Removes the script part from the raw text based on the activation pattern. public string RemoveScript(string rawText, out string script) Parameters rawText string The raw text to process script string Output parameter that will contain the extracted script, or null if no match is found Returns string The raw text with the script part and activation pattern removed"
  },
  "api/Hi.Numerical.ToolConfigNotFoundException.html": {
    "href": "api/Hi.Numerical.ToolConfigNotFoundException.html",
    "title": "Class ToolConfigNotFoundException | HiAPI-C# 2025",
    "summary": "Class ToolConfigNotFoundException Namespace Hi.Numerical Assembly HiUniNc.dll Exception thrown when a tool configuration cannot be found. public class ToolConfigNotFoundException : Exception, ISerializable Inheritance object Exception ToolConfigNotFoundException Implements ISerializable Inherited Members Exception.GetBaseException() Exception.GetType() Exception.ToString() Exception.Data Exception.HelpLink Exception.HResult Exception.InnerException Exception.Message Exception.Source Exception.StackTrace Exception.TargetSite Exception.SerializeObjectState object.Equals(object) object.Equals(object, object) object.GetHashCode() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ToolConfigNotFoundException(int, string) Initializes a new instance of the ToolConfigNotFoundException class. public ToolConfigNotFoundException(int configId, string msg) Parameters configId int The configuration ID that could not be found. msg string The error message. Properties ConfigId Gets or sets the configuration ID that could not be found. public int ConfigId { get; set; } Property Value int"
  },
  "api/Hi.Numerical.Xyzabc.Abc.html": {
    "href": "api/Hi.Numerical.Xyzabc.Abc.html",
    "title": "Struct Abc | HiAPI-C# 2025",
    "summary": "Struct Abc Namespace Hi.Numerical.Xyzabc Assembly HiMech.dll Represents a three-axis rotational configuration in ABC coordinates. public struct Abc Inherited Members ValueType.Equals(object) ValueType.GetHashCode() object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors Abc(Vec3d) Creates a new ABC configuration from a 3D vector. public Abc(Vec3d src) Parameters src Vec3d The source vector where X, Y, Z components map to A, B, C angles respectively Abc(Abc) Creates a new ABC configuration by copying another one. public Abc(Abc src) Parameters src Abc The source ABC configuration to copy Abc(double, double, double) Ctor. public Abc(double a = NaN, double b = NaN, double c = NaN) Parameters a double b double c double Abc((double a, double b, double c)) Creates a new ABC configuration from a tuple of angles. public Abc((double a, double b, double c) src) Parameters src (double, double, double) The source tuple containing (a, b, c) angles Fields a The A-axis rotation angle. public double a Field Value double b The B-axis rotation angle. public double b Field Value double c The C-axis rotation angle. public double c Field Value double Properties Tuple Gets the ABC angles as a tuple. public (double a, double b, double c) Tuple { get; } Property Value (double, double, double) A tuple containing the (a, b, c) angles Methods ToString() Returns the fully qualified type name of this instance. public override string ToString() Returns string The fully qualified type name. ToVec3d() Converts the ABC angles to a 3D vector. public Vec3d ToVec3d() Returns Vec3d A vector where X, Y, Z components represent A, B, C angles respectively"
  },
  "api/Hi.Numerical.Xyzabc.CodeXyzabcChain.html": {
    "href": "api/Hi.Numerical.Xyzabc.CodeXyzabcChain.html",
    "title": "Class CodeXyzabcChain | HiAPI-C# 2025",
    "summary": "Class CodeXyzabcChain Namespace Hi.Numerical.Xyzabc Assembly HiMech.dll A GeneralXyzabcChain authored through chain code — a bracket notation for the connectivity of the mechanism's branches. On purpose of easy XML hand management. The entity is the inherited GeneralMechanism; ChainCodes is a delegated representation: reading derives the codes from the mechanism's topology, assigning reseeds the mechanism (transformers and solids of same-named components carry over). Notation: each segment declares branches left to right — [O][Y];[Y][X];[X][w] pairs, or the concatenated sugar [O][Y][X][w]. Words merge by name across segments; [] is an anonymous component (each occurrence is a fresh one). Reserved words: X,Y,Z translational axes, A,B,C rotational axes, w table buckle, t tool buckle; any other word is a plain component. public class CodeXyzabcChain : GeneralXyzabcChain, IXyzabcChain, IGetXyzabcChain, IMachiningChain, IGetAsmb, IGetAnchor, IGetTopoIndex, IGetAnchorToSolidDictionary, IGetAnchoredDisplayeeList, IExpandToBox3d, IMakeXmlSource Inheritance object GeneralXyzabcChain CodeXyzabcChain Implements IXyzabcChain IGetXyzabcChain IMachiningChain IGetAsmb IGetAnchor IGetTopoIndex IGetAnchorToSolidDictionary IGetAnchoredDisplayeeList IExpandToBox3d IMakeXmlSource Inherited Members GeneralXyzabcChain.Asmb GeneralXyzabcChain.TransformerX GeneralXyzabcChain.TransformerY GeneralXyzabcChain.TransformerZ GeneralXyzabcChain.TransformerA GeneralXyzabcChain.TransformerB GeneralXyzabcChain.TransformerC GeneralXyzabcChain.TableBuckleTransformer GeneralXyzabcChain.ToolBuckleTransformer GeneralXyzabcChain.GeneralMechanismFile GeneralXyzabcChain.GeneralMechanism GeneralXyzabcChain.UpdateByMechanism() GeneralXyzabcChain.GetAsmb() GeneralXyzabcChain.GetTableBuckle() GeneralXyzabcChain.GetToolBuckle() GeneralXyzabcChain.GetTransformerA() GeneralXyzabcChain.GetTransformerB() GeneralXyzabcChain.GetTransformerC() GeneralXyzabcChain.GetTransformerX() GeneralXyzabcChain.GetTransformerY() GeneralXyzabcChain.GetTransformerZ() GeneralXyzabcChain.McCodes GeneralXyzabcChain.McTransformers GeneralXyzabcChain.GetXyzabcChain() GeneralXyzabcChain.GetAnchor() GeneralXyzabcChain.GetAnchorToSolidDictionary() GeneralXyzabcChain.ExpandToBox3d(Box3d) GeneralXyzabcChain.GetAnchoredDisplayeeList() object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods MachiningChainUtil.GetMcCodeTransformerDictionary(IMachiningChain) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) XyzabcUtil.GenerateCollisionIndexPairs(IXyzabcChain) XyzabcUtil.GetMc(IXyzabcChain, out DVec3d) XyzabcUtil.GetMc(IXyzabcChain, out double, out double, out double, out double, out double, out double) XyzabcUtil.GetMcAbc_rad(IXyzabcChain, out Abc) XyzabcUtil.GetMcXyzabc(IXyzabcChain) XyzabcUtil.GetNp(IXyzabcChain) XyzabcUtil.GetTransformationMat4d(IXyzabcChain) XyzabcUtil.RequireEndAnchor(IXyzabcChain, IGetAnchor, string, string) XyzabcUtil.RequireEndAnchors(IXyzabcChain) XyzabcUtil.SetMc(IXyzabcChain, DVec3d) XyzabcUtil.SetMc(IXyzabcChain, Vec3d) XyzabcUtil.SetMc(IXyzabcChain, double, double, double) XyzabcUtil.SetMc(IXyzabcChain, double, double, double, double, double, double) XyzabcUtil.SetMcAbc_rad(IXyzabcChain, Vec3d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CodeXyzabcChain(string) Initializes a new instance seeded from the given chain code. public CodeXyzabcChain(string chainCode = \"[O][Z][C][w];[O][Y][X][B][S][t]\") Parameters chainCode string Semicolon-separated branch segments; see the class summary for the notation. CodeXyzabcChain(string, bool) Legacy overload keeping the retired vertical/horizontal flag working. [Obsolete(\"IsVertical is a legacy orientation shim. Author the ground rotation in the GeneralMechanism instead.\")] public CodeXyzabcChain(string chainCode, bool isVertical) Parameters chainCode string Semicolon-separated branch segments. isVertical bool Legacy orientation flag; false lays the machine down via a hidden root rotation. CodeXyzabcChain(XElement, string, string, IProgress<IMessage>) Initializes a new instance of the CodeXyzabcChain class from XML. public CodeXyzabcChain(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress) Parameters src XElement The XML source element. baseDirectory string The base directory for resolving relative paths. relFile string The relative file path. progress IProgress<IMessage> The progress reporter. Fields DefaultChainCode The classic 5-axis table-tilting layout used when no chain code is given. public const string DefaultChainCode = \"[O][Z][C][w];[O][Y][X][B][S][t]\" Field Value string Properties AnchorToSolid Gets or sets the dictionary mapping anchors to solids for display purposes — the mechanism's dictionary. Assigning copies the entries into it (the mechanism stays the owner). The compact wire format keys solids by component name, so a solid attached to an anonymous [] component is not persisted — name the component if its solid must survive a save. public Dictionary<Anchor, Solid> AnchorToSolid { get; set; } Property Value Dictionary<Anchor, Solid> ChainBegin Gets the chain begin anchor (the table buckle). public Anchor ChainBegin { get; } Property Value Anchor ChainCode The semicolon-joined form of ChainCodes. public string ChainCode { get; } Property Value string ChainCodes The chain code segments — a delegated representation of the mechanism's connectivity. Reading derives them (table-buckle segment first, then the tool-buckle one, then any others); assigning reseeds the mechanism, carrying over the transformers and solids of same-named components. public IReadOnlyList<string> ChainCodes { get; set; } Property Value IReadOnlyList<string> ChainEnd Gets the chain end anchor (the tool buckle). public Anchor ChainEnd { get; } Property Value Anchor CodeToAnc Gets the dictionary mapping component words to anchors — derived from the mechanism; the legacy horizontal shim's hidden root is excluded. public Dictionary<string, Anchor> CodeToAnc { get; } Property Value Dictionary<string, Anchor> ComponentCodes_O2T Gets the list of component words from the code view root to the tool buckle. public List<string> ComponentCodes_O2T { get; } Property Value List<string> ComponentCodes_O2W Gets the list of component words from the code view root to the table buckle. public List<string> ComponentCodes_O2W { get; } Property Value List<string> RootAnchor Gets the root anchor of the XYZABC chain. public Anchor RootAnchor { get; } Property Value Anchor XName Gets the XML element name for serialization. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public override XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Numerical.Xyzabc.GeneralXyzabcChain.html": {
    "href": "api/Hi.Numerical.Xyzabc.GeneralXyzabcChain.html",
    "title": "Class GeneralXyzabcChain | HiAPI-C# 2025",
    "summary": "Class GeneralXyzabcChain Namespace Hi.Numerical.Xyzabc Assembly HiMech.dll Represents a general XYZABC chain that can be constructed from a general mechanism. public class GeneralXyzabcChain : IXyzabcChain, IGetXyzabcChain, IMachiningChain, IGetAsmb, IGetAnchor, IGetTopoIndex, IGetAnchorToSolidDictionary, IGetAnchoredDisplayeeList, IExpandToBox3d, IMakeXmlSource Inheritance object GeneralXyzabcChain Implements IXyzabcChain IGetXyzabcChain IMachiningChain IGetAsmb IGetAnchor IGetTopoIndex IGetAnchorToSolidDictionary IGetAnchoredDisplayeeList IExpandToBox3d IMakeXmlSource Derived CodeXyzabcChain Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods MachiningChainUtil.GetMcCodeTransformerDictionary(IMachiningChain) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) XyzabcUtil.GenerateCollisionIndexPairs(IXyzabcChain) XyzabcUtil.GetMc(IXyzabcChain, out DVec3d) XyzabcUtil.GetMc(IXyzabcChain, out double, out double, out double, out double, out double, out double) XyzabcUtil.GetMcAbc_rad(IXyzabcChain, out Abc) XyzabcUtil.GetMcXyzabc(IXyzabcChain) XyzabcUtil.GetNp(IXyzabcChain) XyzabcUtil.GetTransformationMat4d(IXyzabcChain) XyzabcUtil.RequireEndAnchor(IXyzabcChain, IGetAnchor, string, string) XyzabcUtil.RequireEndAnchors(IXyzabcChain) XyzabcUtil.SetMc(IXyzabcChain, DVec3d) XyzabcUtil.SetMc(IXyzabcChain, Vec3d) XyzabcUtil.SetMc(IXyzabcChain, double, double, double) XyzabcUtil.SetMc(IXyzabcChain, double, double, double, double, double, double) XyzabcUtil.SetMcAbc_rad(IXyzabcChain, Vec3d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors GeneralXyzabcChain(GeneralMechanism) Initializes a new instance of the GeneralXyzabcChain class with the specified general mechanism. public GeneralXyzabcChain(GeneralMechanism generalMechanism) Parameters generalMechanism GeneralMechanism The general mechanism to use for the chain. GeneralXyzabcChain(XElement, string, IProgress<IMessage>) Initializes a new instance of the GeneralXyzabcChain class from XML. public GeneralXyzabcChain(XElement src, string baseDirectory, IProgress<IMessage> progress) Parameters src XElement The XML source element. baseDirectory string The base directory for resolving relative paths. progress IProgress<IMessage> Progress reporter for loading the nested mechanism. Properties Asmb Asmb. public Asmb Asmb { get; } Property Value Asmb GeneralMechanism The mechanism this chain reads — the entity holding the topology, transformers and solids. Assigning a different instance re-runs UpdateByMechanism(). public GeneralMechanism GeneralMechanism { get; set; } Property Value GeneralMechanism GeneralMechanismFile Gets or sets the file path for the general mechanism. public string GeneralMechanismFile { get; set; } Property Value string McCodes Gets the machine coordinate code sequence for decoding the MC array. public string[] McCodes { get; } Property Value string[] McTransformers Gets the machine coordinate transformers. public IDynamicRegular[] McTransformers { get; } Property Value IDynamicRegular[] TableBuckleTransformer Gets or sets the static transformer for the table buckle. Hosted on the unique branch arriving at the “w” anchor; null when the mechanism has no such branch. public IStaticTransformer TableBuckleTransformer { get; set; } Property Value IStaticTransformer ToolBuckleTransformer Gets or sets the static transformer for the tool buckle. Hosted on the unique branch arriving at the “t” anchor; null when the mechanism has no such branch. public IStaticTransformer ToolBuckleTransformer { get; set; } Property Value IStaticTransformer TransformerA Transformer A. public DynamicRotation TransformerA { get; } Property Value DynamicRotation TransformerB Transformer B. public DynamicRotation TransformerB { get; } Property Value DynamicRotation TransformerC Transformer C. public DynamicRotation TransformerC { get; } Property Value DynamicRotation TransformerX Transformer X. public DynamicTranslation TransformerX { get; } Property Value DynamicTranslation TransformerY Transformer Y. public DynamicTranslation TransformerY { get; } Property Value DynamicTranslation TransformerZ Transformer Z. public DynamicTranslation TransformerZ { get; } Property Value DynamicTranslation XName Gets the XML element name for serialization. public static string XName { get; } Property Value string Methods ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor GetAnchorToSolidDictionary() Gets a dictionary that maps Anchor objects to their corresponding Solid objects. public Dictionary<Anchor, Solid> GetAnchorToSolidDictionary() Returns Dictionary<Anchor, Solid> A dictionary where keys are anchors and values are their associated solids. GetAnchoredDisplayeeList() Gets a list of anchored displayable objects. public List<IAnchoredDisplayee> GetAnchoredDisplayeeList() Returns List<IAnchoredDisplayee> A list of IAnchoredDisplayee objects GetAsmb() Gets the key asmb. public Asmb GetAsmb() Returns Asmb The key asmb. GetTableBuckle() Gets the table buckle anchor point. public IGetAnchor GetTableBuckle() Returns IGetAnchor The table buckle anchor point. GetToolBuckle() Gets the tool buckle anchor point. public IGetAnchor GetToolBuckle() Returns IGetAnchor The tool buckle anchor point. GetTransformerA() Get transformer A. public DynamicRotation GetTransformerA() Returns DynamicRotation transformer A GetTransformerB() Get transformer B. public DynamicRotation GetTransformerB() Returns DynamicRotation transformer B GetTransformerC() Get transformer C. public DynamicRotation GetTransformerC() Returns DynamicRotation transformer C GetTransformerX() Get transformer X. public DynamicTranslation GetTransformerX() Returns DynamicTranslation transformer X GetTransformerY() Get transformer Y. public DynamicTranslation GetTransformerY() Returns DynamicTranslation transformer Y GetTransformerZ() Get transformer Z. public DynamicTranslation GetTransformerZ() Returns DynamicTranslation transformer Z GetXyzabcChain() Get IXyzabcChain. public IXyzabcChain GetXyzabcChain() Returns IXyzabcChain IXyzabcChain MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public virtual XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory UpdateByMechanism() Updates the XYZABC chain components based on the current general mechanism. public void UpdateByMechanism() Remarks Names are matched EXACTLY: the motion-axis branches are upper-case X / Y / Z / A / B / C, and the two end anchors are lower-case t (tool end) and w (worktable end). A name differing only in case names nothing, so the axis or buckle it was meant to be stays null. XyzabcUtil strips the same canonical spellings — O, base, t, w — when it generates the default collision pairs, so the vocabulary reads one way everywhere."
  },
  "api/Hi.Numerical.Xyzabc.IGetMcXyzabc.html": {
    "href": "api/Hi.Numerical.Xyzabc.IGetMcXyzabc.html",
    "title": "Interface IGetMcXyzabc | HiAPI-C# 2025",
    "summary": "Interface IGetMcXyzabc Namespace Hi.Numerical.Xyzabc Assembly HiMech.dll Interface of GetMcXyzabc(). public interface IGetMcXyzabc Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetMcXyzabc() Get McXyzabc. ABC is in radian. DVec3d GetMcXyzabc() Returns DVec3d machine coordinate."
  },
  "api/Hi.Numerical.Xyzabc.IGetXyzabcChain.html": {
    "href": "api/Hi.Numerical.Xyzabc.IGetXyzabcChain.html",
    "title": "Interface IGetXyzabcChain | HiAPI-C# 2025",
    "summary": "Interface IGetXyzabcChain Namespace Hi.Numerical.Xyzabc Assembly HiMech.dll Interface of get IXyzabcChain. public interface IGetXyzabcChain Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetXyzabcChain() Get IXyzabcChain. IXyzabcChain GetXyzabcChain() Returns IXyzabcChain IXyzabcChain"
  },
  "api/Hi.Numerical.Xyzabc.IMachineKinematics.html": {
    "href": "api/Hi.Numerical.Xyzabc.IMachineKinematics.html",
    "title": "Interface IMachineKinematics | HiAPI-C# 2025",
    "summary": "Interface IMachineKinematics Namespace Hi.Numerical.Xyzabc Assembly HiMech.dll Device for UniNc controller. public interface IMachineKinematics Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods McAbcToMat(Vec3d) Converts machine ABC coordinates to a tilt matrix. the tilt matrix is the transformation matrix from table to attacher. Mat4d McAbcToMat(Vec3d mcAbc_rad) Parameters mcAbc_rad Vec3d The machine ABC coordinates in radians Returns Mat4d The tilt matrix McToMat(DVec3d) Converts machine coordinates to an attacher matrix. Mat4d McToMat(DVec3d mcXyzabc) Parameters mcXyzabc DVec3d The machine coordinates Returns Mat4d The attacher matrix McToPn(DVec3d) Machine coordinate to tool attacher Pn (Point and Normal). The Pn is from table buckle to tool attacher. DVec3d McToPn(DVec3d mcXyzabc) Parameters mcXyzabc DVec3d machine coordinate. ABC is in radian. Returns DVec3d tool attacher Pn (Point and Normal) OrientationToMcAbc(Mat4d, out Vec3d) Converts a tilt matrix to machine ABC coordinates. the tilt matrix is the transformation matrix from table to attacher. the solution only fit the orientation part of the tiltMat. bool OrientationToMcAbc(Mat4d tiltMat, out Vec3d mcAbc_rad) Parameters tiltMat Mat4d The tilt matrix to convert mcAbc_rad Vec3d Output parameter that will contain the machine ABC coordinates in radians Returns bool Whether the conversion was successful OrientationToMcAbc(Vec3d, out Vec3d) Converts a target tool axial direction (endpoint orientation) to machine ABC coordinates. Only the axial alignment is constrained; rotation about the tool axis is free. Use this in place of OrientationToMcAbc(Mat4d, out Vec3d) when the rotation about the tool axis is irrelevant (e.g. G53.1 rotary positioning). The axial-only solve avoids the redundant 6-target full-matrix constraint and is more likely to converge for tilt configurations such as G68.2 I180 J90 K0. bool OrientationToMcAbc(Vec3d toolAxialNormal, out Vec3d mcAbc_rad) Parameters toolAxialNormal Vec3d Target tool axial direction in table coordinates (the third row of the tilt matrix; e.g. AxialNormal). mcAbc_rad Vec3d Output machine ABC coordinates in radians. Returns bool Whether the conversion was successful. PnToMc(DVec3d, out DVec3d) Tool attacher Pn (Point and Normal) to machine coordinate. The Pn is from table buckle to tool attacher. bool PnToMc(DVec3d pn, out DVec3d mcXyzabc_rad) Parameters pn DVec3d tool attacher Pn (Point and Normal) mcXyzabc_rad DVec3d machine coordinate (ABC in radian) Returns bool whether conversion succeeded"
  },
  "api/Hi.Numerical.Xyzabc.ISetMcXyzabc.html": {
    "href": "api/Hi.Numerical.Xyzabc.ISetMcXyzabc.html",
    "title": "Interface ISetMcXyzabc | HiAPI-C# 2025",
    "summary": "Interface ISetMcXyzabc Namespace Hi.Numerical.Xyzabc Assembly HiMech.dll Abstraction for components that accept a full machine-coordinate pose (XYZ linear + ABC rotary). public interface ISetMcXyzabc Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods SetMcXyzabc(DVec3d) Writes the current MC pose into the implementation (linear metres, rotary radians). void SetMcXyzabc(DVec3d mcXyzabc) Parameters mcXyzabc DVec3d Machine position and orientation."
  },
  "api/Hi.Numerical.Xyzabc.IXyzabcChain.html": {
    "href": "api/Hi.Numerical.Xyzabc.IXyzabcChain.html",
    "title": "Interface IXyzabcChain | HiAPI-C# 2025",
    "summary": "Interface IXyzabcChain Namespace Hi.Numerical.Xyzabc Assembly HiMech.dll A single chain contains subset transformers of {X,Y,Z,A,B,C} . public interface IXyzabcChain : IGetXyzabcChain, IMachiningChain, IGetAsmb, IGetAnchor, IGetTopoIndex, IMakeXmlSource, IGetAnchorToSolidDictionary, IGetAnchoredDisplayeeList, IExpandToBox3d Inherited Members IGetXyzabcChain.GetXyzabcChain() IMachiningChain.GetTableBuckle() IMachiningChain.GetToolBuckle() IMachiningChain.McCodes IMachiningChain.McTransformers IGetAsmb.GetAsmb() IGetAnchor.GetAnchor() IMakeXmlSource.MakeXmlSource(string, string, bool) IGetAnchorToSolidDictionary.GetAnchorToSolidDictionary() IGetAnchorToSolidDictionary.PrepareAnchorSolids() IGetAnchoredDisplayeeList.GetAnchoredDisplayeeList() IExpandToBox3d.ExpandToBox3d(Box3d) Extension Methods MachiningChainUtil.GetMcCodeTransformerDictionary(IMachiningChain) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) XyzabcUtil.GenerateCollisionIndexPairs(IXyzabcChain) XyzabcUtil.GetMc(IXyzabcChain, out DVec3d) XyzabcUtil.GetMc(IXyzabcChain, out double, out double, out double, out double, out double, out double) XyzabcUtil.GetMcAbc_rad(IXyzabcChain, out Abc) XyzabcUtil.GetMcXyzabc(IXyzabcChain) XyzabcUtil.GetNp(IXyzabcChain) XyzabcUtil.GetTransformationMat4d(IXyzabcChain) XyzabcUtil.RequireEndAnchor(IXyzabcChain, IGetAnchor, string, string) XyzabcUtil.RequireEndAnchors(IXyzabcChain) XyzabcUtil.SetMc(IXyzabcChain, DVec3d) XyzabcUtil.SetMc(IXyzabcChain, Vec3d) XyzabcUtil.SetMc(IXyzabcChain, double, double, double) XyzabcUtil.SetMc(IXyzabcChain, double, double, double, double, double, double) XyzabcUtil.SetMcAbc_rad(IXyzabcChain, Vec3d) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetTransformerA() Get transformer A. DynamicRotation GetTransformerA() Returns DynamicRotation transformer A GetTransformerAbc() Rotary column transformers A, B, C in chain order (entries may be null if an axis is absent). IDynamicRotation[] GetTransformerAbc() Returns IDynamicRotation[] GetTransformerB() Get transformer B. DynamicRotation GetTransformerB() Returns DynamicRotation transformer B GetTransformerC() Get transformer C. DynamicRotation GetTransformerC() Returns DynamicRotation transformer C GetTransformerX() Get transformer X. DynamicTranslation GetTransformerX() Returns DynamicTranslation transformer X GetTransformerXyz() Linear column transformers X, Y, Z in chain order. DynamicTranslation[] GetTransformerXyz() Returns DynamicTranslation[] GetTransformerY() Get transformer Y. DynamicTranslation GetTransformerY() Returns DynamicTranslation transformer Y GetTransformerZ() Get transformer Z. DynamicTranslation GetTransformerZ() Returns DynamicTranslation transformer Z"
  },
  "api/Hi.Numerical.Xyzabc.ReflectedXyzabcChain.html": {
    "href": "api/Hi.Numerical.Xyzabc.ReflectedXyzabcChain.html",
    "title": "Class ReflectedXyzabcChain | HiAPI-C# 2025",
    "summary": "Class ReflectedXyzabcChain Namespace Hi.Numerical.Xyzabc Assembly HiMech.dll Cloned CodeXyzabcChain. public class ReflectedXyzabcChain : IXyzabcChain, IGetXyzabcChain, IMachiningChain, IGetAsmb, IGetAnchor, IGetTopoIndex, IMakeXmlSource, IGetAnchorToSolidDictionary, IGetAnchoredDisplayeeList, IExpandToBox3d Inheritance object ReflectedXyzabcChain Implements IXyzabcChain IGetXyzabcChain IMachiningChain IGetAsmb IGetAnchor IGetTopoIndex IMakeXmlSource IGetAnchorToSolidDictionary IGetAnchoredDisplayeeList IExpandToBox3d Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods MachiningChainUtil.GetMcCodeTransformerDictionary(IMachiningChain) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) XyzabcUtil.GenerateCollisionIndexPairs(IXyzabcChain) XyzabcUtil.GetMc(IXyzabcChain, out DVec3d) XyzabcUtil.GetMc(IXyzabcChain, out double, out double, out double, out double, out double, out double) XyzabcUtil.GetMcAbc_rad(IXyzabcChain, out Abc) XyzabcUtil.GetMcXyzabc(IXyzabcChain) XyzabcUtil.GetNp(IXyzabcChain) XyzabcUtil.GetTransformationMat4d(IXyzabcChain) XyzabcUtil.RequireEndAnchor(IXyzabcChain, IGetAnchor, string, string) XyzabcUtil.RequireEndAnchors(IXyzabcChain) XyzabcUtil.SetMc(IXyzabcChain, DVec3d) XyzabcUtil.SetMc(IXyzabcChain, Vec3d) XyzabcUtil.SetMc(IXyzabcChain, double, double, double) XyzabcUtil.SetMc(IXyzabcChain, double, double, double, double, double, double) XyzabcUtil.SetMcAbc_rad(IXyzabcChain, Vec3d) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ReflectedXyzabcChain(IXyzabcChain) Creates a reflected XYZABC chain from a source chain. public ReflectedXyzabcChain(IXyzabcChain src) Parameters src IXyzabcChain The source XYZABC chain. Remarks Both end anchors are required up front through RequireEndAnchors(IXyzabcChain), so a chain missing one fails with the keyword named instead of with a NullReferenceException three frames deeper. Exceptions InvalidOperationException Either end anchor is missing. Properties AnchorToSolid Dictionary mapping anchors to solids. public Dictionary<Anchor, Solid> AnchorToSolid { get; set; } Property Value Dictionary<Anchor, Solid> Asmb The assembly. public Asmb Asmb { get; } Property Value Asmb ChainBegin The beginning anchor of the chain. public Anchor ChainBegin { get; } Property Value Anchor ChainEnd The ending anchor of the chain. public Anchor ChainEnd { get; } Property Value Anchor McCodes Gets the machine coordinate code sequence for decoding the MC array. public string[] McCodes { get; } Property Value string[] McTransformers Gets the machine coordinate transformers. public IDynamicRegular[] McTransformers { get; } Property Value IDynamicRegular[] RootAnchor The root anchor. public Anchor RootAnchor { get; } Property Value Anchor SourceChain Source. public IXyzabcChain SourceChain { get; } Property Value IXyzabcChain TopoReflection Topology reflection. public TopoReflection TopoReflection { get; } Property Value TopoReflection TransformerA The A-axis transformer. public DynamicRotation TransformerA { get; } Property Value DynamicRotation TransformerB The B-axis transformer. public DynamicRotation TransformerB { get; } Property Value DynamicRotation TransformerC The C-axis transformer. public DynamicRotation TransformerC { get; } Property Value DynamicRotation TransformerX The X-axis transformer. public DynamicTranslation TransformerX { get; } Property Value DynamicTranslation TransformerY The Y-axis transformer. public DynamicTranslation TransformerY { get; } Property Value DynamicTranslation TransformerZ The Z-axis transformer. public DynamicTranslation TransformerZ { get; } Property Value DynamicTranslation XName Name for XML serialization. public static string XName { get; } Property Value string Methods ExpandToBox3d(Box3d) Expands the destination box. This function is usually used to compute the bounding box of elements. public void ExpandToBox3d(Box3d dst) Parameters dst Box3d Destination box GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor GetAnchorToSolidDictionary() Gets a dictionary that maps Anchor objects to their corresponding Solid objects. public Dictionary<Anchor, Solid> GetAnchorToSolidDictionary() Returns Dictionary<Anchor, Solid> A dictionary where keys are anchors and values are their associated solids. GetAnchoredDisplayeeList() Gets a list of anchored displayable objects. public List<IAnchoredDisplayee> GetAnchoredDisplayeeList() Returns List<IAnchoredDisplayee> A list of IAnchoredDisplayee objects GetAsmb() Gets the key asmb. public Asmb GetAsmb() Returns Asmb The key asmb. GetTableBuckle() Gets the table buckle anchor point. public IGetAnchor GetTableBuckle() Returns IGetAnchor The table buckle anchor point. GetToolBuckle() Gets the tool buckle anchor point. public IGetAnchor GetToolBuckle() Returns IGetAnchor The tool buckle anchor point. GetTransformerA() Get transformer A. public DynamicRotation GetTransformerA() Returns DynamicRotation transformer A GetTransformerB() Get transformer B. public DynamicRotation GetTransformerB() Returns DynamicRotation transformer B GetTransformerC() Get transformer C. public DynamicRotation GetTransformerC() Returns DynamicRotation transformer C GetTransformerX() Get transformer X. public DynamicTranslation GetTransformerX() Returns DynamicTranslation transformer X GetTransformerY() Get transformer Y. public DynamicTranslation GetTransformerY() Returns DynamicTranslation transformer Y GetTransformerZ() Get transformer Z. public DynamicTranslation GetTransformerZ() Returns DynamicTranslation transformer Z GetXyzabcChain() Get IXyzabcChain. public IXyzabcChain GetXyzabcChain() Returns IXyzabcChain IXyzabcChain MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file."
  },
  "api/Hi.Numerical.Xyzabc.XyzabcSolver.html": {
    "href": "api/Hi.Numerical.Xyzabc.XyzabcSolver.html",
    "title": "Class XyzabcSolver | HiAPI-C# 2025",
    "summary": "Class XyzabcSolver Namespace Hi.Numerical.Xyzabc Assembly HiMech.dll Support to two-way conversion between MC (machine coordinate) and NP (Normal and Point). public class XyzabcSolver : IMachineKinematics Inheritance object XyzabcSolver Implements IMachineKinematics Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors XyzabcSolver(IXyzabcChain) Ctor. public XyzabcSolver(IXyzabcChain srcDevice) Parameters srcDevice IXyzabcChain target device Methods IsAxisAExisted() Whether rotary column A exists on this chain (non-null transformer). public bool IsAxisAExisted() Returns bool IsAxisBExisted() Whether rotary column B exists on this chain (non-null transformer). public bool IsAxisBExisted() Returns bool IsAxisCExisted() Whether rotary column C exists on this chain (non-null transformer). public bool IsAxisCExisted() Returns bool McAbcToMat(Vec3d) Converts machine ABC coordinates to a tilt matrix. the tilt matrix is the transformation matrix from table to attacher. public Mat4d McAbcToMat(Vec3d mcAbc_rad) Parameters mcAbc_rad Vec3d The machine ABC coordinates in radians Returns Mat4d The tilt matrix McToMat(DVec3d) Converts machine coordinates to an attacher matrix. public Mat4d McToMat(DVec3d mc) Parameters mc DVec3d Returns Mat4d The attacher matrix McToPn(DVec3d) Machine coordinate to tool attacher Pn (Point and Normal). The Pn is from table buckle to tool attacher. public DVec3d McToPn(DVec3d mc) Parameters mc DVec3d Returns DVec3d tool attacher Pn (Point and Normal) OrientationToMcAbc(Mat4d, out Vec3d) Converts a tilt matrix to machine ABC coordinates. the tilt matrix is the transformation matrix from table to attacher. the solution only fit the orientation part of the tiltMat. public bool OrientationToMcAbc(Mat4d tiltMat, out Vec3d mcAbc_rad) Parameters tiltMat Mat4d The tilt matrix to convert mcAbc_rad Vec3d Output parameter that will contain the machine ABC coordinates in radians Returns bool Whether the conversion was successful OrientationToMcAbc(Vec3d, out Vec3d) Converts a target tool axial direction (endpoint orientation) to machine ABC coordinates. Only the axial alignment is constrained; rotation about the tool axis is free. Use this in place of OrientationToMcAbc(Mat4d, out Vec3d) when the rotation about the tool axis is irrelevant (e.g. G53.1 rotary positioning). The axial-only solve avoids the redundant 6-target full-matrix constraint and is more likely to converge for tilt configurations such as G68.2 I180 J90 K0. public bool OrientationToMcAbc(Vec3d toolAxialNormal, out Vec3d mcAbc_rad) Parameters toolAxialNormal Vec3d Target tool axial direction in table coordinates (the third row of the tilt matrix; e.g. AxialNormal). mcAbc_rad Vec3d Output machine ABC coordinates in radians. Returns bool Whether the conversion was successful. PnToMc(DVec3d, out DVec3d) Tool attacher Pn (Point and Normal) to machine coordinate. The Pn is from table buckle to tool attacher. public bool PnToMc(DVec3d np, out DVec3d mcXyzabc_rad) Parameters np DVec3d mcXyzabc_rad DVec3d machine coordinate (ABC in radian) Returns bool whether conversion succeeded Rebuild() Rebuild the solver. It should be called after the kinematic chain of Hi.Numerical.Xyzabc.XyzabcSolver.SrcDevice is modified. public void Rebuild() SetPn(DVec3d, out DVec3d) Cutter location to machine coordinate. On failure nothing is written back and the solver state (the implicit seed of the next solve) is restored to what it was on entry; the out value still reports the failed solve's parameters. public bool SetPn(DVec3d pn, out DVec3d mc) Parameters pn DVec3d normal and point mc DVec3d Resolved machine position (XYZ + ABC radians). Returns bool true if solved"
  },
  "api/Hi.Numerical.Xyzabc.XyzabcUtil.html": {
    "href": "api/Hi.Numerical.Xyzabc.XyzabcUtil.html",
    "title": "Class XyzabcUtil | HiAPI-C# 2025",
    "summary": "Class XyzabcUtil Namespace Hi.Numerical.Xyzabc Assembly HiMech.dll Utility of XYZABC device. public static class XyzabcUtil Inheritance object XyzabcUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods BuildAnchorToSolid(Dictionary<Anchor, Solid>, List<Anchor>, Dictionary<string, Solid>) Builds a dictionary mapping anchors to solids. public static void BuildAnchorToSolid(this Dictionary<Anchor, Solid> dstAnchorToSolidDictionary, List<Anchor> anchors, Dictionary<string, Solid> keyToSolid) Parameters dstAnchorToSolidDictionary Dictionary<Anchor, Solid> The destination dictionary to populate anchors List<Anchor> List of anchors keyToSolid Dictionary<string, Solid> Dictionary mapping anchor names to solids GenerateCollisionIndexPairs(IXyzabcChain) Generate collision index pairs for the XYZABC chain. public static List<CollisionIndexPair> GenerateCollisionIndexPairs(this IXyzabcChain xyzabcChain) Parameters xyzabcChain IXyzabcChain The XYZABC chain Returns List<CollisionIndexPair> List of collision index pairs Remarks The pairs are read off the two anchor chains from the ground anchor to the tool end and to the worktable end, so both end anchors must resolve; a chain missing one fails through RequireEndAnchors(IXyzabcChain) with the keyword named. This is the first consumer on the machine-file load path when the file says AutoGenerate. Exceptions InvalidOperationException An end anchor is missing. GetMc(IXyzabcChain, out DVec3d) Get machine coordinates. public static void GetMc(this IXyzabcChain device, out DVec3d mc) Parameters device IXyzabcChain The XYZABC device mc DVec3d Output machine coordinate as DVec3d GetMc(IXyzabcChain, out double, out double, out double, out double, out double, out double) Get machine coordinates. The output value set to NAN if the corresponding transformer does not exist. public static void GetMc(this IXyzabcChain device, out double mcX, out double mcY, out double mcZ, out double mcA, out double mcB, out double mcC) Parameters device IXyzabcChain device mcX double machine coordinate X mcY double machine coordinate Y mcZ double machine coordinate Z mcA double machine coordinate A (rad) mcB double machine coordinate B (rad) mcC double machine coordinate C (rad) GetMcAbc_rad(IXyzabcChain, out Abc) Get machine coordinates. The output value set to NAN if the corresponding transformer does not exist. public static void GetMcAbc_rad(this IXyzabcChain device, out Abc mcAbc_rad) Parameters device IXyzabcChain device mcAbc_rad Abc Output machine coordinates ABC in radians GetMcXyzabc(IXyzabcChain) Get machine coordinates as DVec3d. public static DVec3d GetMcXyzabc(this IXyzabcChain device) Parameters device IXyzabcChain The XYZABC device Returns DVec3d Machine coordinate as DVec3d. ABC in rad. GetNp(IXyzabcChain) Get normal and position from Hi.Numerical.Xyzabc.IXyzabcChain.GetChainBegin to Hi.Numerical.Xyzabc.IXyzabcChain.GetChainEnd. public static DVec3d GetNp(this IXyzabcChain src) Parameters src IXyzabcChain src Returns DVec3d normal and position GetTransformationMat4d(IXyzabcChain) Get transformation matrix from Hi.Numerical.Xyzabc.IXyzabcChain.GetChainBegin to Hi.Numerical.Xyzabc.IXyzabcChain.GetChainEnd. public static Mat4d GetTransformationMat4d(this IXyzabcChain src) Parameters src IXyzabcChain src Returns Mat4d transformation matrix RequireEndAnchor(IXyzabcChain, IGetAnchor, string, string) Fails with the name of the missing end anchor instead of with a NullReferenceException somewhere past it. public static void RequireEndAnchor(this IXyzabcChain src, IGetAnchor buckle, string keyword, string role) Parameters src IXyzabcChain The chain being validated. buckle IGetAnchor The end anchor accessor to validate. keyword string The exact anchor name the chain requires, t or w. role string The end's role, for the message. Remarks The topology keyword vocabulary is matched exactly — see UpdateByMechanism() — so a chain whose end anchor is spelled in another letter case has no end anchor at all. That is the one cause worth naming outright, because nothing else in the application points at letter case. Every consumer that dereferences a buckle unconditionally should pass through here first; the two today are GenerateCollisionIndexPairs(IXyzabcChain) (the machine-file load path, where AutoGenerate collision pairs walk from the ground anchor to each end) and ReflectedXyzabcChain (the solver). Exceptions InvalidOperationException The chain carries no such end anchor. RequireEndAnchors(IXyzabcChain) Requires both end anchors — the worktable end w and the tool end t — with RequireEndAnchor(IXyzabcChain, IGetAnchor, string, string). public static void RequireEndAnchors(this IXyzabcChain src) Parameters src IXyzabcChain The chain being validated. Exceptions InvalidOperationException Either end anchor is missing. SetMc(IXyzabcChain, DVec3d) Set machine coordinate. public static void SetMc(this IXyzabcChain device, DVec3d mc) Parameters device IXyzabcChain device mc DVec3d machine coordinate SetMc(IXyzabcChain, Vec3d) Set machine coordinate. public static void SetMc(this IXyzabcChain device, Vec3d mcXyz) Parameters device IXyzabcChain device mcXyz Vec3d Machine coordinate XYZ SetMc(IXyzabcChain, double, double, double) Set machine coordinate. The input value do no effect if the corresponding transformer does not exist. public static void SetMc(this IXyzabcChain device, double mcX, double mcY, double mcZ) Parameters device IXyzabcChain device mcX double machine coordinate X mcY double machine coordinate Y mcZ double machine coordinate Z SetMc(IXyzabcChain, double, double, double, double, double, double) Set machine coordinate. The input value do no effect if the corresponding transformer does not exist. public static void SetMc(this IXyzabcChain device, double mcX, double mcY, double mcZ, double mcA, double mcB, double mcC) Parameters device IXyzabcChain device mcX double machine coordinate X mcY double machine coordinate Y mcZ double machine coordinate Z mcA double machine coordinate A mcB double machine coordinate B mcC double machine coordinate C SetMcAbc_rad(IXyzabcChain, Vec3d) Set machine coordinate. The input value do no effect if the corresponding transformer does not exist. public static void SetMcAbc_rad(this IXyzabcChain device, Vec3d mcAbc_rad) Parameters device IXyzabcChain device mcAbc_rad Vec3d Machine coordinate ABC in radians"
  },
  "api/Hi.Numerical.Xyzabc.html": {
    "href": "api/Hi.Numerical.Xyzabc.html",
    "title": "Namespace Hi.Numerical.Xyzabc | HiAPI-C# 2025",
    "summary": "Namespace Hi.Numerical.Xyzabc Classes CodeXyzabcChain A GeneralXyzabcChain authored through chain code — a bracket notation for the connectivity of the mechanism's branches. On purpose of easy XML hand management. The entity is the inherited GeneralMechanism; ChainCodes is a delegated representation: reading derives the codes from the mechanism's topology, assigning reseeds the mechanism (transformers and solids of same-named components carry over). Notation: each segment declares branches left to right — [O][Y];[Y][X];[X][w] pairs, or the concatenated sugar [O][Y][X][w]. Words merge by name across segments; [] is an anonymous component (each occurrence is a fresh one). Reserved words: X,Y,Z translational axes, A,B,C rotational axes, w table buckle, t tool buckle; any other word is a plain component. GeneralXyzabcChain Represents a general XYZABC chain that can be constructed from a general mechanism. ReflectedXyzabcChain Cloned CodeXyzabcChain. XyzabcSolver Support to two-way conversion between MC (machine coordinate) and NP (Normal and Point). XyzabcUtil Utility of XYZABC device. Structs Abc Represents a three-axis rotational configuration in ABC coordinates. Interfaces IGetMcXyzabc Interface of GetMcXyzabc(). IGetXyzabcChain Interface of get IXyzabcChain. IMachineKinematics Device for UniNc controller. ISetMcXyzabc Abstraction for components that accept a full machine-coordinate pose (XYZ linear + ABC rotary). IXyzabcChain A single chain contains subset transformers of {X,Y,Z,A,B,C} ."
  },
  "api/Hi.Numerical.html": {
    "href": "api/Hi.Numerical.html",
    "title": "Namespace Hi.Numerical | HiAPI-C# 2025",
    "summary": "Namespace Hi.Numerical Classes FlexDictionaryUtil Utility for flexible dictionary operations. HardNcComment Represents a comment in NC code. HardNcEnv Represents the numerical control environment containing configuration for CNC operations. HardNcLine Represents a line in the NC program with its associated data and operations. HardNcUtil Utility class for working with NC code. MechNcUtil NC Utility. MillingToolOffsetTable Offset table for milling tool. The key is Offset ID (H or D in NC code). MillingToolOffsetTableRow Raw of MillingToolOffsetTable NcFlagUtil Utility class for working with NC flags and their lifecycle modes. NcGroupAttribute NC Group Attribute. NcLifeCycleAttribute Attribute to specify the lifecycle mode of an NC flag. NcNameAttribute Attribute used to define a name for NC flags and other enumeration fields. NcNoteCache Cache for notes and warnings generated during NC line parsing. NcProc Provides processing utilities for NC programming. NumericUtil Utility class for numeric operations and unit conversions. PolarEntry The class for G12.1 Polar mode. In G12.1 Polar mode, NC code applies (X,C) as (linear axis, hypothetical axis). XC, YA, ZB are available. RadiusCompensationBuf Buffer for radius compensation (G41/G42) operations in numerical control. At each line junction, the offset paths of adjacent lines may form an intersection (intersected rays) or align directly (parallel rays). For straight lines, the tool goes to the intersection point. For arcs, the offset curve doesn't pass through the intersection, so transient points bridge the gap: Arc → TransientEnd → (linear) → Intersection → (linear) → TransientBegin → NextArc. Transient properties are null when rays are parallel (offset paths align, no corner needed) or when the adjacent line is not an arc. SourcedActEntry Represents an entry containing a source command and its associated act. SubStringKit Utility class for extracting and manipulating substrings based on specific activation patterns. ToolConfigNotFoundException Exception thrown when a tool configuration cannot be found. Interfaces IFlexDictionaryHost<T> Interface of FlexDictionary. Provider of additional quantity source. IGetFeedrate Interface for retrieving feedrate information. IGetSpindleSpeed Interface for retrieving spindle speed and direction information. INcRunner NC runner — parses and executes NC program lines. Nc is the umbrella term for any machine-readable control program (famous-brand controller code, NX-CL, CSV): the same runner contract serves all of them, and NcKind names the kinds where they must be distinguished. ISetFeedrate Interface for setting feedrate information. ISetSpindleSpeed Interface for setting spindle speed. Enums CncBrand Represents different CNC controller brands supported by the system. CommentMark Enumeration of different comment mark types used in NC code. CoolantMode Cutting-fluid delivery mode parsed from typical NC coolant machine functions (e.g. M07 / M08 / M09). Values are consumed by higher-level machining simulation and thermal models that map each mode to convection and temperature assumptions. CoordinateInterpolationMode Defines the coordinate interpolation mode for NC operations. NcFlag NC Flag. NcGroup00 NcGroup enum. GCode Group00. Include G04,G52,G53,G53p1,SiemensCycle800Swivel,SiemensSupa. NcGroup01 NcGroup enum. For linear move mode: G00 or G01. G00 is rapid move. G01 is linear cut. G02 is CW cut; G03 is CCW cut. NcGroup02 NcGroup enum. Plane selection. Include G17,G18,G19. NcGroup03 NcGroup enum. Absolute(G90) or increment(G91) coordinate. NcGroup05 NcGroup enum. For feedrate. NcGroup06 NcGroup enum. Group of unit. In mm or in inch. NcGroup07 NcGroup enum. Left or right compensation for tool radius, etc.. See G40, G41, G42 for available compensation modes. NcGroup08 NcGroup enum. Tool length compensation, etc.. G43,G43p4,G44,G49,SiemensTraori,SiemensTrafoof,HeidenhainM128,HeidenhainM129. NcGroup09 NcGroup enum. Canned cycle. NcGroup10 NcGroup enum. Canned cycle return point. G98,G99. NcGroup13 NC Group 13 for constant surface speed control. NcGroup14 NcGroup enum. Coordinate system. Such as G54Series. NcGroup15 NcGroup enum. NcGroup16 NcGroup enum. Rotation plane related. Interface of get transformation. Heidenhain equivalent group is NcGroupHeidenhainPlane. NcGroup21 NcGroup enum. Polar coordinate interpolation mode. NcGroupHeidenhainM107M108 NcGroup enum. Heidenhain group. Enable or disable Suppress error message for replacement tools with oversize. NcGroupHeidenhainPlane Heidenhain Group Plane related. ISO equivalent group is NcGroup16. NcGroupHeidenhainShortestRotaryPath NcGroup enum. Heidenhain group. shortest rotary state. HeidenhainM126,HeidenhainM127 NcGroupSpindleRotation NcGroup enum. Spindle rotation control. See SpindleStop, SpindleCw, SpindleCcw for available rotation modes. NcLifeCycleMode Defines the lifecycle mode of NC commands. NcWarningSceneEnum Defines scene types for NC warnings. SpindleDirection Enumeration of spindle rotation directions. SubStringKit.ActivationMode Defines the mode of activation for substring extraction."
  },
  "api/Hi.PanelModels.HiKey.html": {
    "href": "api/Hi.PanelModels.HiKey.html",
    "title": "Enum HiKey | HiAPI-C# 2025",
    "summary": "Enum HiKey Namespace Hi.PanelModels Assembly HiDisp.dll The definition is the same as WPF Key. public enum HiKey Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields A = 44 AbntC1 = 147 AbntC2 = 148 Add = 85 Apps = 72 Attn = 163 B = 45 Back = 2 BrowserBack = 122 BrowserFavorites = 127 BrowserForward = 123 BrowserHome = 128 BrowserRefresh = 124 BrowserSearch = 126 BrowserStop = 125 C = 46 Cancel = 1 Capital = 8 CapsLock = 8 Clear = 5 CrSel = 164 D = 47 D0 = 34 D1 = 35 D2 = 36 D3 = 37 D4 = 38 D5 = 39 D6 = 40 D7 = 41 D8 = 42 D9 = 43 DbeAlphanumeric = 157 DbeCodeInput = 167 DbeDbcsChar = 161 DbeDetermineString = 169 DbeEnterDialogConversionMode = 170 DbeEnterImeConfigureMode = 165 DbeEnterWordRegisterMode = 164 DbeFlushString = 166 DbeHiragana = 159 DbeKatakana = 158 DbeNoCodeInput = 168 DbeNoRoman = 163 DbeRoman = 162 DbeSbcsChar = 160 DeadCharProcessed = 172 Decimal = 88 Delete = 32 Divide = 89 Down = 26 E = 48 End = 21 Enter = 6 EraseEof = 166 Escape = 13 ExSel = 165 Execute = 29 F = 49 F1 = 90 F10 = 99 F11 = 100 F12 = 101 F13 = 102 F14 = 103 F15 = 104 F16 = 105 F17 = 106 F18 = 107 F19 = 108 F2 = 91 F20 = 109 F21 = 110 F22 = 111 F23 = 112 F24 = 113 F3 = 92 F4 = 93 F5 = 94 F6 = 95 F7 = 96 F8 = 97 F9 = 98 FinalMode = 11 G = 50 H = 51 HangulMode = 9 HanjaMode = 12 Help = 33 Home = 22 I = 52 ImeAccept = 16 ImeConvert = 14 ImeModeChange = 17 ImeNonConvert = 15 ImeProcessed = 155 Insert = 31 J = 53 JunjaMode = 10 K = 54 KanaMode = 9 KanjiMode = 12 L = 55 LWin = 70 LaunchApplication1 = 138 LaunchApplication2 = 139 LaunchMail = 136 Left = 23 LeftAlt = 120 LeftCtrl = 118 LeftShift = 116 LineFeed = 4 M = 56 MediaNextTrack = 132 MediaPlayPause = 135 MediaPreviousTrack = 133 MediaStop = 134 Multiply = 84 N = 57 Next = 20 NoName = 169 None = 0 NumLock = 114 NumPad0 = 74 NumPad1 = 75 NumPad2 = 76 NumPad3 = 77 NumPad4 = 78 NumPad5 = 79 NumPad6 = 80 NumPad7 = 81 NumPad8 = 82 NumPad9 = 83 O = 58 Oem1 = 140 Oem102 = 154 Oem2 = 145 Oem3 = 146 Oem4 = 149 Oem5 = 150 Oem6 = 151 Oem7 = 152 Oem8 = 153 OemAttn = 157 OemAuto = 160 OemBackTab = 162 OemBackslash = 154 OemClear = 171 OemCloseBrackets = 151 OemComma = 142 OemCopy = 159 OemEnlw = 161 OemFinish = 158 OemMinus = 143 OemOpenBrackets = 149 OemPeriod = 144 OemPipe = 150 OemPlus = 141 OemQuestion = 145 OemQuotes = 152 OemSemicolon = 140 OemTilde = 146 P = 59 Pa1 = 170 PageDown = 20 PageUp = 19 Pause = 7 Play = 167 Print = 28 PrintScreen = 30 Prior = 19 Q = 60 R = 61 RWin = 71 Return = 6 Right = 25 RightAlt = 121 RightCtrl = 119 RightShift = 117 S = 62 Scroll = 115 Select = 27 SelectMedia = 137 Separator = 86 Sleep = 73 Snapshot = 30 Space = 18 Subtract = 87 System = 156 T = 63 Tab = 3 U = 64 Up = 24 V = 65 VolumeDown = 130 VolumeMute = 129 VolumeUp = 131 W = 66 X = 67 Y = 68 Z = 69 Zoom = 168"
  },
  "api/Hi.PanelModels.HiKeyEvent.html": {
    "href": "api/Hi.PanelModels.HiKeyEvent.html",
    "title": "Class HiKeyEvent | HiAPI-C# 2025",
    "summary": "Class HiKeyEvent Namespace Hi.PanelModels Assembly HiDisp.dll Cross platform key event. public class HiKeyEvent : EventArgs Inheritance object EventArgs HiKeyEvent Inherited Members EventArgs.Empty object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HiKeyEvent() Initializes a new instance of the HiKeyEvent class. public HiKeyEvent() HiKeyEvent(HiKey, PanelModel) Initializes a new instance of the HiKeyEvent class. public HiKeyEvent(HiKey key, PanelModel panelModel) Parameters key HiKey The key associated with this event. panelModel PanelModel The panel model associated with this event. Properties Key Gets the key associated with this event. public HiKey Key { get; } Property Value HiKey PanelModel Gets the panel model associated with this event. public PanelModel PanelModel { get; } Property Value PanelModel"
  },
  "api/Hi.PanelModels.HiModifierKeys.html": {
    "href": "api/Hi.PanelModels.HiModifierKeys.html",
    "title": "Enum HiModifierKeys | HiAPI-C# 2025",
    "summary": "Enum HiModifierKeys Namespace Hi.PanelModels Assembly HiDisp.dll The definition is the same as WPF ModifierKeys. [Flags] public enum HiModifierKeys Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Alt = 1 Control = 2 None = 0 Shift = 4 Windows = 8"
  },
  "api/Hi.PanelModels.HiMouseButton.html": {
    "href": "api/Hi.PanelModels.HiMouseButton.html",
    "title": "Enum HiMouseButton | HiAPI-C# 2025",
    "summary": "Enum HiMouseButton Namespace Hi.PanelModels Assembly HiDisp.dll The definition is the same as WPF MouseButton public enum HiMouseButton Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Left = 0 The left mouse button. Identical to javascript convention. Middle = 1 Right = 2 The right mouse button. Identical to javascript convention. XButton1 = 3 XButton2 = 4"
  },
  "api/Hi.PanelModels.HiMouseButtonEvent.html": {
    "href": "api/Hi.PanelModels.HiMouseButtonEvent.html",
    "title": "Class HiMouseButtonEvent | HiAPI-C# 2025",
    "summary": "Class HiMouseButtonEvent Namespace Hi.PanelModels Assembly HiDisp.dll Mouse button event for cross-platform. public class HiMouseButtonEvent : EventArgs Inheritance object EventArgs HiMouseButtonEvent Inherited Members EventArgs.Empty object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HiMouseButtonEvent(HiMouseButton, PanelModel) Initializes a new instance of the HiMouseButtonEvent class. public HiMouseButtonEvent(HiMouseButton changedButton, PanelModel panelModel) Parameters changedButton HiMouseButton The button that changed state. panelModel PanelModel The panel model associated with this event. Properties ChangedButton Gets the button that changed state. public HiMouseButton ChangedButton { get; } Property Value HiMouseButton PanelModel Gets the panel model associated with this event. public PanelModel PanelModel { get; } Property Value PanelModel"
  },
  "api/Hi.PanelModels.HiMouseButtonMask.html": {
    "href": "api/Hi.PanelModels.HiMouseButtonMask.html",
    "title": "Enum HiMouseButtonMask | HiAPI-C# 2025",
    "summary": "Enum HiMouseButtonMask Namespace Hi.PanelModels Assembly HiDisp.dll Bit Mask of HiMouseButton. [Flags] public enum HiMouseButtonMask Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) HiMouseButtonMaskUtil.IsLeftPressed(HiMouseButtonMask) HiMouseButtonMaskUtil.IsMiddlePressed(HiMouseButtonMask) HiMouseButtonMaskUtil.IsRightPressed(HiMouseButtonMask) HiMouseButtonMaskUtil.IsXButton1Pressed(HiMouseButtonMask) HiMouseButtonMaskUtil.IsXButton2Pressed(HiMouseButtonMask) HiMouseButtonMaskUtil.Set(ref HiMouseButtonMask, HiMouseButton, bool) HiMouseButtonMaskUtil.SetLeftPressed(ref HiMouseButtonMask, bool) HiMouseButtonMaskUtil.SetMiddlePressed(ref HiMouseButtonMask, bool) HiMouseButtonMaskUtil.SetRightPressed(ref HiMouseButtonMask, bool) HiMouseButtonMaskUtil.SetXButton1Pressed(ref HiMouseButtonMask, bool) HiMouseButtonMaskUtil.SetXButton2Pressed(ref HiMouseButtonMask, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Left = 1 Left mouse button. Middle = 2 Middle mouse button. Right = 4 Right mouse button. XButton1 = 8 Other mouse button X1. XButton2 = 16 Other mouse button X2."
  },
  "api/Hi.PanelModels.HiMouseButtonMaskUtil.html": {
    "href": "api/Hi.PanelModels.HiMouseButtonMaskUtil.html",
    "title": "Class HiMouseButtonMaskUtil | HiAPI-C# 2025",
    "summary": "Class HiMouseButtonMaskUtil Namespace Hi.PanelModels Assembly HiDisp.dll Utility of HiMouseButtonMask. public static class HiMouseButtonMaskUtil Inheritance object HiMouseButtonMaskUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods IsLeftPressed(HiMouseButtonMask) Is mouse button Left pressed. public static bool IsLeftPressed(this HiMouseButtonMask src) Parameters src HiMouseButtonMask Returns bool IsMiddlePressed(HiMouseButtonMask) Is mouse button Middle pressed. public static bool IsMiddlePressed(this HiMouseButtonMask src) Parameters src HiMouseButtonMask Returns bool IsRightPressed(HiMouseButtonMask) Is mouse button Right pressed. public static bool IsRightPressed(this HiMouseButtonMask src) Parameters src HiMouseButtonMask Returns bool IsXButton1Pressed(HiMouseButtonMask) Is mouse button XButton1 pressed. public static bool IsXButton1Pressed(this HiMouseButtonMask src) Parameters src HiMouseButtonMask Returns bool IsXButton2Pressed(HiMouseButtonMask) Is mouse button XButton2 pressed. public static bool IsXButton2Pressed(this HiMouseButtonMask src) Parameters src HiMouseButtonMask Returns bool Set(ref HiMouseButtonMask, HiMouseButton, bool) Set the src by HiMouseButton. public static void Set(this ref HiMouseButtonMask src, HiMouseButton changedMouseButton, bool isPressed) Parameters src HiMouseButtonMask src changedMouseButton HiMouseButton changed mouse button isPressed bool true if the action is pressed; false if the action is released SetLeftPressed(ref HiMouseButtonMask, bool) Set mouse button Left pressed. public static void SetLeftPressed(this ref HiMouseButtonMask src, bool b) Parameters src HiMouseButtonMask b bool SetMiddlePressed(ref HiMouseButtonMask, bool) Set mouse button Middle pressed. public static void SetMiddlePressed(this ref HiMouseButtonMask src, bool b) Parameters src HiMouseButtonMask b bool SetRightPressed(ref HiMouseButtonMask, bool) Set mouse button Right pressed. public static void SetRightPressed(this ref HiMouseButtonMask src, bool b) Parameters src HiMouseButtonMask b bool SetXButton1Pressed(ref HiMouseButtonMask, bool) Set mouse button XButton1 pressed. public static void SetXButton1Pressed(this ref HiMouseButtonMask src, bool b) Parameters src HiMouseButtonMask b bool SetXButton2Pressed(ref HiMouseButtonMask, bool) Set mouse button XButton2 pressed. public static void SetXButton2Pressed(this ref HiMouseButtonMask src, bool b) Parameters src HiMouseButtonMask b bool"
  },
  "api/Hi.PanelModels.HiMouseMoveEvent.html": {
    "href": "api/Hi.PanelModels.HiMouseMoveEvent.html",
    "title": "Class HiMouseMoveEvent | HiAPI-C# 2025",
    "summary": "Class HiMouseMoveEvent Namespace Hi.PanelModels Assembly HiDisp.dll Mouse event for cross-platform. public class HiMouseMoveEvent : EventArgs Inheritance object EventArgs HiMouseMoveEvent Inherited Members EventArgs.Empty object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HiMouseMoveEvent(Vec2d, PanelModel) Initializes a new instance of the HiMouseMoveEvent class. public HiMouseMoveEvent(Vec2d position, PanelModel panelModel) Parameters position Vec2d The position of the mouse. panelModel PanelModel The panel model associated with this event. Properties PanelModel Gets the panel model associated with this event. public PanelModel PanelModel { get; } Property Value PanelModel Position Gets the position of the mouse. public Vec2d Position { get; } Property Value Vec2d"
  },
  "api/Hi.PanelModels.HiMouseWheelEvent.html": {
    "href": "api/Hi.PanelModels.HiMouseWheelEvent.html",
    "title": "Class HiMouseWheelEvent | HiAPI-C# 2025",
    "summary": "Class HiMouseWheelEvent Namespace Hi.PanelModels Assembly HiDisp.dll Mouse wheel event for cross-platform. public class HiMouseWheelEvent : EventArgs Inheritance object EventArgs HiMouseWheelEvent Inherited Members EventArgs.Empty object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors HiMouseWheelEvent(int, PanelModel) Initializes a new instance of the HiMouseWheelEvent class. public HiMouseWheelEvent(int delta, PanelModel panelModel) Parameters delta int The delta value of the mouse wheel movement. panelModel PanelModel The panel model associated with this event. Properties Delta Gets the delta value of the mouse wheel movement. public int Delta { get; } Property Value int PanelModel Gets the panel model associated with this event. public PanelModel PanelModel { get; } Property Value PanelModel"
  },
  "api/Hi.PanelModels.PanelModel.html": {
    "href": "api/Hi.PanelModels.PanelModel.html",
    "title": "Class PanelModel | HiAPI-C# 2025",
    "summary": "Class PanelModel Namespace Hi.PanelModels Assembly HiDisp.dll A panel model contains necessary data for manipulating a panel. It is platform-neutral. public class PanelModel Inheritance object PanelModel Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties CursorDelta Mouse cursor position changed from the last time to current. public Vec2d CursorDelta { get; set; } Property Value Vec2d CursorPosition Current mouse cursor position. public Vec2d CursorPosition { get; set; } Property Value Vec2d Height Panel height. public double Height { get; set; } Property Value double IsVisible Is panel visible. public bool IsVisible { get; set; } Property Value bool ModifierKeys Current pressed keyboard modifiers. public HiModifierKeys ModifierKeys { get; set; } Property Value HiModifierKeys MouseButtonMask Current pressed mouse button. public HiMouseButtonMask MouseButtonMask { get; set; } Property Value HiMouseButtonMask Width Panel width. public double Width { get; set; } Property Value double Methods KeyDown(HiKey) Press the key to this model. public void KeyDown(HiKey key) Parameters key HiKey key KeyUp(HiKey) Release the key to this model. public void KeyUp(HiKey key) Parameters key HiKey key MouseButtonDown(HiMouseButton) Press the mouse button to this model. public void MouseButtonDown(HiMouseButton button) Parameters button HiMouseButton button MouseButtonUp(HiMouseButton) Release the mouse button to this model. public void MouseButtonUp(HiMouseButton button) Parameters button HiMouseButton button MouseMove(Vec2d) Move the mouse and update the mouse cursor position to this model. public void MouseMove(Vec2d cursorPosition) Parameters cursorPosition Vec2d cursor position MouseWheel(int) Roll mouse wheel to this model. public void MouseWheel(int delta) Parameters delta int the quantity of the mouse wheel rolling Resize(double, double) Resize the panel model. public void Resize(double w, double h) Parameters w double width h double height"
  },
  "api/Hi.PanelModels.html": {
    "href": "api/Hi.PanelModels.html",
    "title": "Namespace Hi.PanelModels | HiAPI-C# 2025",
    "summary": "Namespace Hi.PanelModels Classes HiKeyEvent Cross platform key event. HiMouseButtonEvent Mouse button event for cross-platform. HiMouseButtonMaskUtil Utility of HiMouseButtonMask. HiMouseMoveEvent Mouse event for cross-platform. HiMouseWheelEvent Mouse wheel event for cross-platform. PanelModel A panel model contains necessary data for manipulating a panel. It is platform-neutral. Enums HiKey The definition is the same as WPF Key. HiModifierKeys The definition is the same as WPF ModifierKeys. HiMouseButton The definition is the same as WPF MouseButton HiMouseButtonMask Bit Mask of HiMouseButton."
  },
  "api/Hi.Parallels.CurrentThreadTaskScheduler.html": {
    "href": "api/Hi.Parallels.CurrentThreadTaskScheduler.html",
    "title": "Class CurrentThreadTaskScheduler | HiAPI-C# 2025",
    "summary": "Class CurrentThreadTaskScheduler Namespace Hi.Parallels Assembly HiGeom.dll A task scheduler that executes tasks on the current thread. public class CurrentThreadTaskScheduler : TaskScheduler Inheritance object TaskScheduler CurrentThreadTaskScheduler Inherited Members TaskScheduler.FromCurrentSynchronizationContext() TaskScheduler.TryDequeue(Task) TaskScheduler.TryExecuteTask(Task) TaskScheduler.Current TaskScheduler.Default TaskScheduler.Id TaskScheduler.MaximumConcurrencyLevel TaskScheduler.UnobservedTaskException object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetScheduledTasks() Gets the tasks currently scheduled on this scheduler. protected override IEnumerable<Task> GetScheduledTasks() Returns IEnumerable<Task> An empty enumerable since this scheduler doesn't queue tasks. QueueTask(Task) Queues a task to the scheduler, which immediately executes it on the current thread. protected override void QueueTask(Task task) Parameters task Task The task to be executed. TryExecuteTaskInline(Task, bool) Tries to execute a task synchronously on the current thread. protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) Parameters task Task The task to be executed. taskWasPreviouslyQueued bool Whether the task was previously queued to the scheduler. Returns bool Always returns true since the task is always executed."
  },
  "api/Hi.Parallels.DistributedQueueTaskScheduler.html": {
    "href": "api/Hi.Parallels.DistributedQueueTaskScheduler.html",
    "title": "Class DistributedQueueTaskScheduler | HiAPI-C# 2025",
    "summary": "Class DistributedQueueTaskScheduler Namespace Hi.Parallels Assembly HiGeom.dll A task scheduler that distributes tasks across multiple threads or processes. Allows for controlled execution of tasks with a specified maximum concurrency level. public class DistributedQueueTaskScheduler : TaskScheduler, IDisposable Inheritance object TaskScheduler DistributedQueueTaskScheduler Implements IDisposable Inherited Members TaskScheduler.FromCurrentSynchronizationContext() TaskScheduler.TryDequeue(Task) TaskScheduler.TryExecuteTask(Task) TaskScheduler.Current TaskScheduler.Default TaskScheduler.Id TaskScheduler.MaximumConcurrencyLevel TaskScheduler.UnobservedTaskException object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors DistributedQueueTaskScheduler(DistributedQueueTaskStarter, int, int) Initializes a new instance of the DistributedQueueTaskScheduler class. public DistributedQueueTaskScheduler(DistributedQueueTaskStarter starter, int maxIdlingTaskNum, int maxWorkingTaskNum) Parameters starter DistributedQueueTaskStarter The task starter responsible for distributing tasks. maxIdlingTaskNum int The maximum number of tasks that can be queued. maxWorkingTaskNum int The maximum number of tasks that can be executed concurrently. Properties MaxWorkingTaskNum Gets the maximum number of tasks that can be executed concurrently. public int MaxWorkingTaskNum { get; } Property Value int Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) Releases the unmanaged resources used by the DistributedQueueTaskScheduler and optionally releases the managed resources. protected virtual void Dispose(bool disposing) Parameters disposing bool true to release both managed and unmanaged resources; false to release only unmanaged resources. GetScheduledTasks() Gets the tasks currently scheduled for execution. protected override IEnumerable<Task> GetScheduledTasks() Returns IEnumerable<Task> An enumerable of the tasks currently scheduled. QueueTask(Task) Queues a task to the scheduler. protected override void QueueTask(Task task) Parameters task Task The task to be queued. TryExecuteTaskInline(Task, bool) Tries to execute a task synchronously on the current thread. protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) Parameters task Task The task to be executed. taskWasPreviouslyQueued bool Whether the task was previously queued to the scheduler. Returns bool true if the task was successfully executed; otherwise, false. WaitAll() Waits for all queued tasks to complete. public void WaitAll() Events Ending Event that is raised when a worker thread ends processing tasks. public event Action Ending Event Type Action Starting Event that is raised when a worker thread starts processing tasks. public event Action Starting Event Type Action"
  },
  "api/Hi.Parallels.DistributedQueueTaskStarter.html": {
    "href": "api/Hi.Parallels.DistributedQueueTaskStarter.html",
    "title": "Class DistributedQueueTaskStarter | HiAPI-C# 2025",
    "summary": "Class DistributedQueueTaskStarter Namespace Hi.Parallels Assembly HiGeom.dll A class that manages and starts a collection of actions in parallel. public class DistributedQueueTaskStarter Inheritance object DistributedQueueTaskStarter Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors DistributedQueueTaskStarter(int) Initializes a new instance of the DistributedQueueTaskStarter class. public DistributedQueueTaskStarter(int maxWorkingTaskNum = 0) Parameters maxWorkingTaskNum int The maximum number of tasks that can be executed simultaneously. If 0, uses the processor count. Properties IdleTaskNum Gets the number of idle tasks (capacity minus current count). public int IdleTaskNum { get; } Property Value int ThreadPriority Gets or sets the thread priority for executing tasks. Default is BelowNormal. public ThreadPriority ThreadPriority { get; set; } Property Value ThreadPriority Methods Start() Starts executing all actions in parallel. public Task Start() Returns Task A task representing the asynchronous operation."
  },
  "api/Hi.Parallels.LockUtil.html": {
    "href": "api/Hi.Parallels.LockUtil.html",
    "title": "Class LockUtil | HiAPI-C# 2025",
    "summary": "Class LockUtil Namespace Hi.Parallels Assembly HiGeom.dll Utility class for object locking operations. public static class LockUtil Inheritance object LockUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods Lock(object) Acquires a lock on the specified object and returns a disposable token that releases the lock when disposed. public static IDisposable Lock(this object obj) Parameters obj object The object to lock. Returns IDisposable A disposable token that releases the lock when disposed."
  },
  "api/Hi.Parallels.PriorityTaskScheduler.html": {
    "href": "api/Hi.Parallels.PriorityTaskScheduler.html",
    "title": "Class PriorityTaskScheduler | HiAPI-C# 2025",
    "summary": "Class PriorityTaskScheduler Namespace Hi.Parallels Assembly HiGeom.dll A task scheduler that executes tasks with a specified thread priority. public class PriorityTaskScheduler : TaskScheduler Inheritance object TaskScheduler PriorityTaskScheduler Inherited Members TaskScheduler.FromCurrentSynchronizationContext() TaskScheduler.TryDequeue(Task) TaskScheduler.TryExecuteTask(Task) TaskScheduler.Current TaskScheduler.Default TaskScheduler.Id TaskScheduler.MaximumConcurrencyLevel TaskScheduler.UnobservedTaskException object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors PriorityTaskScheduler(ThreadPriority) Initializes a new instance. public PriorityTaskScheduler(ThreadPriority threadPriority) Parameters threadPriority ThreadPriority The thread priority for executing tasks. Properties MaxDegreeOfParallelism Max Degree Of Parallelism. Set special value 0 for no limiting. public int MaxDegreeOfParallelism { get; set; } Property Value int ThreadPriority Gets or sets the thread priority for executing tasks. public ThreadPriority ThreadPriority { get; set; } Property Value ThreadPriority Methods GetScheduledTasks() For debugger support only, generates an enumerable of Task instances currently queued to the scheduler waiting to be executed. protected override IEnumerable<Task> GetScheduledTasks() Returns IEnumerable<Task> An enumerable that allows a debugger to traverse the tasks currently queued to this scheduler. Exceptions NotSupportedException This scheduler is unable to generate a list of queued tasks at this time. QueueTask(Task) Queues a Task to the scheduler. protected override void QueueTask(Task task) Parameters task Task The Task to be queued. Exceptions ArgumentNullException The task argument is null. TryExecuteTaskInline(Task, bool) Determines whether the provided Task can be executed synchronously in this call, and if it can, executes it. protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) Parameters task Task The Task to be executed. taskWasPreviouslyQueued bool A Boolean denoting whether or not task has previously been queued. If this parameter is True, then the task may have been previously queued (scheduled); if False, then the task is known not to have been queued, and this call is being made in order to execute the task inline without queuing it. Returns bool A Boolean value indicating whether the task was executed inline. Exceptions ArgumentNullException The task argument is null. InvalidOperationException The task was already executed."
  },
  "api/Hi.Parallels.QueueTaskScheduler.html": {
    "href": "api/Hi.Parallels.QueueTaskScheduler.html",
    "title": "Class QueueTaskScheduler | HiAPI-C# 2025",
    "summary": "Class QueueTaskScheduler Namespace Hi.Parallels Assembly HiGeom.dll A task scheduler that queues tasks and executes them in a controlled manner. Limits the number of concurrent tasks and provides mechanisms for waiting for all tasks to complete. public class QueueTaskScheduler : TaskScheduler, IDisposable Inheritance object TaskScheduler QueueTaskScheduler Implements IDisposable Inherited Members TaskScheduler.FromCurrentSynchronizationContext() TaskScheduler.TryDequeue(Task) TaskScheduler.TryExecuteTask(Task) TaskScheduler.Current TaskScheduler.Default TaskScheduler.Id TaskScheduler.MaximumConcurrencyLevel TaskScheduler.UnobservedTaskException object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors QueueTaskScheduler(int, int, ThreadPriority) Initializes a new instance of the QueueTaskScheduler class. public QueueTaskScheduler(int maxIdlingTaskNum, int maxWorkingTaskNum = 0, ThreadPriority threadPriority = ThreadPriority.BelowNormal) Parameters maxIdlingTaskNum int The maximum number of tasks that can be queued. maxWorkingTaskNum int The maximum number of tasks that can be executed concurrently. If 0, defaults to the number of processors. threadPriority ThreadPriority The thread priority for executing tasks. Properties CancellationToken Gets the cancellation token used to cancel the working task. public CancellationToken CancellationToken { get; } Property Value CancellationToken IdlingTaskNum Gets the number of tasks currently waiting in the queue. public int IdlingTaskNum { get; } Property Value int ThreadPriority Gets the thread priority used for executing tasks. public ThreadPriority ThreadPriority { get; } Property Value ThreadPriority Methods Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) protected virtual void Dispose(bool disposing) Parameters disposing bool GetScheduledTasks() Gets the tasks currently scheduled for execution. protected override IEnumerable<Task> GetScheduledTasks() Returns IEnumerable<Task> An enumerable of the tasks currently scheduled. QueueTask(Task) Queues a task to the scheduler. protected override void QueueTask(Task task) Parameters task Task The task to be queued. Test() Tests the QueueTaskScheduler by running multiple tasks concurrently. public static void Test() TryExecuteTaskInline(Task, bool) Tries to execute a task synchronously on the current thread. protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) Parameters task Task The task to be executed. taskWasPreviouslyQueued bool Whether the task was previously queued to the scheduler. Returns bool true if the task was successfully executed; otherwise, false. WaitAll() Waits for all queued tasks to complete. public void WaitAll()"
  },
  "api/Hi.Parallels.ReaderWriterLockUtil.html": {
    "href": "api/Hi.Parallels.ReaderWriterLockUtil.html",
    "title": "Class ReaderWriterLockUtil | HiAPI-C# 2025",
    "summary": "Class ReaderWriterLockUtil Namespace Hi.Parallels Assembly HiGeom.dll Utility class for reader-writer lock operations. Provides extension methods for ReaderWriterLockSlim to simplify lock acquisition and release. public static class ReaderWriterLockUtil Inheritance object ReaderWriterLockUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods ReadLock(ReaderWriterLockSlim) Acquires a read lock on the specified reader-writer lock. public static IDisposable ReadLock(this ReaderWriterLockSlim obj) Parameters obj ReaderWriterLockSlim The reader-writer lock to acquire a read lock on. Returns IDisposable A disposable token that releases the read lock when disposed. UpgradeableReadLock(ReaderWriterLockSlim) Acquires an upgradeable read lock on the specified reader-writer lock. public static IDisposable UpgradeableReadLock(this ReaderWriterLockSlim obj) Parameters obj ReaderWriterLockSlim The reader-writer lock to acquire an upgradeable read lock on. Returns IDisposable A disposable token that releases the upgradeable read lock when disposed. WriteLock(ReaderWriterLockSlim) Acquires a write lock on the specified reader-writer lock. public static IDisposable WriteLock(this ReaderWriterLockSlim obj) Parameters obj ReaderWriterLockSlim The reader-writer lock to acquire a write lock on. Returns IDisposable A disposable token that releases the write lock when disposed."
  },
  "api/Hi.Parallels.SemaphoreUtil.html": {
    "href": "api/Hi.Parallels.SemaphoreUtil.html",
    "title": "Class SemaphoreUtil | HiAPI-C# 2025",
    "summary": "Class SemaphoreUtil Namespace Hi.Parallels Assembly HiGeom.dll Utility class for semaphore operations. Provides extension methods for SemaphoreSlim to simplify semaphore acquisition and release. public static class SemaphoreUtil Inheritance object SemaphoreUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods Embrace(SemaphoreSlim) Acquires the specified semaphore. public static IDisposable Embrace(this SemaphoreSlim semaphore) Parameters semaphore SemaphoreSlim The semaphore to acquire. Returns IDisposable A disposable token that releases the semaphore when disposed. EmbraceAsync(SemaphoreSlim) Acquires the specified semaphore asynchronously. public static Task<IDisposable> EmbraceAsync(this SemaphoreSlim semaphore) Parameters semaphore SemaphoreSlim The semaphore to acquire. Returns Task<IDisposable> A task that represents the asynchronous operation. The task result contains a disposable token that releases the semaphore when disposed."
  },
  "api/Hi.Parallels.ThreadSafeSet-1.html": {
    "href": "api/Hi.Parallels.ThreadSafeSet-1.html",
    "title": "Class ThreadSafeSet<T> | HiAPI-C# 2025",
    "summary": "Class ThreadSafeSet<T> Namespace Hi.Parallels Assembly HiGeom.dll A thread-safe implementation of a set data structure. Uses a reader-writer lock to synchronize access to the underlying HashSet. public class ThreadSafeSet<T> : IDisposable Type Parameters T The type of elements in the set. Inheritance object ThreadSafeSet<T> Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ThreadSafeSet(HashSet<T>, LockRecursionPolicy) Initializes a new instance of the ThreadSafeSet<T> class with the specified HashSet and lock recursion policy. public ThreadSafeSet(HashSet<T> src, LockRecursionPolicy lockRecursionPolicy) Parameters src HashSet<T> The source HashSet to use. lockRecursionPolicy LockRecursionPolicy The lock recursion policy to use. ThreadSafeSet(int, LockRecursionPolicy) Initializes a new instance of the ThreadSafeSet<T> class with the specified capacity and lock recursion policy. public ThreadSafeSet(int capacity, LockRecursionPolicy lockRecursionPolicy) Parameters capacity int The initial capacity of the set. lockRecursionPolicy LockRecursionPolicy The lock recursion policy to use. ThreadSafeSet(LockRecursionPolicy) Initializes a new instance of the ThreadSafeSet<T> class with the specified lock recursion policy. public ThreadSafeSet(LockRecursionPolicy lockRecursionPolicy) Parameters lockRecursionPolicy LockRecursionPolicy The lock recursion policy to use. Properties Content Gets the underlying HashSet that stores the elements. public HashSet<T> Content { get; } Property Value HashSet<T> Count Gets the number of elements in the set. public int Count { get; } Property Value int ReaderWriterLock Gets the reader-writer lock used to synchronize access to the set. public ReaderWriterLockSlim ReaderWriterLock { get; } Property Value ReaderWriterLockSlim Methods Add(T) Adds an element to the set. public bool Add(T item) Parameters item T The element to add. Returns bool true if the element is added to the set; false if the element is already present. Clear() Removes all elements from the set. public void Clear() CloneContent() Creates a new HashSet that contains the same elements as the current set. public HashSet<T> CloneContent() Returns HashSet<T> A new HashSet that contains the same elements as the current set. Contains(T) Determines whether the set contains the specified element. public bool Contains(T item) Parameters item T The element to locate. Returns bool true if the set contains the specified element; otherwise, false. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) Releases the unmanaged resources used by the ThreadSafeSet<T> and optionally releases the managed resources. protected virtual void Dispose(bool disposing) Parameters disposing bool true to release both managed and unmanaged resources; false to release only unmanaged resources. EnsureCapacity(int) Ensures that the set can hold the specified number of elements without growing. public int EnsureCapacity(int capacity) Parameters capacity int The minimum capacity to ensure. Returns int The new capacity of the set. Remove(T) Removes the specified element from the set. public bool Remove(T item) Parameters item T The element to remove. Returns bool true if the element is successfully found and removed; otherwise, false. TrimExcess() Sets the capacity of the set to the actual number of elements it contains. public void TrimExcess() TryGetValue(T, out T) Attempts to get the actual value of an element equal to the specified value. public bool TryGetValue(T equalValue, out T actualValue) Parameters equalValue T The value to search for. actualValue T When this method returns, contains the actual value if found; otherwise, the default value for the type. Returns bool true if the set contains an element equal to the specified value; otherwise, false. UnionWith(IEnumerable<T>) Modifies the current set to contain all elements that are present in itself, the specified collection, or both. public void UnionWith(IEnumerable<T> other) Parameters other IEnumerable<T> The collection to compare to the current set."
  },
  "api/Hi.Parallels.html": {
    "href": "api/Hi.Parallels.html",
    "title": "Namespace Hi.Parallels | HiAPI-C# 2025",
    "summary": "Namespace Hi.Parallels Classes CurrentThreadTaskScheduler A task scheduler that executes tasks on the current thread. DistributedQueueTaskScheduler A task scheduler that distributes tasks across multiple threads or processes. Allows for controlled execution of tasks with a specified maximum concurrency level. DistributedQueueTaskStarter A class that manages and starts a collection of actions in parallel. LockUtil Utility class for object locking operations. PriorityTaskScheduler A task scheduler that executes tasks with a specified thread priority. QueueTaskScheduler A task scheduler that queues tasks and executes them in a controlled manner. Limits the number of concurrent tasks and provides mechanisms for waiting for all tasks to complete. ReaderWriterLockUtil Utility class for reader-writer lock operations. Provides extension methods for ReaderWriterLockSlim to simplify lock acquisition and release. SemaphoreUtil Utility class for semaphore operations. Provides extension methods for SemaphoreSlim to simplify semaphore acquisition and release. ThreadSafeSet<T> A thread-safe implementation of a set data structure. Uses a reader-writer lock to synchronize access to the underlying HashSet."
  },
  "api/Hi.Physics.AmpPhase.html": {
    "href": "api/Hi.Physics.AmpPhase.html",
    "title": "Class AmpPhase | HiAPI-C# 2025",
    "summary": "Class AmpPhase Namespace Hi.Physics Assembly HiGeom.dll Represents amplitude and phase information for wave-like phenomena. public class AmpPhase Inheritance object AmpPhase Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors AmpPhase() Initializes a new instance of the AmpPhase class. public AmpPhase() AmpPhase(double, double) Initializes a new instance of the AmpPhase class with specified amplitude and phase. public AmpPhase(double amp, double phase_rad) Parameters amp double The amplitude value. phase_rad double The phase value in radians. Properties Amp Gets or sets the amplitude value. public double Amp { get; set; } Property Value double Phase_deg Gets or sets the phase value in degrees. public double Phase_deg { get; set; } Property Value double Phase_rad Gets or sets the phase value in radians. public double Phase_rad { get; set; } Property Value double"
  },
  "api/Hi.Physics.CoatingMaterial.html": {
    "href": "api/Hi.Physics.CoatingMaterial.html",
    "title": "Class CoatingMaterial | HiAPI-C# 2025",
    "summary": "Class CoatingMaterial Namespace Hi.Physics Assembly HiMech.dll Represents a coating material used in cutting tools. public class CoatingMaterial : CutterMaterial, ISurfaceMaterial, IStructureMaterial, IMakeXmlSource, IDuplicate, INameNote, IToXElement Inheritance object CutterMaterial CoatingMaterial Implements ISurfaceMaterial IStructureMaterial IMakeXmlSource IDuplicate INameNote IToXElement Inherited Members CutterMaterial.Name CutterMaterial.Note CutterMaterial.ElasticModulus_GPa CutterMaterial.PoissonRatio CutterMaterial.TensileStrength_MPa CutterMaterial.ThermalExpansionCoefficient_dMK CutterMaterial.HeatConductivity_WdmK CutterMaterial.HeatConductivity_WdmmK CutterMaterial.HeatCapacity_JdgK CutterMaterial.Density_gdm3 CutterMaterial.Density_gdcm3 CutterMaterial.Density_gdmm3 CutterMaterial.MeltingTemperature_K CutterMaterial.FusionLatentHeat_Jdg CutterMaterial.FrictionCoefficient CutterMaterial.TemperatureVsHardnessCurve CutterMaterial.TemperatureVsWearCoefficientCurve CutterMaterial.WC CutterMaterial.WC_Co6_800nm object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CoatingMaterial() Initializes a new instance of the CoatingMaterial class. public CoatingMaterial() CoatingMaterial(CoatingMaterial) Initializes a new instance of the CoatingMaterial class by copying from another instance. public CoatingMaterial(CoatingMaterial src) Parameters src CoatingMaterial The source coating material to copy from. CoatingMaterial(XElement) Initializes a new instance of the CoatingMaterial class from XML data. public CoatingMaterial(XElement src) Parameters src XElement The XML element containing coating material data. Properties DefaultFrictionCoefficient Gets the default friction coefficient for coating materials. public static double DefaultFrictionCoefficient { get; } Property Value double PreferedThickness_mm Gets or sets the preferred thickness of the coating in millimeters. public double PreferedThickness_mm { get; set; } Property Value double PreferedThickness_um Gets or sets the preferred thickness of the coating in micrometers. public double PreferedThickness_um { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods Duplicate(params object[]) public object Duplicate(params object[] res) Parameters res object[] Returns object MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public override XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public override XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.Physics.CoolantHeatCondition.html": {
    "href": "api/Hi.Physics.CoolantHeatCondition.html",
    "title": "Class CoolantHeatCondition | HiAPI-C# 2025",
    "summary": "Class CoolantHeatCondition Namespace Hi.Physics Assembly HiMech.dll Represents the heat condition parameters for coolant in machining operations. Provides effective convection-coefficient lookups keyed by CoolantMode — Flood uses the configured baseline CoolantConvectionCoefficient_Wdm2K; Mist scales it by MistFloodConvectionRatio; Off falls back to OffConvectionCoefficient_Wdm2K (natural/forced air). Named standard presets (StandardForcedAir, StandardWaterSolubleCoolant, StandardOilBasedCoolant) bundle all coefficients so end users can pick a cooling type by name instead of entering convection coefficients; MatchStandardPreset() maps a configured instance back to the preset it equals. public class CoolantHeatCondition : IMakeXmlSource, INameNote, IPreferredFileName Inheritance object CoolantHeatCondition Implements IMakeXmlSource INameNote IPreferredFileName Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CoolantHeatCondition() Initializes a new instance of the CoolantHeatCondition class. public CoolantHeatCondition() CoolantHeatCondition(XElement) Initializes a new instance of the CoolantHeatCondition class from XML data. public CoolantHeatCondition(XElement src) Parameters src XElement The XML element containing coolant heat condition data. Fields CustomName Reserved Name marking an explicitly customized condition; see MatchStandardPreset(). public const string CustomName = \"Custom\" Field Value string Properties CoolantConvectionCoefficient_Wdm2K Gets or sets the coolant heat transfer coefficient (flood baseline) in Watts per square meter per Kelvin. public double CoolantConvectionCoefficient_Wdm2K { get; set; } Property Value double Remarks Common value: forced air: 10~500; coolant: 1e3~1e4 (ref by “Effects of coolant on temperature distribution in metal machining”, 1988) coolant: 1e3 (ref by “Modeling heat transfer in die milling”, 2014) CoolantConvectionCoefficient_Wdmm2K Gets or sets the coolant heat transfer coefficient (flood baseline) in Watts per square millimeter per Kelvin. public double CoolantConvectionCoefficient_Wdmm2K { get; set; } Property Value double CoolantTemperature_C Gets or sets the coolant temperature in Celsius. public double CoolantTemperature_C { get; set; } Property Value double CoolantTemperature_K Gets or sets the coolant temperature in Kelvin. public double CoolantTemperature_K { get; set; } Property Value double MistFloodConvectionRatio Convection-coefficient ratio of mist coolant (MQL) relative to flood coolant. Applied multiplicatively to CoolantConvectionCoefficient_Wdm2K when the current CoolantMode is Mist. public double MistFloodConvectionRatio { get; set; } Property Value double Remarks Default 0.5. Mist (MQL) systems typically remove noticeably less heat than flood coolant, and the effective ratio varies with the process, fluid and delivery system (commonly reported in the 0.4–0.8 range). Projects that characterise their own MQL system should override this value via XML. Name Gets or sets the name of the coolant condition. Standard presets carry their preset name (e.g. “StandardWaterSolubleCoolant”); set to CustomName to mark the condition as explicitly customized (which makes MatchStandardPreset() return null even when the coefficients happen to equal a preset). null/empty on legacy projects that predate naming. public string Name { get; set; } Property Value string Note Gets or sets additional notes about the coolant condition. public string Note { get; set; } Property Value string OffConvectionCoefficient_Wdm2K Gets or sets the convection coefficient when coolant is off (ambient air / forced blow-off), in Watts per square meter per Kelvin. public double OffConvectionCoefficient_Wdm2K { get; set; } Property Value double Remarks Natural convection in still air is ~5–25 W/(m²·K); forced air (shop blow-off / chip conveyor draft) falls in 10–500 W/(m²·K). Default 50 W/(m²·K) represents a mild forced-air environment typical of a running machine enclosure. PreferredFileName Gets or sets the preferred file name for this object when generating or saving files. public string PreferredFileName { get; set; } Property Value string StandardForcedAir Forced-air / dry cutting: air blast only, no liquid coolant. Even when the NC program turns coolant on (M07/M08), the machine only blows air, so the flood baseline is an air-blast coefficient. public static CoolantHeatCondition StandardForcedAir { get; } Property Value CoolantHeatCondition Remarks Coefficients are engineering estimates from the ranges documented on CoolantConvectionCoefficient_Wdm2K and OffConvectionCoefficient_Wdm2K (forced air 10–500 W/(m²·K)); override via XML when characterised data is available. StandardOilBasedCoolant Oil-based (neat oil) cutting fluid: better lubrication, noticeably lower heat removal than water-based emulsion. public static CoolantHeatCondition StandardOilBasedCoolant { get; } Property Value CoolantHeatCondition Remarks Flood baseline 300 W/(m²·K) sits in the documented straight-oil range (roughly 100–500 W/(m²·K)); override via XML when characterised data is available. StandardPresets The named standard presets, in menu order. Each access returns fresh instances (same as Al6061T6), so callers may mutate the result freely. public static IReadOnlyList<CoolantHeatCondition> StandardPresets { get; } Property Value IReadOnlyList<CoolantHeatCondition> StandardWaterSolubleCoolant Water-soluble (water-based emulsion) cutting fluid — the common flood coolant. Matches this class's field defaults, so an unconfigured condition reads as this preset. public static CoolantHeatCondition StandardWaterSolubleCoolant { get; } Property Value CoolantHeatCondition Remarks Flood baseline 1000 W/(m²·K) is the literature-backed default (see CoolantConvectionCoefficient_Wdm2K; water-based emulsion spans roughly 1000–3000). XName Name for XML IO. public static string XName { get; } Property Value string Methods ApplyPreset(CoolantHeatCondition) Copies all values (name, note, temperature and the three convection values) from preset into this instance, in place — existing references (e.g. a live MachiningEquipment.CoolantHeatCondition) keep observing the updated condition. public void ApplyPreset(CoolantHeatCondition preset) Parameters preset CoolantHeatCondition FindStandardPreset(string) Finds the standard preset with the given Name, or null when the name is not a standard preset name (including CustomName and null). public static CoolantHeatCondition FindStandardPreset(string name) Parameters name string Returns CoolantHeatCondition GetEffectiveConvectionCoefficient_Wdm2K(CoolantMode) Gets the effective convection coefficient for the given coolant mode in Watts per square meter per Kelvin. Flood: CoolantConvectionCoefficient_Wdm2K Mist: CoolantConvectionCoefficient_Wdm2K × MistFloodConvectionRatio Off / UnDefined: OffConvectionCoefficient_Wdm2K public double GetEffectiveConvectionCoefficient_Wdm2K(CoolantMode mode) Parameters mode CoolantMode Returns double GetEffectiveConvectionCoefficient_Wdmm2K(CoolantMode) Mode-dependent convection coefficient in Watts per square millimetre per Kelvin (direct input to the FEM layer). See GetEffectiveConvectionCoefficient_Wdm2K(CoolantMode). public double GetEffectiveConvectionCoefficient_Wdmm2K(CoolantMode mode) Parameters mode CoolantMode Returns double MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. MatchStandardPreset() Returns the standard preset whose three convection values (CoolantConvectionCoefficient_Wdm2K, MistFloodConvectionRatio, OffConvectionCoefficient_Wdm2K) exactly equal this instance's, or null when none matches or Name is CustomName. CoolantTemperature_C is intentionally excluded — temperature is an independent setting that a user may tune without leaving the preset. public CoolantHeatCondition MatchStandardPreset() Returns CoolantHeatCondition Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Physics.CutterMaterial.html": {
    "href": "api/Hi.Physics.CutterMaterial.html",
    "title": "Class CutterMaterial | HiAPI-C# 2025",
    "summary": "Class CutterMaterial Namespace Hi.Physics Assembly HiMech.dll Represents a cutter material with physical and thermal properties. public class CutterMaterial : ISurfaceMaterial, IStructureMaterial, IMakeXmlSource, IDuplicate, INameNote, IToXElement Inheritance object CutterMaterial Implements ISurfaceMaterial IStructureMaterial IMakeXmlSource IDuplicate INameNote IToXElement Derived CoatingMaterial Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CutterMaterial() Default constructor. public CutterMaterial() CutterMaterial(CutterMaterial) Creates a new cutter material as a copy of an existing one. public CutterMaterial(CutterMaterial src) Parameters src CutterMaterial The source material to copy from. CutterMaterial(XElement) Ctor. public CutterMaterial(XElement src) Parameters src XElement XML Properties Density_gdcm3 Gets or sets the density in grams per cubic centimeter. public double Density_gdcm3 { get; set; } Property Value double Density_gdm3 Density in g/dm³. public double Density_gdm3 { get; set; } Property Value double Density_gdmm3 Density in g/mm³. public double Density_gdmm3 { get; set; } Property Value double ElasticModulus_GPa Gets or sets the elastic modulus in gigapascals. public double ElasticModulus_GPa { get; set; } Property Value double FrictionCoefficient Gets or sets the friction coefficient of the surface material. public double FrictionCoefficient { get; set; } Property Value double FusionLatentHeat_Jdg Latent Heat of Fusion. public double FusionLatentHeat_Jdg { get; set; } Property Value double HeatCapacity_JdgK Gets or sets the heat capacity in Joules per gram-Kelvin. public double HeatCapacity_JdgK { get; set; } Property Value double HeatConductivity_WdmK Gets or sets the heat transfer coefficient in Watts per meter-Kelvin. public double HeatConductivity_WdmK { get; set; } Property Value double HeatConductivity_WdmmK Heat transfer coefficient in W/(mm·K). public double HeatConductivity_WdmmK { get; set; } Property Value double MeltingTemperature_K public double MeltingTemperature_K { get; set; } Property Value double Name Gets or sets the name of the object. public string Name { get; set; } Property Value string Note Gets or sets the descriptive note for the object. public string Note { get; set; } Property Value string PoissonRatio public double PoissonRatio { get; set; } Property Value double TemperatureVsHardnessCurve Temperature versus hardness curve data. public List<TemperatureVsHardness> TemperatureVsHardnessCurve { get; set; } Property Value List<TemperatureVsHardness> TemperatureVsWearCoefficientCurve Temperature(K) vs WearCoefficient. Unit of WearCoefficient: 1e-6 (non-unit). public List<Vec2d> TemperatureVsWearCoefficientCurve { get; set; } Property Value List<Vec2d> TensileStrength_MPa public double TensileStrength_MPa { get; set; } Property Value double ThermalExpansionCoefficient_dMK public double ThermalExpansionCoefficient_dMK { get; set; } Property Value double WC General condition of WC (Tungsten Carbide). public static CutterMaterial WC { get; } Property Value CutterMaterial WC_Co6_800nm WC-Co6 with 800nm grain size properties. public static CutterMaterial WC_Co6_800nm { get; } Property Value CutterMaterial XName Name for XML IO. public static string XName { get; } Property Value string Methods Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public virtual XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public virtual XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.Physics.IGetThermalLayerList.html": {
    "href": "api/Hi.Physics.IGetThermalLayerList.html",
    "title": "Interface IGetThermalLayerList | HiAPI-C# 2025",
    "summary": "Interface IGetThermalLayerList Namespace Hi.Physics Assembly HiMech.dll Interface for objects that can provide a list of thermal layers. public interface IGetThermalLayerList Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MillingTemperatureUtil.GetMaterial(IGetThermalLayerList, double) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetThermalLayerList() Gets the list of thermal layers. List<ThermalLayer1D> GetThermalLayerList() Returns List<ThermalLayer1D> List of thermal layers."
  },
  "api/Hi.Physics.IStructureMaterial.html": {
    "href": "api/Hi.Physics.IStructureMaterial.html",
    "title": "Interface IStructureMaterial | HiAPI-C# 2025",
    "summary": "Interface IStructureMaterial Namespace Hi.Physics Assembly HiMech.dll Interface for structure materials with thermal properties. public interface IStructureMaterial : IMakeXmlSource, IDuplicate, INameNote Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) IDuplicate.Duplicate(params object[]) INameNote.Name INameNote.Note Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Density_gdcm3 Gets or sets the density in grams per cubic centimeter. double Density_gdcm3 { get; set; } Property Value double Density_gdmm3 Gets or sets the density in grams per cubic millimeter. double Density_gdmm3 { get; set; } Property Value double ElasticModulus_GPa Gets or sets the elastic modulus in gigapascals. double ElasticModulus_GPa { get; set; } Property Value double HeatCapacity_JdgK Gets or sets the heat capacity in Joules per gram-Kelvin. double HeatCapacity_JdgK { get; set; } Property Value double HeatConductivity_WdmK Gets or sets the heat transfer coefficient in Watts per meter-Kelvin. double HeatConductivity_WdmK { get; set; } Property Value double HeatConductivity_WdmmK Gets or sets the heat transfer coefficient in Watts per millimeter-Kelvin. double HeatConductivity_WdmmK { get; set; } Property Value double ThermalDiffusivity_mm2dsK Gets the thermal diffusivity in square millimeters per second-Kelvin. double ThermalDiffusivity_mm2dsK { get; } Property Value double"
  },
  "api/Hi.Physics.ISuccessivePhysicsBriefAccessor.html": {
    "href": "api/Hi.Physics.ISuccessivePhysicsBriefAccessor.html",
    "title": "Interface ISuccessivePhysicsBriefAccessor | HiAPI-C# 2025",
    "summary": "Interface ISuccessivePhysicsBriefAccessor Namespace Hi.Physics Assembly HiMech.dll Interface for accessing sequential physics brief information. public interface ISuccessivePhysicsBriefAccessor Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties SeqPhysicsBrief Gets or sets the sequential physics brief. SeqPhysicsBrief SeqPhysicsBrief { get; set; } Property Value SeqPhysicsBrief"
  },
  "api/Hi.Physics.ISurfaceMaterial.html": {
    "href": "api/Hi.Physics.ISurfaceMaterial.html",
    "title": "Interface ISurfaceMaterial | HiAPI-C# 2025",
    "summary": "Interface ISurfaceMaterial Namespace Hi.Physics Assembly HiMech.dll Interface for materials that can be used on surfaces. public interface ISurfaceMaterial : IStructureMaterial, IMakeXmlSource, IDuplicate, INameNote Inherited Members IStructureMaterial.HeatConductivity_WdmK IStructureMaterial.HeatConductivity_WdmmK IStructureMaterial.HeatCapacity_JdgK IStructureMaterial.Density_gdcm3 IStructureMaterial.Density_gdmm3 IStructureMaterial.ThermalDiffusivity_mm2dsK IStructureMaterial.ElasticModulus_GPa IMakeXmlSource.MakeXmlSource(string, string, bool) IDuplicate.Duplicate(params object[]) INameNote.Name INameNote.Note Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties FrictionCoefficient Gets or sets the friction coefficient of the surface material. double FrictionCoefficient { get; set; } Property Value double"
  },
  "api/Hi.Physics.ITimecoded.html": {
    "href": "api/Hi.Physics.ITimecoded.html",
    "title": "Interface ITimecoded | HiAPI-C# 2025",
    "summary": "Interface ITimecoded Namespace Hi.Physics Assembly HiGeom.dll Interface for objects that provide time information. public interface ITimecoded Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Timecode Gets or sets the time value in seconds. TimeSpan Timecode { get; set; } Property Value TimeSpan"
  },
  "api/Hi.Physics.MillingTemperatureUtil.html": {
    "href": "api/Hi.Physics.MillingTemperatureUtil.html",
    "title": "Class MillingTemperatureUtil | HiAPI-C# 2025",
    "summary": "Class MillingTemperatureUtil Namespace Hi.Physics Assembly HiMech.dll Utility class for calculating and managing temperatures during milling operations. public static class MillingTemperatureUtil Inheritance object MillingTemperatureUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetMaterial(IGetThermalLayerList, double) Gets the thermal material at the specified depth from a thermal layer list. public static IStructureMaterial GetMaterial(this IGetThermalLayerList host, double depth_mm) Parameters host IGetThermalLayerList The object providing the thermal layer list. depth_mm double The depth in millimeters at which to get the material. Returns IStructureMaterial The thermal material at the specified depth, or the last material in the list if the depth exceeds all layers. GetTemperatureVsHardnessCurveByXElements(IEnumerable<XElement>) Creates a list of temperature vs hardness data from XML elements. public static List<TemperatureVsHardness> GetTemperatureVsHardnessCurveByXElements(IEnumerable<XElement> temperatureVsHardnessXElements) Parameters temperatureVsHardnessXElements IEnumerable<XElement> The XML elements containing temperature vs hardness data. Returns List<TemperatureVsHardness> A list of temperature vs hardness data points. ToXElements(IEnumerable<TemperatureVsHardness>) Converts a collection of temperature vs hardness data to XML elements. public static IEnumerable<XElement> ToXElements(this IEnumerable<TemperatureVsHardness> src) Parameters src IEnumerable<TemperatureVsHardness> The source collection of temperature vs hardness data. Returns IEnumerable<XElement> A collection of XML elements representing the temperature vs hardness data."
  },
  "api/Hi.Physics.SeqPhysicsBrief.html": {
    "href": "api/Hi.Physics.SeqPhysicsBrief.html",
    "title": "Class SeqPhysicsBrief | HiAPI-C# 2025",
    "summary": "Class SeqPhysicsBrief Namespace Hi.Physics Assembly HiMech.dll Represents a brief summary of physical properties and measurements during a machining sequence. public class SeqPhysicsBrief : IGetQuantityByKey Inheritance object SeqPhysicsBrief Implements IGetQuantityByKey Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SeqPhysicsBrief(SeqPhysicsBrief) Creates a new instance by copying from an existing SeqPhysicsBrief. public SeqPhysicsBrief(SeqPhysicsBrief src) Parameters src SeqPhysicsBrief The source object to copy from. SeqPhysicsBrief(double, double) Initializes a new instance of the SeqPhysicsBrief class. public SeqPhysicsBrief(double backgroundTemperature_K, double spindleTemperature_K) Parameters backgroundTemperature_K double The background temperature in Kelvin. spindleTemperature_K double The spindle temperature in Kelvin. Properties AccumulatedCraterWear_um Gets or sets the accumulated crater wear in micrometers. public double AccumulatedCraterWear_um { get; set; } Property Value double AccumulatedFlankWearDepth_um Gets or sets the accumulated flank wear depth in micrometers. public double AccumulatedFlankWearDepth_um { get; set; } Property Value double AccumulatedFlankWearWidth_um Gets or sets the accumulated flank wear width in micrometers. public double AccumulatedFlankWearWidth_um { get; set; } Property Value double ChipTemperature_C Gets or sets the chip temperature in Celsius. [NotMapped] public double ChipTemperature_C { get; set; } Property Value double ChipTemperature_K Gets or sets the chip temperature in Kelvin. public double ChipTemperature_K { get; set; } Property Value double CutterBodyTemperature_C Gets or sets the cutter body temperature in Celsius. [NotMapped] public double CutterBodyTemperature_C { get; set; } Property Value double CutterBodyTemperature_K Gets or sets the cutter body temperature in Kelvin. public double CutterBodyTemperature_K { get; set; } Property Value double CutterFluteTemperatureList Gets or sets the list of cutter dermis temperatures at different depths. [0] represents the temperature at the rake surface. public List<double> CutterFluteTemperatureList { get; set; } Property Value List<double> CutterShankTemperatureList Gets or sets the list of cutter body temperatures at different points. public List<double> CutterShankTemperatureList { get; set; } Property Value List<double> CutterSurfaceTemperature_C Gets or sets the cutter surface temperature in Celsius. [NotMapped] public double CutterSurfaceTemperature_C { get; set; } Property Value double CutterSurfaceTemperature_K Gets or sets the cutter surface temperature in Kelvin. public double CutterSurfaceTemperature_K { get; set; } Property Value double InstantCraterWear_um Gets or sets the instant crater wear in micrometers. public double InstantCraterWear_um { get; set; } Property Value double InstantFlankWearDepth_um Gets or sets the instant flank wear depth in micrometers. public double InstantFlankWearDepth_um { get; set; } Property Value double SpindleEnergyConsumption_kJ Accumulation of Spindle input energy. public double SpindleEnergyConsumption_kJ { get; } Property Value double SpindleTemperature_C Gets or sets the spindle temperature in Celsius. public double SpindleTemperature_C { get; } Property Value double SpindleTemperature_K Gets or sets the spindle temperature in Kelvin. public double SpindleTemperature_K { get; } Property Value double SpindleWorkingTemperatureRatio Gets or sets the ratio of current spindle temperature to its working temperature range. public double SpindleWorkingTemperatureRatio { get; set; } Property Value double ThermalStress_MPa Gets or sets the thermal stress in megapascals. public double ThermalStress_MPa { get; } Property Value double ThermalYieldRatio Ratio between Thermal Stress and tensile strength. The tensile strength is applied since the compressive strength is high. so assume if the material shrink back, there arise tensile stress. public double ThermalYieldRatio { get; } Property Value double WorkpieceDermisTemperatureList Gets or sets the list of workpiece dermis temperatures at different depths. public List<double> WorkpieceDermisTemperatureList { get; set; } Property Value List<double> WorkpieceSurfaceTemperature_C Gets or sets the workpiece surface temperature in Celsius. [NotMapped] public double WorkpieceSurfaceTemperature_C { get; set; } Property Value double WorkpieceSurfaceTemperature_K Gets or sets the workpiece surface temperature in Kelvin. public double WorkpieceSurfaceTemperature_K { get; set; } Property Value double Methods AddToCsvDictionary(Dictionary<string, string>) Adds physical quantities to a CSV dictionary representation. public void AddToCsvDictionary(Dictionary<string, string> dst) Parameters dst Dictionary<string, string> The destination dictionary to add values to. AddToQuantityDictionary(Dictionary<string, double>) Adds physical quantities to a numeric dictionary representation. public void AddToQuantityDictionary(Dictionary<string, double> dst) Parameters dst Dictionary<string, double> The destination dictionary to add values to. BuildCuttingTemperatureAndWear(SeqPhysicsBrief, MachineMotionStep, MachineMotionStep, double, SpindleCapability, IMachiningTool, Workpiece, int, Substraction, LayerMillingEngagement, MillingPhysicsBrief, CoolantHeatCondition, CoolantMode, bool, MillingToolPhysicsPack, Action<string>) Builds cutting temperature and wear calculations for the current step. public void BuildCuttingTemperatureAndWear(SeqPhysicsBrief preSeqPhysicsBrief, MachineMotionStep preMachineMotionStep, MachineMotionStep curMachineMotionStep, double backgroundTemperature_K, SpindleCapability spindleCapability, IMachiningTool machiningTool, Workpiece workpiece, int stepIndex, Substraction substraction, LayerMillingEngagement layerMillingEngagement, MillingPhysicsBrief millingPhysicsBrief, CoolantHeatCondition coolantHeatCondition, CoolantMode coolantMode, bool enableWearEffect, MillingToolPhysicsPack physicsPack = null, Action<string> onWarning = null) Parameters preSeqPhysicsBrief SeqPhysicsBrief The previous sequence physics brief. preMachineMotionStep MachineMotionStep The previous machine motion step. curMachineMotionStep MachineMotionStep The current machine motion step. backgroundTemperature_K double The background temperature in Kelvin. spindleCapability SpindleCapability The spindle capability information. machiningTool IMachiningTool The machining tool. workpiece Workpiece The workpiece. stepIndex int The step index. substraction Substraction The substraction data. layerMillingEngagement LayerMillingEngagement The layer milling engagement. millingPhysicsBrief MillingPhysicsBrief The milling physics brief. coolantHeatCondition CoolantHeatCondition The coolant heat condition. coolantMode CoolantMode Current coolant delivery mode — selects which convection coefficient in coolantHeatCondition is used by the temperature FEM. Callers must supply the per-step mode (e.g. from CoolantMode) so the FEM sees the real runtime state rather than a silent default. enableWearEffect bool Whether to enable wear effect calculations. physicsPack MillingToolPhysicsPack The frozen per-session physics pack of machiningTool; null computes the tool's scalar derivations on use. onWarning Action<string> Optional callback invoked with a warning message when the computation cannot complete. BuildSpindleTemperatureAndRatio(MachineMotionStep, MillingPhysicsBrief, double, SpindleCapability, SpindleSpeedCache, double) Internal Use Only. public void BuildSpindleTemperatureAndRatio(MachineMotionStep machiningStep, MillingPhysicsBrief rakeFacePhysicsBrief, double backgroundTemperature_K, SpindleCapability spindleCapability, SpindleSpeedCache spindleSpeedCache, double preSpindleTemperature_K) Parameters machiningStep MachineMotionStep rakeFacePhysicsBrief MillingPhysicsBrief backgroundTemperature_K double spindleCapability SpindleCapability spindleSpeedCache SpindleSpeedCache preSpindleTemperature_K double GetCutterDermisAvgTemperature_K(double, IList<ThermalLayer1D>) Gets the average cutter dermis temperature up to a specific depth. public double GetCutterDermisAvgTemperature_K(double depth, IList<ThermalLayer1D> thermalLayerList) Parameters depth double The depth to calculate the average temperature to thermalLayerList IList<ThermalLayer1D> The list of thermal layers Returns double The average temperature in Kelvin up to the specified depth GetCutterDermisTemperature_K(double, IList<ThermalLayer1D>) Gets the cutter dermis temperature at a specified depth. public double GetCutterDermisTemperature_K(double depth_mm, IList<ThermalLayer1D> thermalLayerList) Parameters depth_mm double The depth in millimeters. thermalLayerList IList<ThermalLayer1D> The thermal layer list. Returns double The temperature in Kelvin. GetQuantityByKey(string) Gets a quantity value associated with the specified key. public double GetQuantityByKey(string key) Parameters key string The key to look up Returns double The quantity value associated with the key SetByCsvDictionary(Dictionary<string, string>, bool) Sets properties from a CSV dictionary. public void SetByCsvDictionary(Dictionary<string, string> src, bool removeFromSource = false) Parameters src Dictionary<string, string> The source dictionary containing values. removeFromSource bool Whether to remove keys from the source dictionary after reading."
  },
  "api/Hi.Physics.StructureMaterial.html": {
    "href": "api/Hi.Physics.StructureMaterial.html",
    "title": "Class StructureMaterial | HiAPI-C# 2025",
    "summary": "Class StructureMaterial Namespace Hi.Physics Assembly HiMech.dll Represents a material with physical and thermal properties used in structural analysis. public class StructureMaterial : IStructureMaterial, IMakeXmlSource, IDuplicate, INameNote, IToXElement Inheritance object StructureMaterial Implements IStructureMaterial IMakeXmlSource IDuplicate INameNote IToXElement Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors StructureMaterial() Default constructor. public StructureMaterial() StructureMaterial(StructureMaterial) Creates a new cutter material as a copy of an existing one. public StructureMaterial(StructureMaterial src) Parameters src StructureMaterial The source material to copy from. StructureMaterial(XElement) Ctor. public StructureMaterial(XElement src) Parameters src XElement XML Properties AlloySteel42CrMo Gets a predefined 42CrMo alloy steel material commonly used for milling cutter bodies. public static StructureMaterial AlloySteel42CrMo { get; } Property Value StructureMaterial Density_gdcm3 Gets or sets the density in grams per cubic centimeter. public double Density_gdcm3 { get; set; } Property Value double Density_gdm3 Density in g/dm³. public double Density_gdm3 { get; set; } Property Value double Density_gdmm3 Density in g/mm³. public double Density_gdmm3 { get; set; } Property Value double ElasticModulus_GPa Gets or sets the elastic modulus in gigapascals. public double ElasticModulus_GPa { get; set; } Property Value double HeatCapacity_JdgK Gets or sets the heat capacity in Joules per gram-Kelvin. public double HeatCapacity_JdgK { get; set; } Property Value double HeatConductivity_WdmK Gets or sets the heat transfer coefficient in Watts per meter-Kelvin. public double HeatConductivity_WdmK { get; set; } Property Value double HeatConductivity_WdmmK Heat transfer coefficient in W/(mm·K). public double HeatConductivity_WdmmK { get; set; } Property Value double Name Gets or sets the name of the object. public string Name { get; set; } Property Value string Note Gets or sets the descriptive note for the object. public string Note { get; set; } Property Value string PoissonRatio public double PoissonRatio { get; set; } Property Value double TensileStrength_MPa public double TensileStrength_MPa { get; set; } Property Value double ThermalExpansionCoefficient_dMK public double ThermalExpansionCoefficient_dMK { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public virtual XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ToXElement() Get the XElement to represent the object. public XElement ToXElement() Returns XElement XElement to represent the object."
  },
  "api/Hi.Physics.TemperatureUtil.html": {
    "href": "api/Hi.Physics.TemperatureUtil.html",
    "title": "Class TemperatureUtil | HiAPI-C# 2025",
    "summary": "Class TemperatureUtil Namespace Hi.Physics Assembly HiMech.dll Utility class for temperature conversions. public static class TemperatureUtil Inheritance object TemperatureUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Fields temperature0C_K Temperature of 0 degrees Celsius in Kelvin. public const double temperature0C_K = 273.16 Field Value double Methods CtoK(double) Convert temperature from Celsius to kelvin. public static double CtoK(double degCelsius) Parameters degCelsius double Returns double KtoC(double) Convert temperature from kelvin to Celsius. public static double KtoC(double degKelvin) Parameters degKelvin double Returns double"
  },
  "api/Hi.Physics.TemperatureVsHardness.html": {
    "href": "api/Hi.Physics.TemperatureVsHardness.html",
    "title": "Class TemperatureVsHardness | HiAPI-C# 2025",
    "summary": "Class TemperatureVsHardness Namespace Hi.Physics Assembly HiMech.dll Represents the relationship between temperature and hardness for materials. public record TemperatureVsHardness : IAdditionOperators<TemperatureVsHardness, TemperatureVsHardness, TemperatureVsHardness>, IMultiplyOperators<TemperatureVsHardness, double, TemperatureVsHardness>, IEquatable<TemperatureVsHardness> Inheritance object TemperatureVsHardness Implements IAdditionOperators<TemperatureVsHardness, TemperatureVsHardness, TemperatureVsHardness> IMultiplyOperators<TemperatureVsHardness, double, TemperatureVsHardness> IEquatable<TemperatureVsHardness> Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors TemperatureVsHardness(TemperatureVsHardness) Initializes a new instance of the TemperatureVsHardness record by copying from another instance. public TemperatureVsHardness(TemperatureVsHardness src) Parameters src TemperatureVsHardness The source instance to copy from. TemperatureVsHardness(double, double) Represents the relationship between temperature and hardness for materials. public TemperatureVsHardness(double Temperature_K, double VickerHardness_Ndmm2) Parameters Temperature_K double The temperature in Kelvin. VickerHardness_Ndmm2 double The Vickers hardness in Newtons per square millimeter. Properties Temperature_K The temperature in Kelvin. public double Temperature_K { get; init; } Property Value double VickerHardness_Ndmm2 The Vickers hardness in Newtons per square millimeter. public double VickerHardness_Ndmm2 { get; init; } Property Value double Operators operator +(TemperatureVsHardness, TemperatureVsHardness) Adds two values together to compute their sum. public static TemperatureVsHardness operator +(TemperatureVsHardness left, TemperatureVsHardness right) Parameters left TemperatureVsHardness The value to which right is added. right TemperatureVsHardness The value that is added to left. Returns TemperatureVsHardness The sum of left and right. operator *(TemperatureVsHardness, double) Multiplies two values together to compute their product. public static TemperatureVsHardness operator *(TemperatureVsHardness left, double right) Parameters left TemperatureVsHardness The value that right multiplies. right double The value that multiplies left. Returns TemperatureVsHardness The product of left multiplied by right."
  },
  "api/Hi.Physics.ThermalLayer1D.html": {
    "href": "api/Hi.Physics.ThermalLayer1D.html",
    "title": "Class ThermalLayer1D | HiAPI-C# 2025",
    "summary": "Class ThermalLayer1D Namespace Hi.Physics Assembly HiMech.dll Represents a one-dimensional thermal layer for heat transfer calculations. public class ThermalLayer1D : IMakeXmlSource Inheritance object ThermalLayer1D Implements IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ThermalLayer1D() Initializes a new instance of the ThermalLayer1D class. public ThermalLayer1D() ThermalLayer1D(IStructureMaterial, double) Initializes a new instance of the ThermalLayer1D class with the specified material and length. public ThermalLayer1D(IStructureMaterial material, double length_mm) Parameters material IStructureMaterial The thermal material of this layer. length_mm double The length of this layer in millimeters. ThermalLayer1D(ThermalLayer1D) Initializes a new instance of the ThermalLayer1D class by copying from another instance. public ThermalLayer1D(ThermalLayer1D src) Parameters src ThermalLayer1D The source thermal layer to copy from. ThermalLayer1D(XElement, string, string, IProgress<IMessage>) Initializes a new instance of the ThermalLayer1D class from XML data. public ThermalLayer1D(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress) Parameters src XElement The XML element containing thermal layer data. baseDirectory string The base directory for resolving relative paths. relFile string The relative file path. progress IProgress<IMessage> Progress reporter for nested material XML loading. Properties Length_mm Gets or sets the length of this thermal layer in millimeters. public double Length_mm { get; set; } Property Value double Length_um Gets or sets the length of this thermal layer in micrometers. public double Length_um { get; set; } Property Value double Material Gets or sets the thermal material of this layer. public IStructureMaterial Material { get; set; } Property Value IStructureMaterial XName Name for XML IO. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Physics.TimeSeriesUtil.html": {
    "href": "api/Hi.Physics.TimeSeriesUtil.html",
    "title": "Class TimeSeriesUtil | HiAPI-C# 2025",
    "summary": "Class TimeSeriesUtil Namespace Hi.Physics Assembly HiGeom.dll Utility class for time series data operations. public static class TimeSeriesUtil Inheritance object TimeSeriesUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods FourierTransformApSeries(List<TimeValue>, TimeSpan, TimeSpan, int) Performs a Fourier transform series on a list of time values and converts the results to amplitude-phase format. public static List<AmpPhase> FourierTransformApSeries(this List<TimeValue> timeValueList, TimeSpan basePeriod, TimeSpan resolutionPeriod, int threadNum = 1) Parameters timeValueList List<TimeValue> timeToValueList which the time length is closed to integral multiple of basePeriod. The offset part cause bias. basePeriod TimeSpan period of 1st fourier transform parameter. resolutionPeriod TimeSpan peroid of last fourier transform parameter. threadNum int thread number. Set 0 to apply processor count. Set 1 for not creating additional thread during the function. Returns List<AmpPhase> A list of amplitude-phase pairs for each frequency FourierTransformApSeries<TimeItem>(List<TimeItem>, TimeSpan, TimeSpan, Func<TimeItem, double>[], int) Performs a Fourier transform series on a list of time-based items and converts the results to amplitude-phase format. public static List<AmpPhase[]> FourierTransformApSeries<TimeItem>(this List<TimeItem> timeValueList, TimeSpan basePeriod, TimeSpan resolutionPeriod, Func<TimeItem, double>[] getValueFuncs, int threadNum = 1) where TimeItem : ITimecoded Parameters timeValueList List<TimeItem> timeToValueList which the time length is closed to integral multiple of basePeriod. The offset part cause bias. basePeriod TimeSpan period of 1st fourier transform parameter. resolutionPeriod TimeSpan peroid of last fourier transform parameter. getValueFuncs Func<TimeItem, double>[] Array of functions to extract values from each time-based item threadNum int thread number. Set 0 to apply processor count. Set 1 for not creating additional thread during the function. Returns List<AmpPhase[]> A list of arrays of amplitude-phase pairs for each frequency and value function Type Parameters TimeItem The type of items that implement ITimecoded FourierTransformSeries(List<TimeValue>, TimeSpan, TimeSpan, int) Performs a Fourier transform series on a list of time values, generating frequency domain data. public static List<Vec2d> FourierTransformSeries(this List<TimeValue> fittedTimeValueList, TimeSpan basePeriod, TimeSpan resolutionPeriod, int threadNum = 1) Parameters fittedTimeValueList List<TimeValue> timeToValueList which the time length is closed to integral multiple of basePeriod. The offset part cause bias. basePeriod TimeSpan period of 1st fourier transform parameter. resolutionPeriod TimeSpan peroid of last fourier transform parameter. threadNum int thread number. Set 0 to apply processor count. Set 1 for not creating additional thread during the function. Returns List<Vec2d> A list of 2D vectors containing the cosine and sine components for each frequency FourierTransformSeries<TimeItem>(List<TimeItem>, TimeSpan, TimeSpan, Func<TimeItem, double>[], int) Performs a Fourier transform series on a list of time-based items, generating frequency domain data for multiple value functions. public static List<Vec2d[]> FourierTransformSeries<TimeItem>(this List<TimeItem> fittedTimeValueList, TimeSpan basePeriod, TimeSpan resolutionPeriod, Func<TimeItem, double>[] getValueFuncs, int threadNum = 1) where TimeItem : ITimecoded Parameters fittedTimeValueList List<TimeItem> timeToValueList which the time length is closed to integral multiple of basePeriod. The offset part cause bias. basePeriod TimeSpan Base period. Effective period. Period of 1st fourier transform parameter. The period should be close and smaller than the full period. resolutionPeriod TimeSpan peroid of last fourier transform parameter. getValueFuncs Func<TimeItem, double>[] Array of functions to extract values from each time-based item threadNum int thread number. Set 0 to apply processor count. Set 1 for not creating additional thread during the function. Returns List<Vec2d[]> A list of arrays of 2D vectors containing the cosine and sine components for each frequency and value function Type Parameters TimeItem The type of items that implement ITimecoded FourierTransformSingleton(List<TimeValue>, double) Performs a Fourier transform at a specific angular frequency for a list of time values. public static Vec2d FourierTransformSingleton(this List<TimeValue> fittedTimeValueList, double kw) Parameters fittedTimeValueList List<TimeValue> The list of time-value pairs to transform kw double The angular frequency to transform at Returns Vec2d A 2D vector containing the cosine and sine components of the transform FourierTransformSingleton(List<TimeValue>, double, TimeSpan) Get fourier transform parameter of indicated angular frequency kw. public static Vec2d FourierTransformSingleton(this List<TimeValue> fittedTimeValueList, double kw, TimeSpan fullPeriod) Parameters fittedTimeValueList List<TimeValue> timeToValueList which the time length is closed to integral multiple of period. The offset part cause bias. kw double multiplication of K (number of angular frequency) and W (base angular frequency f2pi) fullPeriod TimeSpan The full period of the time series. Returns Vec2d (parameter cos,parameter sin) FourierTransformSingleton<TimeItem>(List<TimeItem>, double, Func<TimeItem, double>[]) Performs a Fourier transform at a specific angular frequency for a list of time-based items. public static Vec2d[] FourierTransformSingleton<TimeItem>(this List<TimeItem> fittedTimeValueList, double kw, Func<TimeItem, double>[] getValueFuncs) where TimeItem : ITimecoded Parameters fittedTimeValueList List<TimeItem> The list of time-based items to transform kw double The angular frequency to transform at getValueFuncs Func<TimeItem, double>[] Array of functions to extract values from each TimeItem Returns Vec2d[] An array of 2D vectors containing the cosine and sine components of the transform for each value function Type Parameters TimeItem The type of items that implement ITimecoded FourierTransformSingleton<TimeItem>(List<TimeItem>, double, TimeSpan, Func<TimeItem, double>[]) Get fourier transform parameter of indicated frequency kw. public static Vec2d[] FourierTransformSingleton<TimeItem>(this List<TimeItem> fittedTimeValueList, double kw, TimeSpan fullPeriod, Func<TimeItem, double>[] getValueFuncs) where TimeItem : ITimecoded Parameters fittedTimeValueList List<TimeItem> timeToValueList which the time length is closed to integral multiple of period. The offset part cause bias. kw double multiplication of K and W fullPeriod TimeSpan period of 1st fourier transform parameter. getValueFuncs Func<TimeItem, double>[] Array of functions to extract values from each TimeItem. Returns Vec2d[] (parameter cos,parameter sin) Type Parameters TimeItem GetAvgTimeInterval(List<TimeValue>) Calculates the average time interval between consecutive TimeValue items in a list. public static TimeSpan GetAvgTimeInterval(this List<TimeValue> timeValueList) Parameters timeValueList List<TimeValue> The list of TimeValue objects Returns TimeSpan The average time interval as a TimeSpan GetFullPeriod<TimeItem>(IList<TimeItem>) Gets the total time period covered by a collection of time-based items. public static TimeSpan GetFullPeriod<TimeItem>(this IList<TimeItem> src) where TimeItem : ITimecoded Parameters src IList<TimeItem> The collection of time-based items Returns TimeSpan The time span between the first and last items, or TimeSpan.Zero if the collection is empty Type Parameters TimeItem The type of items that implement ITimecoded GetInterpolatedAvgValueByTime(IEnumerable<KeyValuePair<double, double>>, double) Get interpolated average value by time. public static IEnumerable<KeyValuePair<double, double>> GetInterpolatedAvgValueByTime(this IEnumerable<KeyValuePair<double, double>> sortedTimeToValue, double timeInterval) Parameters sortedTimeToValue IEnumerable<KeyValuePair<double, double>> sorted time to value. Key is time. Value is value. timeInterval double time interval Returns IEnumerable<KeyValuePair<double, double>> enumerable of (Key: time, Value: interpolated average value) GetInterpolatedAvgValueByTime<Data>(IEnumerable<KeyValuePair<double, Data>>, double, Func<Data, Data, Data>, Func<Data, double, Data>) Get interpolated average value by time. public static IEnumerable<KeyValuePair<double, Data>> GetInterpolatedAvgValueByTime<Data>(this IEnumerable<KeyValuePair<double, Data>> sortedTimeToValue, double timeInterval, Func<Data, Data, Data> addingFunc, Func<Data, double, Data> scalingFunc) Parameters sortedTimeToValue IEnumerable<KeyValuePair<double, Data>> sorted time to value. Key is time. Value is value. timeInterval double time interval addingFunc Func<Data, Data, Data> Function to add two values of type Data scalingFunc Func<Data, double, Data> Function to scale a value of type Data by a factor Returns IEnumerable<KeyValuePair<double, Data>> enumerable of (Key: time, Value: interpolated average value) Type Parameters Data The type of data values GetInterpolatedValueByTime(List<TimeValue>, TimeSpan) Gets an interpolated value from a list of TimeValue objects at a specified time. public static double GetInterpolatedValueByTime(this List<TimeValue> timeVsValueContour, TimeSpan t) Parameters timeVsValueContour List<TimeValue> The list of TimeValue objects t TimeSpan The time at which to interpolate Returns double The interpolated value at the specified time GetInterpolatedValueByTime(SortedList<double, double>, double) Gets an interpolated double value from a time-value contour at a specified time. public static double GetInterpolatedValueByTime(this SortedList<double, double> timeVsValueContour, double t) Parameters timeVsValueContour SortedList<double, double> The sorted list of time-value pairs t double The time at which to interpolate Returns double The interpolated value at the specified time GetInterpolatedValueByTime<T>(SortedList<double, T>, double, Func<T, T, T>, Func<T, double, T>) Gets an interpolated value from a time-value contour at a specified time. public static T GetInterpolatedValueByTime<T>(this SortedList<double, T> timeVsValueContour, double t, Func<T, T, T> addingFunc, Func<T, double, T> scalingFunc) Parameters timeVsValueContour SortedList<double, T> The sorted list of time-value pairs t double The time at which to interpolate addingFunc Func<T, T, T> Function to add two values of type T scalingFunc Func<T, double, T> Function to scale a value of type T by a factor Returns T The interpolated value at the specified time Type Parameters T The type of values in the contour"
  },
  "api/Hi.Physics.TimeValue.html": {
    "href": "api/Hi.Physics.TimeValue.html",
    "title": "Class TimeValue | HiAPI-C# 2025",
    "summary": "Class TimeValue Namespace Hi.Physics Assembly HiGeom.dll Represents a value associated with a specific point in time. public class TimeValue : ITimecoded Inheritance object TimeValue Implements ITimecoded Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors TimeValue(TimeSpan, double) Initializes a new instance of the TimeValue class with the specified time and value. public TimeValue(TimeSpan time_s, double value) Parameters time_s TimeSpan The time in seconds. value double The value associated with the time. Fields value The value associated with the time. public double value Field Value double Properties Timecode Gets or sets the time value in seconds. public TimeSpan Timecode { get; set; } Property Value TimeSpan Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. ToString(string) Returns a string representation of this instance using the specified format. public string ToString(string format) Parameters format string The format to use for the string representation. Returns string A string representation of this instance. Operators operator +(TimeValue, TimeValue) Adds two TimeValue instances. public static TimeValue operator +(TimeValue a, TimeValue b) Parameters a TimeValue The first TimeValue instance. b TimeValue The second TimeValue instance. Returns TimeValue A new TimeValue instance with the sum of times and values. operator *(TimeValue, double) Multiplies a TimeValue instance by a scalar. public static TimeValue operator *(TimeValue a, double scale) Parameters a TimeValue The TimeValue instance to multiply. scale double The scalar value to multiply by. Returns TimeValue A new TimeValue instance with scaled time and value."
  },
  "api/Hi.Physics.WorkpieceMaterial.html": {
    "href": "api/Hi.Physics.WorkpieceMaterial.html",
    "title": "Class WorkpieceMaterial | HiAPI-C# 2025",
    "summary": "Class WorkpieceMaterial Namespace Hi.Physics Assembly HiMech.dll Represents the physical and mechanical properties of a workpiece material. public class WorkpieceMaterial : IPreferredFileName, IStructureMaterial, IMakeXmlSource, IDuplicate, INameNote Inheritance object WorkpieceMaterial Implements IPreferredFileName IStructureMaterial IMakeXmlSource IDuplicate INameNote Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors WorkpieceMaterial() Ctor. public WorkpieceMaterial() WorkpieceMaterial(XElement, string) Ctor. public WorkpieceMaterial(XElement src, string baseDirectory) Parameters src XElement XML baseDirectory string Base directory path for resolving relative paths Properties Al6061T6 General condition of Al6061T6. public static WorkpieceMaterial Al6061T6 { get; } Property Value WorkpieceMaterial CompressiveYieldStrength_MPa Gets or sets the compressive yield strength in megapascals (MPa). public double CompressiveYieldStrength_MPa { get; set; } Property Value double Density_gdcm3 Gets or sets the density in grams per cubic centimeter (g/cm³). public double Density_gdcm3 { get; set; } Property Value double Density_gdm3 Gets or sets the density in grams per cubic decimeter (g/dm³). public double Density_gdm3 { get; set; } Property Value double Density_gdmm3 Gets or sets the density in grams per cubic millimeter (g/mm³). public double Density_gdmm3 { get; set; } Property Value double ElasticModulus_GPa Gets or sets the elastic modulus in gigapascals (GPa). public double ElasticModulus_GPa { get; set; } Property Value double ElogationRaioAtBreak Gets or sets the elongation ratio at break point. public double ElogationRaioAtBreak { get; set; } Property Value double FusionLatentHeat_Jdg Gets or sets the latent heat of fusion in joules per gram (J/g). public double FusionLatentHeat_Jdg { get; set; } Property Value double HeatCapacity_JdgK Gets or sets the specific heat capacity in joules per gram per Kelvin (J/g·K). public double HeatCapacity_JdgK { get; set; } Property Value double HeatConductivity_WdmK Gets or sets the heat transfer coefficient in watts per decimeter per Kelvin (W/dm·K). public double HeatConductivity_WdmK { get; set; } Property Value double HeatConductivity_WdmmK Gets or sets the heat conductivity in watts per millimeter per Kelvin (W/mm·K). This is a conversion of HeatConductivity_WdmK with a factor of 1/1000. public double HeatConductivity_WdmmK { get; set; } Property Value double MeltingTemperature_C Gets or sets the melting temperature in Celsius (°C). public double MeltingTemperature_C { get; set; } Property Value double MeltingTemperature_K Gets or sets the melting temperature in Kelvin (K). public double MeltingTemperature_K { get; set; } Property Value double Name Gets or sets the name of the material. public string Name { get; set; } Property Value string Note Gets or sets additional notes about the material. public string Note { get; set; } Property Value string PoissonRatio Gets or sets the Poisson's ratio of the material. public double PoissonRatio { get; set; } Property Value double PreferredFileName Gets or sets the preferred file name for this object when generating or saving files. public string PreferredFileName { get; set; } Property Value string TensileYieldStrength_MPa Gets or sets the tensile yield strength in megapascals (MPa). public double TensileYieldStrength_MPa { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods Duplicate(params object[]) Creates a deep copy of the object, excluding any source file references. public object Duplicate(params object[] res) Parameters res object[] Optional parameters that may be needed during the duplication process Returns object A new instance that is a deep copy of the original object MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory"
  },
  "api/Hi.Physics.html": {
    "href": "api/Hi.Physics.html",
    "title": "Namespace Hi.Physics | HiAPI-C# 2025",
    "summary": "Namespace Hi.Physics Classes AmpPhase Represents amplitude and phase information for wave-like phenomena. CoatingMaterial Represents a coating material used in cutting tools. CoolantHeatCondition Represents the heat condition parameters for coolant in machining operations. Provides effective convection-coefficient lookups keyed by CoolantMode — Flood uses the configured baseline CoolantConvectionCoefficient_Wdm2K; Mist scales it by MistFloodConvectionRatio; Off falls back to OffConvectionCoefficient_Wdm2K (natural/forced air). Named standard presets (StandardForcedAir, StandardWaterSolubleCoolant, StandardOilBasedCoolant) bundle all coefficients so end users can pick a cooling type by name instead of entering convection coefficients; MatchStandardPreset() maps a configured instance back to the preset it equals. CutterMaterial Represents a cutter material with physical and thermal properties. MillingTemperatureUtil Utility class for calculating and managing temperatures during milling operations. SeqPhysicsBrief Represents a brief summary of physical properties and measurements during a machining sequence. StructureMaterial Represents a material with physical and thermal properties used in structural analysis. TemperatureUtil Utility class for temperature conversions. TemperatureVsHardness Represents the relationship between temperature and hardness for materials. ThermalLayer1D Represents a one-dimensional thermal layer for heat transfer calculations. TimeSeriesUtil Utility class for time series data operations. TimeValue Represents a value associated with a specific point in time. WorkpieceMaterial Represents the physical and mechanical properties of a workpiece material. Interfaces IGetThermalLayerList Interface for objects that can provide a list of thermal layers. IStructureMaterial Interface for structure materials with thermal properties. ISuccessivePhysicsBriefAccessor Interface for accessing sequential physics brief information. ISurfaceMaterial Interface for materials that can be used on surfaces. ITimecoded Interface for objects that provide time information."
  },
  "api/Hi.SessionCommands.CollisionDetectionCommand.html": {
    "href": "api/Hi.SessionCommands.CollisionDetectionCommand.html",
    "title": "Class CollisionDetectionCommand | HiAPI-C# 2025",
    "summary": "Class CollisionDetectionCommand Namespace Hi.SessionCommands Assembly HiNc.dll Command that turns collision detection on or off for the session. One of the single-setting successors of the legacy PreSettingCommand bundle. [CultureText(\"zh-Hant\", \"碰撞偵測\")] [CultureText(\"zh-Hans\", \"碰撞检测\")] [CommandCatalog(CommandCategory.Setup, Order = 2)] public class CollisionDetectionCommand : ITitleCommand, ISessionCommand, IMakeXmlSource Inheritance object CollisionDetectionCommand Implements ITitleCommand ISessionCommand IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CollisionDetectionCommand() Ctor. public CollisionDetectionCommand() CollisionDetectionCommand(XElement, string) Ctor. public CollisionDetectionCommand(XElement src, string baseDirectory) Parameters src XElement XML baseDirectory string Base directory for resolving relative paths Properties Enable Whether collision detection is enabled from this command on. [CultureText(\"zh-Hant\", \"啟用碰撞偵測\", Key = \"Enable Collision Detection\")] [CultureText(\"zh-Hans\", \"启用碰撞检测\", Key = \"Enable Collision Detection\")] public bool Enable { get; set; } Property Value bool XName Name for XML IO. public static string XName { get; } Property Value string Methods GetCommandTitle(ICommandTextSource) Gets the title of the command — one row in a command list or a mission tree — composed from the caller's vocabulary: the command owns the composition and degradation rules, the caller owns the language. The shape is Name, or Name [detail] once there is a detail worth showing. The NAME always leads and is never dropped: a row must say WHAT it is even when the detail is a title the user wrote, otherwise a newcomer cannot tell a command list from a script. The detail trails because these rows truncate from the right. An empty detail takes the bare-name form rather than rendering dangling brackets. public string GetCommandTitle(ICommandTextSource text) Parameters text ICommandTextSource Culture-bearing vocabulary the static words are taken from. Returns string The command title. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Run(SessionShell) Runs the command, delegating execution to the provided session shell. public IEnumerable<Action> Run(SessionShell sessionShell) Parameters sessionShell SessionShell Session shell that exposes the machining facade to commands. Returns IEnumerable<Action> Sequence of actions to be executed."
  },
  "api/Hi.SessionCommands.CommandCatalogAttribute.html": {
    "href": "api/Hi.SessionCommands.CommandCatalogAttribute.html",
    "title": "Class CommandCatalogAttribute | HiAPI-C# 2025",
    "summary": "Class CommandCatalogAttribute Namespace Hi.SessionCommands Assembly HiNc.dll Marks an ISessionCommand as user-addable: GUIs build their “Add Command” catalog from the commands carrying this attribute, grouped by Category. A command WITHOUT this attribute stays loadable from project files (its Reg registration is unaffected) but is not offered for creation. [AttributeUsage(AttributeTargets.Class, Inherited = false)] public sealed class CommandCatalogAttribute : Attribute Inheritance object Attribute CommandCatalogAttribute Inherited Members Attribute.Equals(object) Attribute.GetCustomAttribute(Assembly, Type) Attribute.GetCustomAttribute(Assembly, Type, bool) Attribute.GetCustomAttribute(MemberInfo, Type) Attribute.GetCustomAttribute(MemberInfo, Type, bool) Attribute.GetCustomAttribute(Module, Type) Attribute.GetCustomAttribute(Module, Type, bool) Attribute.GetCustomAttribute(ParameterInfo, Type) Attribute.GetCustomAttribute(ParameterInfo, Type, bool) Attribute.GetCustomAttributes(Assembly) Attribute.GetCustomAttributes(Assembly, bool) Attribute.GetCustomAttributes(Assembly, Type) Attribute.GetCustomAttributes(Assembly, Type, bool) Attribute.GetCustomAttributes(MemberInfo) Attribute.GetCustomAttributes(MemberInfo, bool) Attribute.GetCustomAttributes(MemberInfo, Type) Attribute.GetCustomAttributes(MemberInfo, Type, bool) Attribute.GetCustomAttributes(Module) Attribute.GetCustomAttributes(Module, bool) Attribute.GetCustomAttributes(Module, Type) Attribute.GetCustomAttributes(Module, Type, bool) Attribute.GetCustomAttributes(ParameterInfo) Attribute.GetCustomAttributes(ParameterInfo, bool) Attribute.GetCustomAttributes(ParameterInfo, Type) Attribute.GetCustomAttributes(ParameterInfo, Type, bool) Attribute.GetHashCode() Attribute.IsDefaultAttribute() Attribute.IsDefined(Assembly, Type) Attribute.IsDefined(Assembly, Type, bool) Attribute.IsDefined(MemberInfo, Type) Attribute.IsDefined(MemberInfo, Type, bool) Attribute.IsDefined(Module, Type) Attribute.IsDefined(Module, Type, bool) Attribute.IsDefined(ParameterInfo, Type) Attribute.IsDefined(ParameterInfo, Type, bool) Attribute.Match(object) Attribute.TypeId object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors CommandCatalogAttribute(CommandCategory) Places the command under category in the catalog. public CommandCatalogAttribute(CommandCategory category) Parameters category CommandCategory Catalog category the command is listed under. Properties Aliases Extra search keywords for catalog search boxes. Each entry is a vocabulary key (an English default word, localized through CultureTextAttribute declarations the way title words are). Declare the terms users search by that appear in neither the display name nor the kind key — e.g. RecordMeshedGeomCommand aliases Read / Write, its action modes. Null when the command needs none. public string[] Aliases { get; set; } Property Value string[] Category Catalog category the command is listed under. public CommandCategory Category { get; } Property Value CommandCategory Kind Wire kind key web APIs use for the command type. Default (null): the class name without the Command suffix, lower-cased (e.g. NcFileCommand → ncfile). Set explicitly only to keep a historical key alive. public string Kind { get; set; } Property Value string Order Sort key within the category (ascending; ties sort by display name). public int Order { get; set; } Property Value int Methods GetKind(Type) The effective wire kind key of commandType: the attribute's explicit Kind when set, otherwise the default derivation described on Kind. Works for un-attributed types too (derivation only). public static string GetKind(Type commandType) Parameters commandType Type The session command type. Returns string The wire kind key."
  },
  "api/Hi.SessionCommands.CommandCategory.html": {
    "href": "api/Hi.SessionCommands.CommandCategory.html",
    "title": "Enum CommandCategory | HiAPI-C# 2025",
    "summary": "Enum CommandCategory Namespace Hi.SessionCommands Assembly HiNc.dll Category of a session command in user-facing command catalogs (the GUI “Add Command” listings). Declaration order is the display order. public enum CommandCategory Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields [CultureText(\"zh-Hant\", \"流程\")] [CultureText(\"zh-Hans\", \"流程\")] Flow = 4 Structural commands that organize other commands. [CultureText(\"zh-Hant\", \"優化\")] [CultureText(\"zh-Hans\", \"优化\")] Optimization = 2 Optimization configuration. [CultureText(\"zh-Hant\", \"輸出\")] [CultureText(\"zh-Hans\", \"输出\")] Output = 3 File and geometry outputs. [CultureText(\"zh-Hant\", \"程式\")] [CultureText(\"zh-Hans\", \"程序\")] Program = 1 Executable program content (program files, inline NC code, scripts). [CultureText(\"zh-Hant\", \"設定\")] [CultureText(\"zh-Hans\", \"设置\")] Setup = 0 Session-state settings applied when the command runs (resolutions, detection switches, physics)."
  },
  "api/Hi.SessionCommands.CommandFieldAttribute.html": {
    "href": "api/Hi.SessionCommands.CommandFieldAttribute.html",
    "title": "Class CommandFieldAttribute | HiAPI-C# 2025",
    "summary": "Class CommandFieldAttribute Namespace Hi.SessionCommands Assembly HiNc.dll Marks a session-command property as a directly editable scalar field, so generic editors (e.g. the web UI's fallback command panel) can render and update it without a hand-written per-command editor. Supported property types: bool, int, double and string. [AttributeUsage(AttributeTargets.Property, Inherited = false)] public sealed class CommandFieldAttribute : Attribute Inheritance object Attribute CommandFieldAttribute Inherited Members Attribute.Equals(object) Attribute.GetCustomAttribute(Assembly, Type) Attribute.GetCustomAttribute(Assembly, Type, bool) Attribute.GetCustomAttribute(MemberInfo, Type) Attribute.GetCustomAttribute(MemberInfo, Type, bool) Attribute.GetCustomAttribute(Module, Type) Attribute.GetCustomAttribute(Module, Type, bool) Attribute.GetCustomAttribute(ParameterInfo, Type) Attribute.GetCustomAttribute(ParameterInfo, Type, bool) Attribute.GetCustomAttributes(Assembly) Attribute.GetCustomAttributes(Assembly, bool) Attribute.GetCustomAttributes(Assembly, Type) Attribute.GetCustomAttributes(Assembly, Type, bool) Attribute.GetCustomAttributes(MemberInfo) Attribute.GetCustomAttributes(MemberInfo, bool) Attribute.GetCustomAttributes(MemberInfo, Type) Attribute.GetCustomAttributes(MemberInfo, Type, bool) Attribute.GetCustomAttributes(Module) Attribute.GetCustomAttributes(Module, bool) Attribute.GetCustomAttributes(Module, Type) Attribute.GetCustomAttributes(Module, Type, bool) Attribute.GetCustomAttributes(ParameterInfo) Attribute.GetCustomAttributes(ParameterInfo, bool) Attribute.GetCustomAttributes(ParameterInfo, Type) Attribute.GetCustomAttributes(ParameterInfo, Type, bool) Attribute.GetHashCode() Attribute.IsDefaultAttribute() Attribute.IsDefined(Assembly, Type) Attribute.IsDefined(Assembly, Type, bool) Attribute.IsDefined(MemberInfo, Type) Attribute.IsDefined(MemberInfo, Type, bool) Attribute.IsDefined(Module, Type) Attribute.IsDefined(Module, Type, bool) Attribute.IsDefined(ParameterInfo, Type) Attribute.IsDefined(ParameterInfo, Type, bool) Attribute.Match(object) Attribute.TypeId object.Equals(object, object) object.GetType() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Label Display-label localization key (its English text). Default (null): the property name with PascalCase words spaced and any _unit suffix removed (e.g. MachiningResolution_mm → “Machining Resolution”). public string Label { get; set; } Property Value string PhysicsLicenseGated The field configures physics simulation; GUIs disable it when the physics license is absent. public bool PhysicsLicenseGated { get; set; } Property Value bool Unit Measurement unit shown after the input (e.g. mm), if any. public string Unit { get; set; } Property Value string Methods GetLabel(PropertyInfo) The effective display-label key of property: the attribute's explicit Label when set, otherwise the default derivation described on Label. public static string GetLabel(PropertyInfo property) Parameters property PropertyInfo The command property carrying this attribute. Returns string The label localization key."
  },
  "api/Hi.SessionCommands.EnablingWrapper.html": {
    "href": "api/Hi.SessionCommands.EnablingWrapper.html",
    "title": "Class EnablingWrapper | HiAPI-C# 2025",
    "summary": "Class EnablingWrapper Namespace Hi.SessionCommands Assembly HiNc.dll Wrapper for session commands that provides enable/disable functionality. public class EnablingWrapper : ISessionCommand, IMakeXmlSource Inheritance object EnablingWrapper Implements ISessionCommand IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors EnablingWrapper() Ctor. public EnablingWrapper() EnablingWrapper(ISessionCommand) Initializes a new instance of the EnablingWrapper class with the specified command. public EnablingWrapper(ISessionCommand command) Parameters command ISessionCommand The command to wrap. EnablingWrapper(XElement, string, string, IProgress<IMessage>, object[]) Ctor. public EnablingWrapper(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress, object[] res) Parameters src XElement XML baseDirectory string Base directory for relative paths relFile string Relative file path progress IProgress<IMessage> Progress reporter for nested command XML. res object[] Additional resources Properties Command Gets or sets the wrapped session command. public ISessionCommand Command { get; set; } Property Value ISessionCommand IsEnabled Gets or sets whether the wrapped command is enabled. public bool IsEnabled { get; set; } Property Value bool XName Name for XML IO. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Run(SessionShell) Runs the command, delegating execution to the provided session shell. public IEnumerable<Action> Run(SessionShell sessionShell) Parameters sessionShell SessionShell Session shell that exposes the machining facade to commands. Returns IEnumerable<Action> Sequence of actions to be executed."
  },
  "api/Hi.SessionCommands.ExportMeshedGeomToStlCommand.html": {
    "href": "api/Hi.SessionCommands.ExportMeshedGeomToStlCommand.html",
    "title": "Class ExportMeshedGeomToStlCommand | HiAPI-C# 2025",
    "summary": "Class ExportMeshedGeomToStlCommand Namespace Hi.SessionCommands Assembly HiNc.dll Command to call ExportMeshedGeomToStl(string, double). [CultureText(\"zh-Hant\", \"匯出網格幾何 STL\")] [CultureText(\"zh-Hans\", \"导出网格几何 STL\")] [CommandCatalog(CommandCategory.Output, Order = 2, Kind = \"exportmeshedgeom\")] public class ExportMeshedGeomToStlCommand : ITitleCommand, ISessionCommand, IMakeXmlSource Inheritance object ExportMeshedGeomToStlCommand Implements ITitleCommand ISessionCommand IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ExportMeshedGeomToStlCommand() Default constructor. public ExportMeshedGeomToStlCommand() ExportMeshedGeomToStlCommand(XElement, string) Ctor. public ExportMeshedGeomToStlCommand(XElement src, string baseDirectory) Parameters src XElement XML baseDirectory string Base directory for resolving relative paths Properties RelFile Relative path for the output STL file. public string RelFile { get; set; } Property Value string Resolution_mm Resolution in millimeters for STL generation. public double Resolution_mm { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods GetCommandTitle(ICommandTextSource) Gets the title of the command — one row in a command list or a mission tree — composed from the caller's vocabulary: the command owns the composition and degradation rules, the caller owns the language. The shape is Name, or Name [detail] once there is a detail worth showing. The NAME always leads and is never dropped: a row must say WHAT it is even when the detail is a title the user wrote, otherwise a newcomer cannot tell a command list from a script. The detail trails because these rows truncate from the right. An empty detail takes the bare-name form rather than rendering dangling brackets. public string GetCommandTitle(ICommandTextSource text) Parameters text ICommandTextSource Culture-bearing vocabulary the static words are taken from. Returns string The command title. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Run(SessionShell) Runs the command, delegating execution to the provided session shell. public IEnumerable<Action> Run(SessionShell sessionShell) Parameters sessionShell SessionShell Session shell that exposes the machining facade to commands. Returns IEnumerable<Action> Sequence of actions to be executed."
  },
  "api/Hi.SessionCommands.GeomDiffCommand.html": {
    "href": "api/Hi.SessionCommands.GeomDiffCommand.html",
    "title": "Class GeomDiffCommand | HiAPI-C# 2025",
    "summary": "Class GeomDiffCommand Namespace Hi.SessionCommands Assembly HiNc.dll Command for calculating geometric differences between workpieces. [CultureText(\"zh-Hant\", \"幾何差異\")] [CultureText(\"zh-Hans\", \"几何差异\")] public class GeomDiffCommand : ISessionCommand, IMakeXmlSource Inheritance object GeomDiffCommand Implements ISessionCommand IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors GeomDiffCommand() Default constructor. public GeomDiffCommand() GeomDiffCommand(XElement, string) Ctor. public GeomDiffCommand(XElement src, string baseDirectory) Parameters src XElement XML baseDirectory string Base directory for relative paths. Fields ConstDisplayName Display name constant for this command. public const string ConstDisplayName = \"Geometry Difference\" Field Value string Properties DetectRadius_mm Detection radius in millimeters. public double DetectRadius_mm { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Run(SessionShell) Runs the command, delegating execution to the provided session shell. public IEnumerable<Action> Run(SessionShell sessionShell) Parameters sessionShell SessionShell Session shell that exposes the machining facade to commands. Returns IEnumerable<Action> Sequence of actions to be executed."
  },
  "api/Hi.SessionCommands.ISessionCommand.html": {
    "href": "api/Hi.SessionCommands.ISessionCommand.html",
    "title": "Interface ISessionCommand | HiAPI-C# 2025",
    "summary": "Interface ISessionCommand Namespace Hi.SessionCommands Assembly HiNc.dll Interface for commands that can be executed in a machining session. public interface ISessionCommand : IMakeXmlSource Inherited Members IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods Run(SessionShell) Runs the command, delegating execution to the provided session shell. IEnumerable<Action> Run(SessionShell sessionShell) Parameters sessionShell SessionShell Session shell that exposes the machining facade to commands. Returns IEnumerable<Action> Sequence of actions to be executed."
  },
  "api/Hi.SessionCommands.ITitleCommand.html": {
    "href": "api/Hi.SessionCommands.ITitleCommand.html",
    "title": "Interface ITitleCommand | HiAPI-C# 2025",
    "summary": "Interface ITitleCommand Namespace Hi.SessionCommands Assembly HiNc.dll ISessionCommand with title. [CultureText(\"zh-Hant\", \"開\", Key = \"On\")] [CultureText(\"zh-Hans\", \"开\", Key = \"On\")] [CultureText(\"zh-Hant\", \"關\", Key = \"Off\")] [CultureText(\"zh-Hans\", \"关\", Key = \"Off\")] public interface ITitleCommand : ISessionCommand, IMakeXmlSource Inherited Members ISessionCommand.Run(SessionShell) IMakeXmlSource.MakeXmlSource(string, string, bool) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods GetCommandTitle(ICommandTextSource) Gets the title of the command — one row in a command list or a mission tree — composed from the caller's vocabulary: the command owns the composition and degradation rules, the caller owns the language. The shape is Name, or Name [detail] once there is a detail worth showing. The NAME always leads and is never dropped: a row must say WHAT it is even when the detail is a title the user wrote, otherwise a newcomer cannot tell a command list from a script. The detail trails because these rows truncate from the right. An empty detail takes the bare-name form rather than rendering dangling brackets. string GetCommandTitle(ICommandTextSource text) Parameters text ICommandTextSource Culture-bearing vocabulary the static words are taken from. Returns string The command title."
  },
  "api/Hi.SessionCommands.Lang.html": {
    "href": "api/Hi.SessionCommands.Lang.html",
    "title": "Class Lang | HiAPI-C# 2025",
    "summary": "Class Lang Namespace Hi.SessionCommands Assembly HiNc.dll Language package class for command flow. public class Lang Inheritance object Lang Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.SessionCommands.ListCommand.html": {
    "href": "api/Hi.SessionCommands.ListCommand.html",
    "title": "Class ListCommand | HiAPI-C# 2025",
    "summary": "Class ListCommand Namespace Hi.SessionCommands Assembly HiNc.dll A command that contains and executes a list of other commands. [CultureText(\"zh-Hant\", \"清單\")] [CultureText(\"zh-Hans\", \"列表\")] [CommandCatalog(CommandCategory.Flow, Order = 0)] public class ListCommand : ITitleCommand, ISessionCommand, IMakeXmlSource Inheritance object ListCommand Implements ITitleCommand ISessionCommand IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ListCommand() Default constructor. public ListCommand() ListCommand(XElement, string, string, IProgress<IMessage>, object[]) Ctor. public ListCommand(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress, object[] res) Parameters src XElement XML baseDirectory string Base directory for relative paths. relFile string Relative file path. progress IProgress<IMessage> Progress reporter for nested command XML. res object[] Additional resources Fields ConstDisplayName The command's own name — the DisplayNameAttribute value AND the localization key (Blazor reads it through GetSelectionName(), the web catalog through the same attribute). Not “Command List”: every row that can hold one of these is already a command, so the word carries nothing and costs tree width. public const string ConstDisplayName = \"List\" Field Value string Properties CommandEntryList Command List. The item in list is null capable. public List<EnablingWrapper> CommandEntryList { get; set; } Property Value List<EnablingWrapper> Title Optional display title. GUI lists show it as the DETAIL after the localized type name when non-empty (see GetCommandTitle(ICommandTextSource)) — a titled list must still read as a list. public string Title { get; set; } Property Value string XName Name for XML IO. public static string XName { get; } Property Value string Methods GetCommandTitle(ICommandTextSource) Gets the title of the command — one row in a command list or a mission tree — composed from the caller's vocabulary: the command owns the composition and degradation rules, the caller owns the language. The shape is Name, or Name [detail] once there is a detail worth showing. The NAME always leads and is never dropped: a row must say WHAT it is even when the detail is a title the user wrote, otherwise a newcomer cannot tell a command list from a script. The detail trails because these rows truncate from the right. An empty detail takes the bare-name form rather than rendering dangling brackets. public string GetCommandTitle(ICommandTextSource text) Parameters text ICommandTextSource Culture-bearing vocabulary the static words are taken from. Returns string The command title. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null), and chains Reg(factory) on dependents so the registration graph is observable. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Run(SessionShell) Runs the command, delegating execution to the provided session shell. public IEnumerable<Action> Run(SessionShell sessionShell) Parameters sessionShell SessionShell Session shell that exposes the machining facade to commands. Returns IEnumerable<Action> Sequence of actions to be executed."
  },
  "api/Hi.SessionCommands.MachiningMotionResolutionCommand.html": {
    "href": "api/Hi.SessionCommands.MachiningMotionResolutionCommand.html",
    "title": "Class MachiningMotionResolutionCommand | HiAPI-C# 2025",
    "summary": "Class MachiningMotionResolutionCommand Namespace Hi.SessionCommands Assembly HiNc.dll Command for setting machining motion resolution for the milling process. [CultureText(\"zh-Hant\", \"運動解析度\")] [CultureText(\"zh-Hans\", \"运动分辨率\")] [CultureText(\"zh-Hant\", \"每轉進給\", Key = \"Feed Per Cycle\")] [CultureText(\"zh-Hans\", \"每转进给\", Key = \"Feed Per Cycle\")] [CultureText(\"zh-Hant\", \"每刃進給\", Key = \"Feed Per Tooth\")] [CultureText(\"zh-Hans\", \"每刃进给\", Key = \"Feed Per Tooth\")] [CultureText(\"zh-Hant\", \"固定\", Key = \"Fixed\")] [CultureText(\"zh-Hans\", \"固定\", Key = \"Fixed\")] [CommandCatalog(CommandCategory.Setup, Order = 1)] public class MachiningMotionResolutionCommand : ITitleCommand, ISessionCommand, IMakeXmlSource Inheritance object MachiningMotionResolutionCommand Implements ITitleCommand ISessionCommand IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MachiningMotionResolutionCommand() Ctor. public MachiningMotionResolutionCommand() MachiningMotionResolutionCommand(XElement, string, string, IProgress<IMessage>) Ctor. public MachiningMotionResolutionCommand(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress) Parameters src XElement XML baseDirectory string Base directory for resolving relative paths relFile string Relative file path progress IProgress<IMessage> Progress reporter for nested resolution XML. Properties MachiningMotionResolution Main content. Machining Cycle Resolution. public IMachiningMotionResolution MachiningMotionResolution { get; set; } Property Value IMachiningMotionResolution XName Name for XML IO. public static string XName { get; } Property Value string Methods GetCommandTitle(ICommandTextSource) Gets the title of the command — one row in a command list or a mission tree — composed from the caller's vocabulary: the command owns the composition and degradation rules, the caller owns the language. The shape is Name, or Name [detail] once there is a detail worth showing. The NAME always leads and is never dropped: a row must say WHAT it is even when the detail is a title the user wrote, otherwise a newcomer cannot tell a command list from a script. The detail trails because these rows truncate from the right. An empty detail takes the bare-name form rather than rendering dangling brackets. public string GetCommandTitle(ICommandTextSource text) Parameters text ICommandTextSource Culture-bearing vocabulary the static words are taken from. Returns string The command title. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null), and chains Reg(factory) on dependents so the registration graph is observable. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Run(SessionShell) Runs the command, delegating execution to the provided session shell. public IEnumerable<Action> Run(SessionShell sessionShell) Parameters sessionShell SessionShell Session shell that exposes the machining facade to commands. Returns IEnumerable<Action> Sequence of actions to be executed."
  },
  "api/Hi.SessionCommands.MachiningResolutionCommand.html": {
    "href": "api/Hi.SessionCommands.MachiningResolutionCommand.html",
    "title": "Class MachiningResolutionCommand | HiAPI-C# 2025",
    "summary": "Class MachiningResolutionCommand Namespace Hi.SessionCommands Assembly HiNc.dll Command that sets the session's machining resolution — the meshing resolution of material removal. One of the single-setting successors of the legacy PreSettingCommand bundle. [CultureText(\"zh-Hant\", \"加工解析度\")] [CultureText(\"zh-Hans\", \"加工分辨率\")] [CommandCatalog(CommandCategory.Setup, Order = 0)] public class MachiningResolutionCommand : ITitleCommand, ISessionCommand, IMakeXmlSource Inheritance object MachiningResolutionCommand Implements ITitleCommand ISessionCommand IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors MachiningResolutionCommand() Ctor. public MachiningResolutionCommand() MachiningResolutionCommand(XElement, string) Ctor. public MachiningResolutionCommand(XElement src, string baseDirectory) Parameters src XElement XML baseDirectory string Base directory for resolving relative paths Properties MachiningResolution_mm Machining resolution in millimeters. public double MachiningResolution_mm { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods GetCommandTitle(ICommandTextSource) Gets the title of the command — one row in a command list or a mission tree — composed from the caller's vocabulary: the command owns the composition and degradation rules, the caller owns the language. The shape is Name, or Name [detail] once there is a detail worth showing. The NAME always leads and is never dropped: a row must say WHAT it is even when the detail is a title the user wrote, otherwise a newcomer cannot tell a command list from a script. The detail trails because these rows truncate from the right. An empty detail takes the bare-name form rather than rendering dangling brackets. public string GetCommandTitle(ICommandTextSource text) Parameters text ICommandTextSource Culture-bearing vocabulary the static words are taken from. Returns string The command title. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Run(SessionShell) Runs the command, delegating execution to the provided session shell. public IEnumerable<Action> Run(SessionShell sessionShell) Parameters sessionShell SessionShell Session shell that exposes the machining facade to commands. Returns IEnumerable<Action> Sequence of actions to be executed."
  },
  "api/Hi.SessionCommands.NcCodeCommand.html": {
    "href": "api/Hi.SessionCommands.NcCodeCommand.html",
    "title": "Class NcCodeCommand | HiAPI-C# 2025",
    "summary": "Class NcCodeCommand Namespace Hi.SessionCommands Assembly HiNc.dll Command for executing NC code directly. [CultureText(\"zh-Hant\", \"NC程式碼\")] [CultureText(\"zh-Hans\", \"NC代码\")] [CommandCatalog(CommandCategory.Program, Order = 1)] public class NcCodeCommand : ITitleCommand, ISessionCommand, IMakeXmlSource Inheritance object NcCodeCommand Implements ITitleCommand ISessionCommand IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NcCodeCommand() Ctor. public NcCodeCommand() NcCodeCommand(string) Initializes a new instance of the NcCodeCommand class with the specified NC text. public NcCodeCommand(string nc) Parameters nc string The NC code text. NcCodeCommand(XElement, string) Ctor. public NcCodeCommand(XElement src, string baseDirectory) Parameters src XElement XML baseDirectory string Base directory for resolving relative paths Fields ConstDisplayName The command's own name — the DisplayNameAttribute value, the localization key, AND the Title default, which is why GetCommandTitle(ICommandTextSource) can treat a Title equal to it as unset. public const string ConstDisplayName = \"NC Code\" Field Value string Properties NcText The NC code text content. public string NcText { get; set; } Property Value string Title Title. Alternative file name for the NC code file — it doubles as the in-memory NC program name handed to RunNc(string, string), so the default is a usable name rather than an empty string. public string Title { get; set; } Property Value string XName Name for XML IO. public static string XName { get; } Property Value string Methods GetCommandTitle(ICommandTextSource) Gets the title of the command — one row in a command list or a mission tree — composed from the caller's vocabulary: the command owns the composition and degradation rules, the caller owns the language. The shape is Name, or Name [detail] once there is a detail worth showing. The NAME always leads and is never dropped: a row must say WHAT it is even when the detail is a title the user wrote, otherwise a newcomer cannot tell a command list from a script. The detail trails because these rows truncate from the right. An empty detail takes the bare-name form rather than rendering dangling brackets. public string GetCommandTitle(ICommandTextSource text) Parameters text ICommandTextSource Culture-bearing vocabulary the static words are taken from. Returns string The command title. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Run(SessionShell) Runs the command, delegating execution to the provided session shell. public IEnumerable<Action> Run(SessionShell sessionShell) Parameters sessionShell SessionShell Session shell that exposes the machining facade to commands. Returns IEnumerable<Action> Sequence of actions to be executed."
  },
  "api/Hi.SessionCommands.NcFileCommand.html": {
    "href": "api/Hi.SessionCommands.NcFileCommand.html",
    "title": "Class NcFileCommand | HiAPI-C# 2025",
    "summary": "Class NcFileCommand Namespace Hi.SessionCommands Assembly HiNc.dll Command for executing an NC program file (Nc is the umbrella term: brand controller code, NX-CL or CSV). The runner is picked by NcKind — Auto (the default) detects by file extension: .cl/.cls/.clsf play as NX-CL, .csv as CSV, anything else as brand NC code. The GUI labels it “Program File”. [CultureText(\"zh-Hant\", \"程式檔案\")] [CultureText(\"zh-Hans\", \"程序文件\")] [CommandCatalog(CommandCategory.Program, Order = 0)] public class NcFileCommand : ITitleCommand, ISessionCommand, IMakeXmlSource Inheritance object NcFileCommand Implements ITitleCommand ISessionCommand IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NcFileCommand() Default constructor. public NcFileCommand() NcFileCommand(string) Initializes a new instance of the NcFileCommand class with the specified NC program file path. public NcFileCommand(string ncFile) Parameters ncFile string The NC program file path. NcFileCommand(XElement, string) Ctor. public NcFileCommand(XElement src, string baseDirectory) Parameters src XElement XML baseDirectory string Base directory for resolving relative paths Properties NcFile Path to the NC program file. public string NcFile { get; set; } Property Value string NcKind Which runner plays NcFile; Auto detects by extension. public NcKind NcKind { get; set; } Property Value NcKind XName Name for XML IO. public static string XName { get; } Property Value string Methods GetCommandTitle(ICommandTextSource) Gets the title of the command — one row in a command list or a mission tree — composed from the caller's vocabulary: the command owns the composition and degradation rules, the caller owns the language. The shape is Name, or Name [detail] once there is a detail worth showing. The NAME always leads and is never dropped: a row must say WHAT it is even when the detail is a title the user wrote, otherwise a newcomer cannot tell a command list from a script. The detail trails because these rows truncate from the right. An empty detail takes the bare-name form rather than rendering dangling brackets. public string GetCommandTitle(ICommandTextSource text) Parameters text ICommandTextSource Culture-bearing vocabulary the static words are taken from. Returns string The command title. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Run(SessionShell) Runs the command, delegating execution to the provided session shell. public IEnumerable<Action> Run(SessionShell sessionShell) Parameters sessionShell SessionShell Session shell that exposes the machining facade to commands. Returns IEnumerable<Action> Sequence of actions to be executed."
  },
  "api/Hi.SessionCommands.NcOptOptionCommand.html": {
    "href": "api/Hi.SessionCommands.NcOptOptionCommand.html",
    "title": "Class NcOptOptionCommand | HiAPI-C# 2025",
    "summary": "Class NcOptOptionCommand Namespace Hi.SessionCommands Assembly HiNc.dll Command for NC optimization options. [CultureText(\"zh-Hant\", \"NC優化設定\")] [CultureText(\"zh-Hans\", \"NC优化设定\")] [CommandCatalog(CommandCategory.Optimization, Order = 0)] public class NcOptOptionCommand : ITitleCommand, ISessionCommand, IMakeXmlSource Inheritance object NcOptOptionCommand Implements ITitleCommand ISessionCommand IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors NcOptOptionCommand() Ctor. public NcOptOptionCommand() NcOptOptionCommand(XElement, string, string, IProgress<IMessage>, object[]) Ctor. public NcOptOptionCommand(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress, object[] res) Parameters src XElement XML baseDirectory string Base directory for relative paths relFile string Relative file path progress IProgress<IMessage> Progress reporter for nested option XML. res object[] Additional resources Properties NcOptOption Gets or sets the NC optimization options. public NcOptOption NcOptOption { get; set; } Property Value NcOptOption XName Name for XML IO. public static string XName { get; } Property Value string Methods GetCommandTitle(ICommandTextSource) Gets the title of the command — one row in a command list or a mission tree — composed from the caller's vocabulary: the command owns the composition and degradation rules, the caller owns the language. The shape is Name, or Name [detail] once there is a detail worth showing. The NAME always leads and is never dropped: a row must say WHAT it is even when the detail is a title the user wrote, otherwise a newcomer cannot tell a command list from a script. The detail trails because these rows truncate from the right. An empty detail takes the bare-name form rather than rendering dangling brackets. public string GetCommandTitle(ICommandTextSource text) Parameters text ICommandTextSource Culture-bearing vocabulary the static words are taken from. Returns string The command title. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Run(SessionShell) Runs the command, delegating execution to the provided session shell. public IEnumerable<Action> Run(SessionShell sessionShell) Parameters sessionShell SessionShell Session shell that exposes the machining facade to commands. Returns IEnumerable<Action> Sequence of actions to be executed."
  },
  "api/Hi.SessionCommands.OptimizeToFilesCommand.html": {
    "href": "api/Hi.SessionCommands.OptimizeToFilesCommand.html",
    "title": "Class OptimizeToFilesCommand | HiAPI-C# 2025",
    "summary": "Class OptimizeToFilesCommand Namespace Hi.SessionCommands Assembly HiNc.dll Command to call OptimizeToFiles(string). [CultureText(\"zh-Hant\", \"優化NC至檔案\")] [CultureText(\"zh-Hans\", \"优化NC至文件\")] public class OptimizeToFilesCommand : ISessionCommand, IMakeXmlSource Inheritance object OptimizeToFilesCommand Implements ISessionCommand IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors OptimizeToFilesCommand() Default constructor. public OptimizeToFilesCommand() OptimizeToFilesCommand(XElement, string) Ctor. public OptimizeToFilesCommand(XElement src, string baseDirectory) Parameters src XElement XML baseDirectory string Base directory for resolving relative paths Properties RelFileTemplate Template for the relative file path. public string RelFileTemplate { get; set; } Property Value string XName Name for XML IO. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Run(SessionShell) Runs the command, delegating execution to the provided session shell. public IEnumerable<Action> Run(SessionShell sessionShell) Parameters sessionShell SessionShell Session shell that exposes the machining facade to commands. Returns IEnumerable<Action> Sequence of actions to be executed."
  },
  "api/Hi.SessionCommands.PauseOnFailureCommand.html": {
    "href": "api/Hi.SessionCommands.PauseOnFailureCommand.html",
    "title": "Class PauseOnFailureCommand | HiAPI-C# 2025",
    "summary": "Class PauseOnFailureCommand Namespace Hi.SessionCommands Assembly HiNc.dll Command that turns pause-on-failure on or off for the session. One of the single-setting successors of the legacy PreSettingCommand bundle. [CultureText(\"zh-Hant\", \"失敗時暫停\")] [CultureText(\"zh-Hans\", \"失败时暂停\")] [CommandCatalog(CommandCategory.Setup, Order = 3)] public class PauseOnFailureCommand : ITitleCommand, ISessionCommand, IMakeXmlSource Inheritance object PauseOnFailureCommand Implements ITitleCommand ISessionCommand IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors PauseOnFailureCommand() Ctor. public PauseOnFailureCommand() PauseOnFailureCommand(XElement, string) Ctor. public PauseOnFailureCommand(XElement src, string baseDirectory) Parameters src XElement XML baseDirectory string Base directory for resolving relative paths Properties Enable Whether the session pauses on a failure from this command on. [CultureText(\"zh-Hant\", \"啟用失敗時暫停\", Key = \"Enable Pause on Failure\")] [CultureText(\"zh-Hans\", \"启用失败时暂停\", Key = \"Enable Pause on Failure\")] public bool Enable { get; set; } Property Value bool XName Name for XML IO. public static string XName { get; } Property Value string Methods GetCommandTitle(ICommandTextSource) Gets the title of the command — one row in a command list or a mission tree — composed from the caller's vocabulary: the command owns the composition and degradation rules, the caller owns the language. The shape is Name, or Name [detail] once there is a detail worth showing. The NAME always leads and is never dropped: a row must say WHAT it is even when the detail is a title the user wrote, otherwise a newcomer cannot tell a command list from a script. The detail trails because these rows truncate from the right. An empty detail takes the bare-name form rather than rendering dangling brackets. public string GetCommandTitle(ICommandTextSource text) Parameters text ICommandTextSource Culture-bearing vocabulary the static words are taken from. Returns string The command title. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Run(SessionShell) Runs the command, delegating execution to the provided session shell. public IEnumerable<Action> Run(SessionShell sessionShell) Parameters sessionShell SessionShell Session shell that exposes the machining facade to commands. Returns IEnumerable<Action> Sequence of actions to be executed."
  },
  "api/Hi.SessionCommands.PhysicsCommand.html": {
    "href": "api/Hi.SessionCommands.PhysicsCommand.html",
    "title": "Class PhysicsCommand | HiAPI-C# 2025",
    "summary": "Class PhysicsCommand Namespace Hi.SessionCommands Assembly HiNc.dll Command that turns physics simulation on or off for the session. One of the single-setting successors of the legacy PreSettingCommand bundle. [CultureText(\"zh-Hant\", \"物理模擬\")] [CultureText(\"zh-Hans\", \"物理模拟\")] [CommandCatalog(CommandCategory.Setup, Order = 4)] public class PhysicsCommand : ITitleCommand, ISessionCommand, IMakeXmlSource Inheritance object PhysicsCommand Implements ITitleCommand ISessionCommand IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors PhysicsCommand() Ctor. public PhysicsCommand() PhysicsCommand(XElement, string) Ctor. public PhysicsCommand(XElement src, string baseDirectory) Parameters src XElement XML baseDirectory string Base directory for resolving relative paths Properties Enable Whether physics simulation is enabled from this command on. [CultureText(\"zh-Hant\", \"啟用物理模擬\", Key = \"Enable Physics\")] [CultureText(\"zh-Hans\", \"启用物理模拟\", Key = \"Enable Physics\")] public bool Enable { get; set; } Property Value bool XName Name for XML IO. public static string XName { get; } Property Value string Methods GetCommandTitle(ICommandTextSource) Gets the title of the command — one row in a command list or a mission tree — composed from the caller's vocabulary: the command owns the composition and degradation rules, the caller owns the language. The shape is Name, or Name [detail] once there is a detail worth showing. The NAME always leads and is never dropped: a row must say WHAT it is even when the detail is a title the user wrote, otherwise a newcomer cannot tell a command list from a script. The detail trails because these rows truncate from the right. An empty detail takes the bare-name form rather than rendering dangling brackets. public string GetCommandTitle(ICommandTextSource text) Parameters text ICommandTextSource Culture-bearing vocabulary the static words are taken from. Returns string The command title. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Run(SessionShell) Runs the command, delegating execution to the provided session shell. public IEnumerable<Action> Run(SessionShell sessionShell) Parameters sessionShell SessionShell Session shell that exposes the machining facade to commands. Returns IEnumerable<Action> Sequence of actions to be executed."
  },
  "api/Hi.SessionCommands.PostExecutionCommand.html": {
    "href": "api/Hi.SessionCommands.PostExecutionCommand.html",
    "title": "Class PostExecutionCommand | HiAPI-C# 2025",
    "summary": "Class PostExecutionCommand Namespace Hi.SessionCommands Assembly HiNc.dll Command for post-execution actions after NC command running. [CultureText(\"zh-Hant\", \"執行後處理\")] [CultureText(\"zh-Hans\", \"执行后处理\")] [CommandCatalog(CommandCategory.Output, Order = 0)] public class PostExecutionCommand : ITitleCommand, ISessionCommand, IMakeXmlSource Inheritance object PostExecutionCommand Implements ITitleCommand ISessionCommand IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors PostExecutionCommand() Ctor. public PostExecutionCommand() PostExecutionCommand(XElement, string, string, params object[]) Ctor. public PostExecutionCommand(XElement src, string baseDirectory, string relFile, params object[] res) Parameters src XElement XML baseDirectory string Base directory for relative paths relFile string Relative file path res object[] Additional resources Properties ClToNcFileTemplate Gets or sets the writeback output template; [NcName] is replaced by the source file name (extension kept). public string ClToNcFileTemplate { get; set; } Property Value string EnableConvertClToNcFiles Gets or sets whether to convert the session's play into NC files by writeback synthesis (ConvertClToNcFiles(string)). Converts EVERY NC program file the session played (grouped per source file) — meaningful after a CL play; an NC play would be re-serialized too. public bool EnableConvertClToNcFiles { get; set; } Property Value bool EnableGeomDiff Gets or sets whether to enable geometry difference detection. public bool EnableGeomDiff { get; set; } Property Value bool EnableOptimizeToFiles Gets or sets whether to enable optimization to files. public bool EnableOptimizeToFiles { get; set; } Property Value bool EnableWriteShotFiles Gets or sets whether to write shot files. public bool EnableWriteShotFiles { get; set; } Property Value bool EnableWriteStepFiles Gets or sets whether to write step files. public bool EnableWriteStepFiles { get; set; } Property Value bool GeomDiffDetectRadius_mm Gets or sets the geometry difference detection radius in millimeters. public double GeomDiffDetectRadius_mm { get; set; } Property Value double OptimizationFileTemplate Gets or sets the optimization file template path. public string OptimizationFileTemplate { get; set; } Property Value string ShotFileTemplate Gets or sets the shot file template path. public string ShotFileTemplate { get; set; } Property Value string ShotFileTimeResolution_ms Gets or sets the time resolution for shot files in milliseconds. public double ShotFileTimeResolution_ms { get; set; } Property Value double StepFileTemplate Gets or sets the step file template path. public string StepFileTemplate { get; set; } Property Value string XName Name for XML IO. public static string XName { get; } Property Value string Methods GetCommandTitle(ICommandTextSource) Gets the title of the command — one row in a command list or a mission tree — composed from the caller's vocabulary: the command owns the composition and degradation rules, the caller owns the language. The shape is Name, or Name [detail] once there is a detail worth showing. The NAME always leads and is never dropped: a row must say WHAT it is even when the detail is a title the user wrote, otherwise a newcomer cannot tell a command list from a script. The detail trails because these rows truncate from the right. An empty detail takes the bare-name form rather than rendering dangling brackets. public string GetCommandTitle(ICommandTextSource text) Parameters text ICommandTextSource Culture-bearing vocabulary the static words are taken from. Returns string The command title. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Run(SessionShell) Runs the command, delegating execution to the provided session shell. public IEnumerable<Action> Run(SessionShell sessionShell) Parameters sessionShell SessionShell Session shell that exposes the machining facade to commands. Returns IEnumerable<Action> Sequence of actions to be executed."
  },
  "api/Hi.SessionCommands.PreSettingCommand.html": {
    "href": "api/Hi.SessionCommands.PreSettingCommand.html",
    "title": "Class PreSettingCommand | HiAPI-C# 2025",
    "summary": "Class PreSettingCommand Namespace Hi.SessionCommands Assembly HiNc.dll Legacy bundle of pre-settings applied before NC command running, superseded by the single-setting commands (machining resolution, motion resolution, collision detection, pause on failure, physics). Loading a project expands a saved instance into those commands via ExpandToEntries(bool); saving never writes the bundle back. The class stays functional for API callers that construct it directly. [CultureText(\"zh-Hant\", \"一般設定\")] [CultureText(\"zh-Hans\", \"一般设定\")] public class PreSettingCommand : ITitleCommand, ISessionCommand, IMakeXmlSource Inheritance object PreSettingCommand Implements ITitleCommand ISessionCommand IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors PreSettingCommand() Ctor. public PreSettingCommand() PreSettingCommand(XElement, string, string, IProgress<IMessage>, object[]) Ctor. public PreSettingCommand(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress, object[] res) Parameters src XElement XML baseDirectory string Base directory for relative paths relFile string Relative file path progress IProgress<IMessage> Progress reporter for nested preset XML. res object[] Additional resources Properties EnableCollisionDetection Gets or sets whether collision detection is enabled. public bool EnableCollisionDetection { get; set; } Property Value bool EnablePauseOnFailure Gets or sets whether to pause on failure. public bool EnablePauseOnFailure { get; set; } Property Value bool EnablePhysics Gets or sets whether physics is enabled. public bool EnablePhysics { get; set; } Property Value bool EnableReadMeshedGeom Gets or sets whether to enable reading meshed geometry. public bool EnableReadMeshedGeom { get; set; } Property Value bool MachiningMotionResolution Gets or sets the machining motion resolution. public IMachiningMotionResolution MachiningMotionResolution { get; set; } Property Value IMachiningMotionResolution MachiningResolution_mm Gets or sets the machining resolution in millimeters. public double MachiningResolution_mm { get; set; } Property Value double MeshedGeomFile Gets or sets the meshed geometry file path. public string MeshedGeomFile { get; set; } Property Value string XName Name for XML IO. public static string XName { get; } Property Value string Methods ExpandToEntries(bool) Expands this bundle into the split single-setting commands, in the order the bundle applied them. isEnabled — the enable state of the bundle's own list entry — is consumed into every split entry; the meshed-geometry read additionally keeps its own EnableReadMeshedGeom flag (its entry is emitted only when the read is enabled or a file is set, as a RecordMeshedGeomCommand in Read mode). public List<EnablingWrapper> ExpandToEntries(bool isEnabled) Parameters isEnabled bool Enable state of the bundle's list entry. Returns List<EnablingWrapper> The split entries replacing the bundle. GetCommandTitle(ICommandTextSource) Gets the title of the command — one row in a command list or a mission tree — composed from the caller's vocabulary: the command owns the composition and degradation rules, the caller owns the language. The shape is Name, or Name [detail] once there is a detail worth showing. The NAME always leads and is never dropped: a row must say WHAT it is even when the detail is a title the user wrote, otherwise a newcomer cannot tell a command list from a script. The detail trails because these rows truncate from the right. An empty detail takes the bare-name form rather than rendering dangling brackets. public string GetCommandTitle(ICommandTextSource text) Parameters text ICommandTextSource Culture-bearing vocabulary the static words are taken from. Returns string The command title. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Run(SessionShell) Runs the command, delegating execution to the provided session shell. public IEnumerable<Action> Run(SessionShell sessionShell) Parameters sessionShell SessionShell Session shell that exposes the machining facade to commands. Returns IEnumerable<Action> Sequence of actions to be executed."
  },
  "api/Hi.SessionCommands.RecordMeshedGeomActionEnum.html": {
    "href": "api/Hi.SessionCommands.RecordMeshedGeomActionEnum.html",
    "title": "Enum RecordMeshedGeomActionEnum | HiAPI-C# 2025",
    "summary": "Enum RecordMeshedGeomActionEnum Namespace Hi.SessionCommands Assembly HiNc.dll Action of the RecordMeshedGeomCommand. public enum RecordMeshedGeomActionEnum Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields [CultureText(\"zh-Hant\", \"無操作\")] [CultureText(\"zh-Hans\", \"无操作\")] NoAction = 0 No action. [CultureText(\"zh-Hant\", \"讀取\")] [CultureText(\"zh-Hans\", \"读取\")] Read = 1 Read meshed geometry from file. [CultureText(\"zh-Hant\", \"首次讀取，否則寫入\")] [CultureText(\"zh-Hans\", \"首次读取，否则写入\")] ReadOnFirstOrWrite = 3 If file existed and no motion has ran before, read the meshed geometry; otherwise, write the current geometry into file. [CultureText(\"zh-Hant\", \"寫入\")] [CultureText(\"zh-Hans\", \"写入\")] Write = 2 Write meshed geometry to file."
  },
  "api/Hi.SessionCommands.RecordMeshedGeomCommand.html": {
    "href": "api/Hi.SessionCommands.RecordMeshedGeomCommand.html",
    "title": "Class RecordMeshedGeomCommand | HiAPI-C# 2025",
    "summary": "Class RecordMeshedGeomCommand Namespace Hi.SessionCommands Assembly HiNc.dll Command for recording meshed geometry to/from file. [CultureText(\"zh-Hant\", \"記錄網格幾何\")] [CultureText(\"zh-Hans\", \"记录网格几何\")] [CommandCatalog(CommandCategory.Output, Order = 1, Aliases = new string[] { \"Read\", \"Write\" })] public class RecordMeshedGeomCommand : ITitleCommand, ISessionCommand, IMakeXmlSource Inheritance object RecordMeshedGeomCommand Implements ITitleCommand ISessionCommand IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors RecordMeshedGeomCommand() Default constructor. public RecordMeshedGeomCommand() RecordMeshedGeomCommand(XElement, string) Ctor. public RecordMeshedGeomCommand(XElement src, string baseDirectory) Parameters src XElement XML baseDirectory string Base directory for resolving relative paths Properties MainActionEnum Main action to perform (read, write, or conditional). public RecordMeshedGeomActionEnum MainActionEnum { get; set; } Property Value RecordMeshedGeomActionEnum RelFile Relative file path. Defaults under Cache/: a recorded mesh is a rebuildable by-product of a run, not a project asset, so it belongs beside the other cached artifacts rather than at the project root. The write path creates the directory when it is missing. public string RelFile { get; set; } Property Value string XName Name for XML IO. public static string XName { get; } Property Value string Methods GetCommandTitle(ICommandTextSource) Gets the title of the command — one row in a command list or a mission tree — composed from the caller's vocabulary: the command owns the composition and degradation rules, the caller owns the language. The shape is Name, or Name [detail] once there is a detail worth showing. The NAME always leads and is never dropped: a row must say WHAT it is even when the detail is a title the user wrote, otherwise a newcomer cannot tell a command list from a script. The detail trails because these rows truncate from the right. An empty detail takes the bare-name form rather than rendering dangling brackets. public string GetCommandTitle(ICommandTextSource text) Parameters text ICommandTextSource Culture-bearing vocabulary the static words are taken from. Returns string The command title. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Run(SessionShell) Runs the command, delegating execution to the provided session shell. public IEnumerable<Action> Run(SessionShell sessionShell) Parameters sessionShell SessionShell Session shell that exposes the machining facade to commands. Returns IEnumerable<Action> Sequence of actions to be executed."
  },
  "api/Hi.SessionCommands.ScriptCommand.html": {
    "href": "api/Hi.SessionCommands.ScriptCommand.html",
    "title": "Class ScriptCommand | HiAPI-C# 2025",
    "summary": "Class ScriptCommand Namespace Hi.SessionCommands Assembly HiNc.dll Command for executing C# scripts in the milling process. [CultureText(\"zh-Hant\", \"腳本\")] [CultureText(\"zh-Hans\", \"脚本\")] [CommandCatalog(CommandCategory.Program, Order = 2)] public class ScriptCommand : ITitleCommand, ISessionCommand, IMakeXmlSource, IGetSelectionName Inheritance object ScriptCommand Implements ITitleCommand ISessionCommand IMakeXmlSource IGetSelectionName Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ScriptCommand() Ctor. public ScriptCommand() ScriptCommand(XElement, string) Ctor. public ScriptCommand(XElement src, string baseDirectory) Parameters src XElement XML baseDirectory string Base directory for resolving relative paths Properties ExecutionTemplate Gets the execution template command. public static ScriptCommand ExecutionTemplate { get; } Property Value ScriptCommand OptimizationConfigurationTemplate Gets the optimization configuration template command. public static ScriptCommand OptimizationConfigurationTemplate { get; } Property Value ScriptCommand PreSettingTemplate Gets the pre-setting template command. public static ScriptCommand PreSettingTemplate { get; } Property Value ScriptCommand ScriptText The script text content. public string ScriptText { get; set; } Property Value string ScriptTitle Title or name of the script. public string ScriptTitle { get; set; } Property Value string XName Name for XML IO. public static string XName { get; } Property Value string Methods GenTemplateCommand() Generates a template script command with default values. public static ScriptCommand GenTemplateCommand() Returns ScriptCommand A new ScriptCommand with template values GetCommandTitle(ICommandTextSource) Gets the title of the command — one row in a command list or a mission tree — composed from the caller's vocabulary: the command owns the composition and degradation rules, the caller owns the language. The shape is Name, or Name [detail] once there is a detail worth showing. The NAME always leads and is never dropped: a row must say WHAT it is even when the detail is a title the user wrote, otherwise a newcomer cannot tell a command list from a script. The detail trails because these rows truncate from the right. An empty detail takes the bare-name form rather than rendering dangling brackets. public string GetCommandTitle(ICommandTextSource text) Parameters text ICommandTextSource Culture-bearing vocabulary the static words are taken from. Returns string The command title. GetSelectionName() Gets a name that can be used for selection in UI or other contexts. public string GetSelectionName() Returns string The selection name for this object MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer (and its legacy alias) with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Run(SessionShell) Runs the command, delegating execution to the provided session shell. public IEnumerable<Action> Run(SessionShell sessionShell) Parameters sessionShell SessionShell Session shell that exposes the machining facade to commands. Returns IEnumerable<Action> Sequence of actions to be executed. Run(SessionShell, string) Runs a specified script with the given session shell. public IEnumerable<Action> Run(SessionShell sessionShell, string scriptText) Parameters sessionShell SessionShell The session shell that scripts delegate to. scriptText string The script text to run Returns IEnumerable<Action> Enumerable of actions to perform"
  },
  "api/Hi.SessionCommands.WriteShotFilesCommand.html": {
    "href": "api/Hi.SessionCommands.WriteShotFilesCommand.html",
    "title": "Class WriteShotFilesCommand | HiAPI-C# 2025",
    "summary": "Class WriteShotFilesCommand Namespace Hi.SessionCommands Assembly HiNc.dll Command to call WriteShotFiles(string, double). [CultureText(\"zh-Hant\", \"輸出時間序資訊至檔案\")] [CultureText(\"zh-Hans\", \"输出时间序信息至文件\")] public class WriteShotFilesCommand : ISessionCommand, IMakeXmlSource Inheritance object WriteShotFilesCommand Implements ISessionCommand IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors WriteShotFilesCommand() Default constructor. public WriteShotFilesCommand() WriteShotFilesCommand(XElement, string) Ctor. public WriteShotFilesCommand(XElement src, string baseDirectory) Parameters src XElement XML baseDirectory string Base directory for resolving relative paths Properties RelFileTemplate Template for the relative file path where shot files will be written. public string RelFileTemplate { get; set; } Property Value string TimeResolution_ms Time resolution in milliseconds for shot data sampling. public double TimeResolution_ms { get; set; } Property Value double XName Name for XML IO. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Run(SessionShell) Runs the command, delegating execution to the provided session shell. public IEnumerable<Action> Run(SessionShell sessionShell) Parameters sessionShell SessionShell Session shell that exposes the machining facade to commands. Returns IEnumerable<Action> Sequence of actions to be executed."
  },
  "api/Hi.SessionCommands.WriteStepFilesCommand.html": {
    "href": "api/Hi.SessionCommands.WriteStepFilesCommand.html",
    "title": "Class WriteStepFilesCommand | HiAPI-C# 2025",
    "summary": "Class WriteStepFilesCommand Namespace Hi.SessionCommands Assembly HiNc.dll Command to call WriteStepFiles(string). [CultureText(\"zh-Hant\", \"輸出每步資訊至檔案\")] [CultureText(\"zh-Hans\", \"输出每步信息至文件\")] public class WriteStepFilesCommand : ISessionCommand, IMakeXmlSource Inheritance object WriteStepFilesCommand Implements ISessionCommand IMakeXmlSource Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors WriteStepFilesCommand() Default constructor. public WriteStepFilesCommand() WriteStepFilesCommand(XElement, string) Ctor. public WriteStepFilesCommand(XElement src, string baseDirectory) Parameters src XElement XML baseDirectory string Base directory for resolving relative paths Properties RelFileTemplate Template for the relative file path where step files will be written. public string RelFileTemplate { get; set; } Property Value string XName Name for XML IO. public static string XName { get; } Property Value string Methods MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory (or Default when factory is null). Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory Run(SessionShell) Runs the command, delegating execution to the provided session shell. public IEnumerable<Action> Run(SessionShell sessionShell) Parameters sessionShell SessionShell Session shell that exposes the machining facade to commands. Returns IEnumerable<Action> Sequence of actions to be executed."
  },
  "api/Hi.SessionCommands.html": {
    "href": "api/Hi.SessionCommands.html",
    "title": "Namespace Hi.SessionCommands | HiAPI-C# 2025",
    "summary": "Namespace Hi.SessionCommands Classes CollisionDetectionCommand Command that turns collision detection on or off for the session. One of the single-setting successors of the legacy PreSettingCommand bundle. CommandCatalogAttribute Marks an ISessionCommand as user-addable: GUIs build their “Add Command” catalog from the commands carrying this attribute, grouped by Category. A command WITHOUT this attribute stays loadable from project files (its Reg registration is unaffected) but is not offered for creation. CommandFieldAttribute Marks a session-command property as a directly editable scalar field, so generic editors (e.g. the web UI's fallback command panel) can render and update it without a hand-written per-command editor. Supported property types: bool, int, double and string. EnablingWrapper Wrapper for session commands that provides enable/disable functionality. ExportMeshedGeomToStlCommand Command to call ExportMeshedGeomToStl(string, double). GeomDiffCommand Command for calculating geometric differences between workpieces. Lang Language package class for command flow. ListCommand A command that contains and executes a list of other commands. MachiningMotionResolutionCommand Command for setting machining motion resolution for the milling process. MachiningResolutionCommand Command that sets the session's machining resolution — the meshing resolution of material removal. One of the single-setting successors of the legacy PreSettingCommand bundle. NcCodeCommand Command for executing NC code directly. NcFileCommand Command for executing an NC program file (Nc is the umbrella term: brand controller code, NX-CL or CSV). The runner is picked by NcKind — Auto (the default) detects by file extension: .cl/.cls/.clsf play as NX-CL, .csv as CSV, anything else as brand NC code. The GUI labels it “Program File”. NcOptOptionCommand Command for NC optimization options. OptimizeToFilesCommand Command to call OptimizeToFiles(string). PauseOnFailureCommand Command that turns pause-on-failure on or off for the session. One of the single-setting successors of the legacy PreSettingCommand bundle. PhysicsCommand Command that turns physics simulation on or off for the session. One of the single-setting successors of the legacy PreSettingCommand bundle. PostExecutionCommand Command for post-execution actions after NC command running. PreSettingCommand Legacy bundle of pre-settings applied before NC command running, superseded by the single-setting commands (machining resolution, motion resolution, collision detection, pause on failure, physics). Loading a project expands a saved instance into those commands via ExpandToEntries(bool); saving never writes the bundle back. The class stays functional for API callers that construct it directly. RecordMeshedGeomCommand Command for recording meshed geometry to/from file. ScriptCommand Command for executing C# scripts in the milling process. WriteShotFilesCommand Command to call WriteShotFiles(string, double). WriteStepFilesCommand Command to call WriteStepFiles(string). Interfaces ISessionCommand Interface for commands that can be executed in a machining session. ITitleCommand ISessionCommand with title. Enums CommandCategory Category of a session command in user-facing command catalogs (the GUI “Add Command” listings). Declaration order is the display order. RecordMeshedGeomActionEnum Action of the RecordMeshedGeomCommand."
  },
  "api/Hi.SessionShellUtils.ISessionShell.html": {
    "href": "api/Hi.SessionShellUtils.ISessionShell.html",
    "title": "Interface ISessionShell | HiAPI-C# 2025",
    "summary": "Interface ISessionShell Namespace Hi.SessionShellUtils Assembly HiGeom.dll Interface for C# scripting API functionality. public interface ISessionShell Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties ScriptOptions ScriptOptions. ScriptOptions ScriptOptions { get; set; } Property Value ScriptOptions"
  },
  "api/Hi.SessionShellUtils.JsAceAttribute.html": {
    "href": "api/Hi.SessionShellUtils.JsAceAttribute.html",
    "title": "Class JsAceAttribute | HiAPI-C# 2025",
    "summary": "Class JsAceAttribute Namespace Hi.SessionShellUtils Assembly HiGeom.dll Attribute for JavaScript Ace editor integration. public class JsAceAttribute : Attribute Inheritance object Attribute JsAceAttribute Inherited Members Attribute.Equals(object) Attribute.GetCustomAttribute(Assembly, Type) Attribute.GetCustomAttribute(Assembly, Type, bool) Attribute.GetCustomAttribute(MemberInfo, Type) Attribute.GetCustomAttribute(MemberInfo, Type, bool) Attribute.GetCustomAttribute(Module, Type) Attribute.GetCustomAttribute(Module, Type, bool) Attribute.GetCustomAttribute(ParameterInfo, Type) Attribute.GetCustomAttribute(ParameterInfo, Type, bool) Attribute.GetCustomAttributes(Assembly) Attribute.GetCustomAttributes(Assembly, bool) Attribute.GetCustomAttributes(Assembly, Type) Attribute.GetCustomAttributes(Assembly, Type, bool) Attribute.GetCustomAttributes(MemberInfo) Attribute.GetCustomAttributes(MemberInfo, bool) Attribute.GetCustomAttributes(MemberInfo, Type) Attribute.GetCustomAttributes(MemberInfo, Type, bool) Attribute.GetCustomAttributes(Module) Attribute.GetCustomAttributes(Module, bool) Attribute.GetCustomAttributes(Module, Type) Attribute.GetCustomAttributes(Module, Type, bool) Attribute.GetCustomAttributes(ParameterInfo) Attribute.GetCustomAttributes(ParameterInfo, bool) Attribute.GetCustomAttributes(ParameterInfo, Type) Attribute.GetCustomAttributes(ParameterInfo, Type, bool) Attribute.GetHashCode() Attribute.IsDefaultAttribute() Attribute.IsDefined(Assembly, Type) Attribute.IsDefined(Assembly, Type, bool) Attribute.IsDefined(MemberInfo, Type) Attribute.IsDefined(MemberInfo, Type, bool) Attribute.IsDefined(Module, Type) Attribute.IsDefined(Module, Type, bool) Attribute.IsDefined(ParameterInfo, Type) Attribute.IsDefined(ParameterInfo, Type, bool) Attribute.Match(object) Attribute.TypeId object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks Do not add new usages. Retained only so the legacy HiNcRcl (Blazor) Ace editor completion pipeline keeps working until that app is retired: SessionShell.JsAceCompletionProfileJsonArray scans [JsAce] members by reflection and CommonRcl.AceEditor feeds the resulting JSON into Ace's completer list. New code should rely on Roslyn CompletionService served over POST /api/script/completions and consumed by CodeMirror 6 on the HiNC-2025-webservice Quasar frontend. XML <summary> comments become the single source of truth for tooltip content, so no duplicated attribute metadata is needed. Deprecation lifecycle: Now — discouraged for new code (this remark); existing call sites in HiNcRcl / SessionShell / MachiningStep keep building without warnings. When HiNcRcl retires — this attribute will be marked [Obsolete], surfacing a compiler warning on every remaining call site so they can be cleaned up. After all call sites are gone — this file (and SessionShell.JsAceCompletionProfileJsonArray) will be deleted entirely. Constructors JsAceAttribute() Initializes a new instance of the JsAceAttribute class. public JsAceAttribute() JsAceAttribute(string) Initializes a new instance of the JsAceAttribute class with a specified snippet. public JsAceAttribute(string snippet) Parameters snippet string The code snippet for the editor JsAceAttribute(string, string) Initializes a new instance of the JsAceAttribute class with a specified snippet and documentation. public JsAceAttribute(string snippet, string docHtml) Parameters snippet string The code snippet for the editor docHtml string The HTML documentation content Properties ClassExt Gets or sets the class extension. public string ClassExt { get; set; } Property Value string DocContentHtml Gets or sets the HTML documentation content. public string DocContentHtml { get; set; } Property Value string Snippet Gets or sets the code snippet for the editor. public string Snippet { get; set; } Property Value string"
  },
  "api/Hi.SessionShellUtils.html": {
    "href": "api/Hi.SessionShellUtils.html",
    "title": "Namespace Hi.SessionShellUtils | HiAPI-C# 2025",
    "summary": "Namespace Hi.SessionShellUtils Classes JsAceAttribute Attribute for JavaScript Ace editor integration. Interfaces ISessionShell Interface for C# scripting API functionality."
  },
  "api/Hi.SqliteUtils.SqliteIdentityRole.html": {
    "href": "api/Hi.SqliteUtils.SqliteIdentityRole.html",
    "title": "Class SqliteIdentityRole | HiAPI-C# 2025",
    "summary": "Class SqliteIdentityRole Namespace Hi.SqliteUtils Assembly HiNc.dll Base class for SQLite-based identity roles. public class SqliteIdentityRole Inheritance object SqliteIdentityRole Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SqliteIdentityRole() Initializes a new instance of the SqliteIdentityRole class. public SqliteIdentityRole() SqliteIdentityRole(string) Initializes a new instance of the SqliteIdentityRole class with the specified role name. public SqliteIdentityRole(string roleName) Parameters roleName string The role name. Properties ConcurrencyStamp Gets or sets the concurrency stamp. public virtual string ConcurrencyStamp { get; set; } Property Value string Id Gets or sets the role ID. public virtual string Id { get; set; } Property Value string Name Gets or sets the role name. public virtual string Name { get; set; } Property Value string NormalizedName Gets or sets the normalized role name. public virtual string NormalizedName { get; set; } Property Value string"
  },
  "api/Hi.SqliteUtils.SqliteIdentityStorage.RoleRow.html": {
    "href": "api/Hi.SqliteUtils.SqliteIdentityStorage.RoleRow.html",
    "title": "Class SqliteIdentityStorage.RoleRow | HiAPI-C# 2025",
    "summary": "Class SqliteIdentityStorage.RoleRow Namespace Hi.SqliteUtils Assembly HiNc.dll Represents a role row in the database. public class SqliteIdentityStorage.RoleRow Inheritance object SqliteIdentityStorage.RoleRow Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties ConcurrencyStamp Gets or sets the concurrency stamp. public string ConcurrencyStamp { get; set; } Property Value string Id Gets or sets the role ID. public string Id { get; set; } Property Value string Name Gets or sets the role name. public string Name { get; set; } Property Value string NormalizedName Gets or sets the normalized role name. public string NormalizedName { get; set; } Property Value string Methods ToRole<TRole>() Converts this row to a role object. public TRole ToRole<TRole>() where TRole : SqliteIdentityRole, new() Returns TRole A new role instance. Type Parameters TRole The type of role to create."
  },
  "api/Hi.SqliteUtils.SqliteIdentityStorage.UserRow.html": {
    "href": "api/Hi.SqliteUtils.SqliteIdentityStorage.UserRow.html",
    "title": "Class SqliteIdentityStorage.UserRow | HiAPI-C# 2025",
    "summary": "Class SqliteIdentityStorage.UserRow Namespace Hi.SqliteUtils Assembly HiNc.dll Represents a user row in the database. public class SqliteIdentityStorage.UserRow Inheritance object SqliteIdentityStorage.UserRow Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties AccessFailedCount Gets or sets the access failed count. public int AccessFailedCount { get; set; } Property Value int ConcurrencyStamp Gets or sets the concurrency stamp. public string ConcurrencyStamp { get; set; } Property Value string CustomData Gets or sets custom data as a serialized string. public string CustomData { get; set; } Property Value string Email Gets or sets the email address. public string Email { get; set; } Property Value string EmailConfirmed Gets or sets whether the email is confirmed (1 for true, 0 for false). public int EmailConfirmed { get; set; } Property Value int Id Gets or sets the user ID. public string Id { get; set; } Property Value string InitialPassword Gets or sets the initial password. public string InitialPassword { get; set; } Property Value string LockoutEnabled Gets or sets whether lockout is enabled (1 for true, 0 for false). public int LockoutEnabled { get; set; } Property Value int LockoutEnd Gets or sets the lockout end date/time as a string. public string LockoutEnd { get; set; } Property Value string NormalizedEmail Gets or sets the normalized email address. public string NormalizedEmail { get; set; } Property Value string NormalizedUserName Gets or sets the normalized user name. public string NormalizedUserName { get; set; } Property Value string PasswordHash Gets or sets the password hash. public string PasswordHash { get; set; } Property Value string PhoneNumber Gets or sets the phone number. public string PhoneNumber { get; set; } Property Value string PhoneNumberConfirmed Gets or sets whether the phone number is confirmed (1 for true, 0 for false). public int PhoneNumberConfirmed { get; set; } Property Value int SecurityStamp Gets or sets the security stamp. public string SecurityStamp { get; set; } Property Value string TwoFactorEnabled Gets or sets whether two-factor authentication is enabled (1 for true, 0 for false). public int TwoFactorEnabled { get; set; } Property Value int UserName Gets or sets the user name. public string UserName { get; set; } Property Value string Methods ToUser<TUser>() Converts this row to a user object. public TUser ToUser<TUser>() where TUser : SqliteIdentityUser, new() Returns TUser A new user instance. Type Parameters TUser The type of user to create."
  },
  "api/Hi.SqliteUtils.SqliteIdentityStorage.html": {
    "href": "api/Hi.SqliteUtils.SqliteIdentityStorage.html",
    "title": "Class SqliteIdentityStorage | HiAPI-C# 2025",
    "summary": "Class SqliteIdentityStorage Namespace Hi.SqliteUtils Assembly HiNc.dll SQLite-based storage for ASP.NET Core Identity. public class SqliteIdentityStorage : IDisposable Inheritance object SqliteIdentityStorage Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SqliteIdentityStorage(string, ILogger) Initializes a new instance of the SqliteIdentityStorage class. public SqliteIdentityStorage(string databasePath = null, ILogger logger = null) Parameters databasePath string The path to the SQLite database file. logger ILogger Optional logger instance. Properties DatabasePath Gets the database file path. public string DatabasePath { get; } Property Value string Default Gets or sets the default SQLite identity storage instance. public static SqliteIdentityStorage Default { get; set; } Property Value SqliteIdentityStorage IsDefaultInit Gets a value indicating whether the default storage has been initialized. public static bool IsDefaultInit { get; } Property Value bool Methods AddToRoleAsync(string, string, CancellationToken) Adds a user to a role asynchronously. public Task AddToRoleAsync(string userId, string normalizedRoleName, CancellationToken cancellationToken) Parameters userId string The user ID. normalizedRoleName string The normalized role name. cancellationToken CancellationToken The cancellation token. Returns Task ClearAllData() Clears all identity data (users, roles, and user-role associations). public void ClearAllData() CreateRoleAsync<TRole>(TRole, CancellationToken) Creates a new role asynchronously. public Task<IdentityResult> CreateRoleAsync<TRole>(TRole role, CancellationToken cancellationToken) where TRole : SqliteIdentityRole Parameters role TRole The role to create. cancellationToken CancellationToken The cancellation token. Returns Task<IdentityResult> The result of the operation. Type Parameters TRole The type of role to create. CreateUserAsync<TUser>(TUser, CancellationToken) Creates a new user asynchronously. public Task<IdentityResult> CreateUserAsync<TUser>(TUser user, CancellationToken cancellationToken) where TUser : SqliteIdentityUser Parameters user TUser The user to create. cancellationToken CancellationToken The cancellation token. Returns Task<IdentityResult> The result of the operation. Type Parameters TUser The type of user to create. DeleteRoleAsync<TRole>(TRole, CancellationToken) Deletes a role asynchronously. public Task<IdentityResult> DeleteRoleAsync<TRole>(TRole role, CancellationToken cancellationToken) where TRole : SqliteIdentityRole Parameters role TRole The role to delete. cancellationToken CancellationToken The cancellation token. Returns Task<IdentityResult> The result of the operation. Type Parameters TRole The type of role to delete. DeleteUserAsync<TUser>(TUser, CancellationToken) Deletes a user asynchronously. public Task<IdentityResult> DeleteUserAsync<TUser>(TUser user, CancellationToken cancellationToken) where TUser : SqliteIdentityUser Parameters user TUser The user to delete. cancellationToken CancellationToken The cancellation token. Returns Task<IdentityResult> The result of the operation. Type Parameters TUser The type of user to delete. Dispose() Releases all resources used by the SqliteIdentityStorage. public void Dispose() Dispose(bool) Releases the unmanaged resources used by the SqliteIdentityStorage and optionally releases the managed resources. protected virtual void Dispose(bool disposing) Parameters disposing bool True to release both managed and unmanaged resources; false to release only unmanaged resources. FindRoleByIdAsync<TRole>(string, CancellationToken) Finds a role by its ID asynchronously. public Task<TRole> FindRoleByIdAsync<TRole>(string roleId, CancellationToken cancellationToken) where TRole : SqliteIdentityRole, new() Parameters roleId string The role ID. cancellationToken CancellationToken The cancellation token. Returns Task<TRole> The role if found, otherwise null. Type Parameters TRole The type of role to find. FindRoleByNameAsync<TRole>(string, CancellationToken) Finds a role by its normalized name asynchronously. public Task<TRole> FindRoleByNameAsync<TRole>(string normalizedName, CancellationToken cancellationToken) where TRole : SqliteIdentityRole, new() Parameters normalizedName string The normalized role name. cancellationToken CancellationToken The cancellation token. Returns Task<TRole> The role if found, otherwise null. Type Parameters TRole The type of role to find. FindUserByEmailAsync<TUser>(string, CancellationToken) Finds a user by their normalized email asynchronously. public Task<TUser> FindUserByEmailAsync<TUser>(string normalizedEmail, CancellationToken cancellationToken) where TUser : SqliteIdentityUser, new() Parameters normalizedEmail string The normalized email address. cancellationToken CancellationToken The cancellation token. Returns Task<TUser> The user if found, otherwise null. Type Parameters TUser The type of user to find. FindUserByIdAsync<TUser>(string, CancellationToken) Finds a user by their ID asynchronously. public Task<TUser> FindUserByIdAsync<TUser>(string userId, CancellationToken cancellationToken) where TUser : SqliteIdentityUser, new() Parameters userId string The user ID. cancellationToken CancellationToken The cancellation token. Returns Task<TUser> The user if found, otherwise null. Type Parameters TUser The type of user to find. FindUserByNameAsync<TUser>(string, CancellationToken) Finds a user by their normalized user name asynchronously. public Task<TUser> FindUserByNameAsync<TUser>(string normalizedUserName, CancellationToken cancellationToken) where TUser : SqliteIdentityUser, new() Parameters normalizedUserName string The normalized user name. cancellationToken CancellationToken The cancellation token. Returns Task<TUser> The user if found, otherwise null. Type Parameters TUser The type of user to find. GetRolesAsync(string, CancellationToken) Gets the roles for a user asynchronously. public Task<IList<string>> GetRolesAsync(string userId, CancellationToken cancellationToken) Parameters userId string The user ID. cancellationToken CancellationToken The cancellation token. Returns Task<IList<string>> A list of role names. GetRoles<TRole>() Gets all roles as a queryable collection. public IQueryable<TRole> GetRoles<TRole>() where TRole : SqliteIdentityRole, new() Returns IQueryable<TRole> A queryable collection of roles. Type Parameters TRole The type of roles to retrieve. GetUsersInRoleAsync<TUser>(string, CancellationToken) Gets all users in a role asynchronously. public Task<IList<TUser>> GetUsersInRoleAsync<TUser>(string normalizedRoleName, CancellationToken cancellationToken) where TUser : SqliteIdentityUser, new() Parameters normalizedRoleName string The normalized role name. cancellationToken CancellationToken The cancellation token. Returns Task<IList<TUser>> A list of users in the role. Type Parameters TUser The type of users to retrieve. GetUsers<TUser>() Gets all users as a queryable collection. public IQueryable<TUser> GetUsers<TUser>() where TUser : SqliteIdentityUser, new() Returns IQueryable<TUser> A queryable collection of users. Type Parameters TUser The type of users to retrieve. IsInRoleAsync(string, string, CancellationToken) Checks if a user is in a role asynchronously. public Task<bool> IsInRoleAsync(string userId, string normalizedRoleName, CancellationToken cancellationToken) Parameters userId string The user ID. normalizedRoleName string The normalized role name. cancellationToken CancellationToken The cancellation token. Returns Task<bool> True if the user is in the role, otherwise false. RemoveFromRoleAsync(string, string, CancellationToken) Removes a user from a role asynchronously. public Task RemoveFromRoleAsync(string userId, string normalizedRoleName, CancellationToken cancellationToken) Parameters userId string The user ID. normalizedRoleName string The normalized role name. cancellationToken CancellationToken The cancellation token. Returns Task UpdateRoleAsync<TRole>(TRole, CancellationToken) Updates an existing role asynchronously. public Task<IdentityResult> UpdateRoleAsync<TRole>(TRole role, CancellationToken cancellationToken) where TRole : SqliteIdentityRole Parameters role TRole The role to update. cancellationToken CancellationToken The cancellation token. Returns Task<IdentityResult> The result of the operation. Type Parameters TRole The type of role to update. UpdateUserAsync<TUser>(TUser, CancellationToken) Updates an existing user asynchronously. public Task<IdentityResult> UpdateUserAsync<TUser>(TUser user, CancellationToken cancellationToken) where TUser : SqliteIdentityUser Parameters user TUser The user to update. cancellationToken CancellationToken The cancellation token. Returns Task<IdentityResult> The result of the operation. Type Parameters TUser The type of user to update."
  },
  "api/Hi.SqliteUtils.SqliteIdentityUser.html": {
    "href": "api/Hi.SqliteUtils.SqliteIdentityUser.html",
    "title": "Class SqliteIdentityUser | HiAPI-C# 2025",
    "summary": "Class SqliteIdentityUser Namespace Hi.SqliteUtils Assembly HiNc.dll Base class for SQLite-based identity users. public class SqliteIdentityUser Inheritance object SqliteIdentityUser Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties AccessFailedCount Gets or sets the access failed count. public virtual int AccessFailedCount { get; set; } Property Value int ConcurrencyStamp Gets or sets the concurrency stamp. public virtual string ConcurrencyStamp { get; set; } Property Value string Email Gets or sets the email address. public virtual string Email { get; set; } Property Value string EmailConfirmed Gets or sets whether the email is confirmed. public virtual bool EmailConfirmed { get; set; } Property Value bool Id Gets or sets the user ID. public virtual string Id { get; set; } Property Value string InitialPassword Gets or sets the initial password. public virtual string InitialPassword { get; set; } Property Value string LockoutEnabled Gets or sets whether lockout is enabled. public virtual bool LockoutEnabled { get; set; } Property Value bool LockoutEnd Gets or sets the lockout end date/time. public virtual DateTimeOffset? LockoutEnd { get; set; } Property Value DateTimeOffset? NormalizedEmail Gets or sets the normalized email address. public virtual string NormalizedEmail { get; set; } Property Value string NormalizedUserName Gets or sets the normalized user name. public virtual string NormalizedUserName { get; set; } Property Value string PasswordHash Gets or sets the password hash. public virtual string PasswordHash { get; set; } Property Value string PhoneNumber Gets or sets the phone number. public virtual string PhoneNumber { get; set; } Property Value string PhoneNumberConfirmed Gets or sets whether the phone number is confirmed. public virtual bool PhoneNumberConfirmed { get; set; } Property Value bool SecurityStamp Gets or sets the security stamp. public virtual string SecurityStamp { get; set; } Property Value string TwoFactorEnabled Gets or sets whether two-factor authentication is enabled. public virtual bool TwoFactorEnabled { get; set; } Property Value bool UserName Gets or sets the user name. public virtual string UserName { get; set; } Property Value string Methods DeserializeCustomData(string) Deserializes custom data from JSON string. Override in derived class. public virtual void DeserializeCustomData(string json) Parameters json string SerializeCustomData() Serializes custom data to JSON string. Override in derived class. public virtual string SerializeCustomData() Returns string"
  },
  "api/Hi.SqliteUtils.SqliteRoleStore-1.html": {
    "href": "api/Hi.SqliteUtils.SqliteRoleStore-1.html",
    "title": "Class SqliteRoleStore<TRole> | HiAPI-C# 2025",
    "summary": "Class SqliteRoleStore<TRole> Namespace Hi.SqliteUtils Assembly HiNc.dll SQLite-based role store for ASP.NET Core Identity. public class SqliteRoleStore<TRole> : IRoleStore<TRole>, IQueryableRoleStore<TRole>, IRoleStore<TRole>, IDisposable where TRole : SqliteIdentityRole, new() Type Parameters TRole The type of role. Inheritance object SqliteRoleStore<TRole> Implements IRoleStore<TRole> IQueryableRoleStore<TRole> IRoleStore<TRole> IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SqliteRoleStore(SqliteIdentityStorage) Initializes a new instance of the SqliteRoleStore<TRole> class. public SqliteRoleStore(SqliteIdentityStorage storage) Parameters storage SqliteIdentityStorage The SQLite identity storage. Properties Roles Gets all roles as a queryable collection. public IQueryable<TRole> Roles { get; } Property Value IQueryable<TRole> Methods CreateAsync(TRole, CancellationToken) Creates a new role in a store as an asynchronous operation. public Task<IdentityResult> CreateAsync(TRole role, CancellationToken cancellationToken) Parameters role TRole The role to create in the store. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<IdentityResult> A Task<TResult> that represents the IdentityResult of the asynchronous query. DeleteAsync(TRole, CancellationToken) Deletes a role from the store as an asynchronous operation. public Task<IdentityResult> DeleteAsync(TRole role, CancellationToken cancellationToken) Parameters role TRole The role to delete from the store. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<IdentityResult> A Task<TResult> that represents the IdentityResult of the asynchronous query. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() FindByIdAsync(string, CancellationToken) Finds the role who has the specified ID as an asynchronous operation. public Task<TRole> FindByIdAsync(string roleId, CancellationToken cancellationToken) Parameters roleId string The role ID to look for. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<TRole> A Task<TResult> that result of the look up. FindByNameAsync(string, CancellationToken) Finds the role who has the specified normalized name as an asynchronous operation. public Task<TRole> FindByNameAsync(string normalizedRoleName, CancellationToken cancellationToken) Parameters normalizedRoleName string The normalized role name to look for. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<TRole> A Task<TResult> that result of the look up. GetNormalizedRoleNameAsync(TRole, CancellationToken) Get a role's normalized name as an asynchronous operation. public Task<string> GetNormalizedRoleNameAsync(TRole role, CancellationToken cancellationToken) Parameters role TRole The role whose normalized name should be retrieved. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<string> A Task<TResult> that contains the name of the role. GetRoleIdAsync(TRole, CancellationToken) Gets the ID for a role from the store as an asynchronous operation. public Task<string> GetRoleIdAsync(TRole role, CancellationToken cancellationToken) Parameters role TRole The role whose ID should be returned. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<string> A Task<TResult> that contains the ID of the role. GetRoleNameAsync(TRole, CancellationToken) Gets the name of a role from the store as an asynchronous operation. public Task<string> GetRoleNameAsync(TRole role, CancellationToken cancellationToken) Parameters role TRole The role whose name should be returned. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<string> A Task<TResult> that contains the name of the role. SetNormalizedRoleNameAsync(TRole, string, CancellationToken) Set a role's normalized name as an asynchronous operation. public Task SetNormalizedRoleNameAsync(TRole role, string normalizedName, CancellationToken cancellationToken) Parameters role TRole The role whose normalized name should be set. normalizedName string The normalized name to set cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task The Task that represents the asynchronous operation. SetRoleNameAsync(TRole, string, CancellationToken) Sets the name of a role in the store as an asynchronous operation. public Task SetRoleNameAsync(TRole role, string roleName, CancellationToken cancellationToken) Parameters role TRole The role whose name should be set. roleName string The name of the role. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task The Task that represents the asynchronous operation. UpdateAsync(TRole, CancellationToken) Updates a role in a store as an asynchronous operation. public Task<IdentityResult> UpdateAsync(TRole role, CancellationToken cancellationToken) Parameters role TRole The role to update in the store. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<IdentityResult> A Task<TResult> that represents the IdentityResult of the asynchronous query."
  },
  "api/Hi.SqliteUtils.SqliteStepStorage.MillingStepLuggageRow.html": {
    "href": "api/Hi.SqliteUtils.SqliteStepStorage.MillingStepLuggageRow.html",
    "title": "Class SqliteStepStorage.MillingStepLuggageRow | HiAPI-C# 2025",
    "summary": "Class SqliteStepStorage.MillingStepLuggageRow Namespace Hi.SqliteUtils Assembly HiNc.dll Represents a milling step luggage row in the database. public class SqliteStepStorage.MillingStepLuggageRow Inheritance object SqliteStepStorage.MillingStepLuggageRow Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties LayerEngagementData Gets or sets the layer engagement data as a byte array. public byte[] LayerEngagementData { get; set; } Property Value byte[] MillingForceData Gets or sets the milling force data as a byte array. public byte[] MillingForceData { get; set; } Property Value byte[] StepIndex Gets or sets the step index. public int StepIndex { get; set; } Property Value int SubstractionData Gets or sets the subtraction data as a byte array. public byte[] SubstractionData { get; set; } Property Value byte[] Methods ToMillingStepLuggage() Converts this row to a milling step luggage object. public MillingStepLuggage ToMillingStepLuggage() Returns MillingStepLuggage A new milling step luggage instance."
  },
  "api/Hi.SqliteUtils.SqliteStepStorage.html": {
    "href": "api/Hi.SqliteUtils.SqliteStepStorage.html",
    "title": "Class SqliteStepStorage | HiAPI-C# 2025",
    "summary": "Class SqliteStepStorage Namespace Hi.SqliteUtils Assembly HiNc.dll SQLite-based storage for milling step data. MillingStepLuggage data. public class SqliteStepStorage : IDisposable Inheritance object SqliteStepStorage Implements IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SqliteStepStorage(string, ILogger) Initializes a new instance of the SqliteStepStorage class. public SqliteStepStorage(string databasePath = null, ILogger logger = null) Parameters databasePath string The path to the SQLite database file. If null, uses the default per-user path (LocalApplicationData/HiNC/StepCache/step_cache.db) — callers hosting several instances under one account must pass a per-instance path. logger ILogger Optional logger instance. Properties DatabasePath Gets the database file path. public string DatabasePath { get; } Property Value string Default Gets or sets the default SQLite step storage instance. public static SqliteStepStorage Default { get; set; } Property Value SqliteStepStorage IsDefaultInit Gets a value indicating whether the default storage has been initialized. public static bool IsDefaultInit { get; } Property Value bool Methods ClearMillingStepLuggages() Deletes all milling step luggages from the database. public void ClearMillingStepLuggages() CountMillingStepLuggages() Gets the count of milling step luggages in the database. public int CountMillingStepLuggages() Returns int The count of records. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() Dispose(bool) Releases the resources used by the storage. protected virtual void Dispose(bool disposing) Parameters disposing bool Whether this method is being called from Dispose. FindMillingStepLuggages(int, int) Finds milling step luggages within the specified index range. public List<MillingStepLuggage> FindMillingStepLuggages(int beginIndex, int endIndex) Parameters beginIndex int The beginning index (inclusive). endIndex int The ending index (exclusive). Returns List<MillingStepLuggage> A list of milling step luggages. InsertMillingStepLuggages(IEnumerable<MillingStepLuggage>) Inserts multiple milling step luggages into the database. public void InsertMillingStepLuggages(IEnumerable<MillingStepLuggage> items) Parameters items IEnumerable<MillingStepLuggage> The items to insert. Reset() Resets the storage by deleting and recreating the database file. public void Reset() Remarks Delete-and-recreate instead of DELETE FROM: the per-run cache grows to many GB of step blobs and SQLite never returns freed pages to the file system (VACUUM would rewrite the whole file), so recreating the file is both the fastest wipe and the only practical space reclaim. Callers drain the luggage writer first (ResetStateAndClStrip → WaitAll) and the file is per-instance, so no other writer can be mid-batch. Falls back to the in-place table wipe when the file is still held open (e.g. a concurrent reader mid-query keeps the delete off on Windows)."
  },
  "api/Hi.SqliteUtils.SqliteUserStore-1.html": {
    "href": "api/Hi.SqliteUtils.SqliteUserStore-1.html",
    "title": "Class SqliteUserStore<TUser> | HiAPI-C# 2025",
    "summary": "Class SqliteUserStore<TUser> Namespace Hi.SqliteUtils Assembly HiNc.dll SQLite-based user store for ASP.NET Core Identity. public class SqliteUserStore<TUser> : IUserStore<TUser>, IUserPasswordStore<TUser>, IUserRoleStore<TUser>, IUserEmailStore<TUser>, IUserPhoneNumberStore<TUser>, IUserTwoFactorStore<TUser>, IUserLockoutStore<TUser>, IUserSecurityStampStore<TUser>, IQueryableUserStore<TUser>, IUserStore<TUser>, IDisposable where TUser : SqliteIdentityUser, new() Type Parameters TUser The type of user. Inheritance object SqliteUserStore<TUser> Implements IUserStore<TUser> IUserPasswordStore<TUser> IUserRoleStore<TUser> IUserEmailStore<TUser> IUserPhoneNumberStore<TUser> IUserTwoFactorStore<TUser> IUserLockoutStore<TUser> IUserSecurityStampStore<TUser> IQueryableUserStore<TUser> IUserStore<TUser> IDisposable Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors SqliteUserStore(SqliteIdentityStorage) Initializes a new instance of the SqliteUserStore<TUser> class. public SqliteUserStore(SqliteIdentityStorage storage) Parameters storage SqliteIdentityStorage The SQLite identity storage. Properties Users Gets all users as a queryable collection. public IQueryable<TUser> Users { get; } Property Value IQueryable<TUser> Methods AddToRoleAsync(TUser, string, CancellationToken) Add the specified user to the named role. public Task AddToRoleAsync(TUser user, string roleName, CancellationToken cancellationToken) Parameters user TUser The user to add to the named role. roleName string The name of the role to add the user to. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task The Task that represents the asynchronous operation. CreateAsync(TUser, CancellationToken) Creates the specified user in the user store. public Task<IdentityResult> CreateAsync(TUser user, CancellationToken cancellationToken) Parameters user TUser The user to create. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<IdentityResult> The Task that represents the asynchronous operation, containing the IdentityResult of the creation operation. DeleteAsync(TUser, CancellationToken) Deletes the specified user from the user store. public Task<IdentityResult> DeleteAsync(TUser user, CancellationToken cancellationToken) Parameters user TUser The user to delete. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<IdentityResult> The Task that represents the asynchronous operation, containing the IdentityResult of the delete operation. Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. public void Dispose() FindByEmailAsync(string, CancellationToken) Gets the user, if any, associated with the specified, normalized email address. public Task<TUser> FindByEmailAsync(string normalizedEmail, CancellationToken cancellationToken) Parameters normalizedEmail string The normalized email address to return the user for. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<TUser> The task object containing the results of the asynchronous lookup operation, the user if any associated with the specified normalized email address. FindByIdAsync(string, CancellationToken) Finds and returns a user, if any, who has the specified userId. public Task<TUser> FindByIdAsync(string userId, CancellationToken cancellationToken) Parameters userId string The user ID to search for. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<TUser> The Task that represents the asynchronous operation, containing the user matching the specified userId if it exists. FindByNameAsync(string, CancellationToken) Finds and returns a user, if any, who has the specified normalized user name. public Task<TUser> FindByNameAsync(string normalizedUserName, CancellationToken cancellationToken) Parameters normalizedUserName string The normalized user name to search for. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<TUser> The Task that represents the asynchronous operation, containing the user matching the specified normalizedUserName if it exists. GetAccessFailedCountAsync(TUser, CancellationToken) Retrieves the current failed access count for the specified user. public Task<int> GetAccessFailedCountAsync(TUser user, CancellationToken cancellationToken) Parameters user TUser The user whose failed access count should be retrieved. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<int> The Task that represents the asynchronous operation, containing the failed access count. GetEmailAsync(TUser, CancellationToken) Gets the email address for the specified user. public Task<string> GetEmailAsync(TUser user, CancellationToken cancellationToken) Parameters user TUser The user whose email should be returned. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<string> The task object containing the results of the asynchronous operation, the email address for the specified user. GetEmailConfirmedAsync(TUser, CancellationToken) Gets a flag indicating whether the email address for the specified user has been verified, true if the email address is verified otherwise false. public Task<bool> GetEmailConfirmedAsync(TUser user, CancellationToken cancellationToken) Parameters user TUser The user whose email confirmation status should be returned. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<bool> The task object containing the results of the asynchronous operation, a flag indicating whether the email address for the specified user has been confirmed or not. GetLockoutEnabledAsync(TUser, CancellationToken) Retrieves a flag indicating whether user lockout can enabled for the specified user. public Task<bool> GetLockoutEnabledAsync(TUser user, CancellationToken cancellationToken) Parameters user TUser The user whose ability to be locked out should be returned. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<bool> The Task that represents the asynchronous operation, true if a user can be locked out, otherwise false. GetLockoutEndDateAsync(TUser, CancellationToken) Gets the last DateTimeOffset a user's last lockout expired, if any. Any time in the past should be indicates a user is not locked out. public Task<DateTimeOffset?> GetLockoutEndDateAsync(TUser user, CancellationToken cancellationToken) Parameters user TUser The user whose lockout date should be retrieved. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<DateTimeOffset?> A Task<TResult> that represents the result of the asynchronous query, a DateTimeOffset containing the last time a user's lockout expired, if any. GetNormalizedEmailAsync(TUser, CancellationToken) Returns the normalized email for the specified user. public Task<string> GetNormalizedEmailAsync(TUser user, CancellationToken cancellationToken) Parameters user TUser The user whose email address to retrieve. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<string> The task object containing the results of the asynchronous lookup operation, the normalized email address if any associated with the specified user. GetNormalizedUserNameAsync(TUser, CancellationToken) Gets the normalized user name for the specified user. public Task<string> GetNormalizedUserNameAsync(TUser user, CancellationToken cancellationToken) Parameters user TUser The user whose normalized name should be retrieved. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<string> The Task that represents the asynchronous operation, containing the normalized user name for the specified user. GetPasswordHashAsync(TUser, CancellationToken) Gets the password hash for the specified user. public Task<string> GetPasswordHashAsync(TUser user, CancellationToken cancellationToken) Parameters user TUser The user whose password hash to retrieve. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<string> The Task that represents the asynchronous operation, returning the password hash for the specified user. GetPhoneNumberAsync(TUser, CancellationToken) Gets the telephone number, if any, for the specified user. public Task<string> GetPhoneNumberAsync(TUser user, CancellationToken cancellationToken) Parameters user TUser The user whose telephone number should be retrieved. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<string> The Task that represents the asynchronous operation, containing the user's telephone number, if any. GetPhoneNumberConfirmedAsync(TUser, CancellationToken) Gets a flag indicating whether the specified user's telephone number has been confirmed. public Task<bool> GetPhoneNumberConfirmedAsync(TUser user, CancellationToken cancellationToken) Parameters user TUser The user to return a flag for, indicating whether their telephone number is confirmed. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<bool> The Task that represents the asynchronous operation, returning true if the specified user has a confirmed telephone number otherwise false. GetRolesAsync(TUser, CancellationToken) Gets a list of role names the specified user belongs to. public Task<IList<string>> GetRolesAsync(TUser user, CancellationToken cancellationToken) Parameters user TUser The user whose role names to retrieve. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<IList<string>> The Task that represents the asynchronous operation, containing a list of role names. GetSecurityStampAsync(TUser, CancellationToken) Get the security stamp for the specified user. public Task<string> GetSecurityStampAsync(TUser user, CancellationToken cancellationToken) Parameters user TUser The user whose security stamp should be set. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<string> The Task that represents the asynchronous operation, containing the security stamp for the specified user. GetTwoFactorEnabledAsync(TUser, CancellationToken) Returns a flag indicating whether the specified user has two factor authentication enabled or not, as an asynchronous operation. public Task<bool> GetTwoFactorEnabledAsync(TUser user, CancellationToken cancellationToken) Parameters user TUser The user whose two factor authentication enabled status should be set. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<bool> The Task that represents the asynchronous operation, containing a flag indicating whether the specified user has two factor authentication enabled or not. GetUserIdAsync(TUser, CancellationToken) Gets the user identifier for the specified user. public Task<string> GetUserIdAsync(TUser user, CancellationToken cancellationToken) Parameters user TUser The user whose identifier should be retrieved. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<string> The Task that represents the asynchronous operation, containing the identifier for the specified user. GetUserNameAsync(TUser, CancellationToken) Gets the user name for the specified user. public Task<string> GetUserNameAsync(TUser user, CancellationToken cancellationToken) Parameters user TUser The user whose name should be retrieved. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<string> The Task that represents the asynchronous operation, containing the name for the specified user. GetUsersInRoleAsync(string, CancellationToken) Returns a list of Users who are members of the named role. public Task<IList<TUser>> GetUsersInRoleAsync(string roleName, CancellationToken cancellationToken) Parameters roleName string The name of the role whose membership should be returned. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<IList<TUser>> The Task that represents the asynchronous operation, containing a list of users who are in the named role. HasPasswordAsync(TUser, CancellationToken) Gets a flag indicating whether the specified user has a password. public Task<bool> HasPasswordAsync(TUser user, CancellationToken cancellationToken) Parameters user TUser The user to return a flag for, indicating whether they have a password or not. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<bool> The Task that represents the asynchronous operation, returning true if the specified user has a password otherwise false. IncrementAccessFailedCountAsync(TUser, CancellationToken) Records that a failed access has occurred, incrementing the failed access count. public Task<int> IncrementAccessFailedCountAsync(TUser user, CancellationToken cancellationToken) Parameters user TUser The user whose cancellation count should be incremented. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<int> The Task that represents the asynchronous operation, containing the incremented failed access count. IsInRoleAsync(TUser, string, CancellationToken) Returns a flag indicating whether the specified user is a member of the given named role. public Task<bool> IsInRoleAsync(TUser user, string roleName, CancellationToken cancellationToken) Parameters user TUser The user whose role membership should be checked. roleName string The name of the role to be checked. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<bool> The Task that represents the asynchronous operation, containing a flag indicating whether the specified user is a member of the named role. RemoveFromRoleAsync(TUser, string, CancellationToken) Remove the specified user from the named role. public Task RemoveFromRoleAsync(TUser user, string roleName, CancellationToken cancellationToken) Parameters user TUser The user to remove the named role from. roleName string The name of the role to remove. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task The Task that represents the asynchronous operation. ResetAccessFailedCountAsync(TUser, CancellationToken) Resets a user's failed access count. public Task ResetAccessFailedCountAsync(TUser user, CancellationToken cancellationToken) Parameters user TUser The user whose failed access count should be reset. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task The Task that represents the asynchronous operation. Remarks This is typically called after the account is successfully accessed. SetEmailAsync(TUser, string, CancellationToken) Sets the email address for a user. public Task SetEmailAsync(TUser user, string email, CancellationToken cancellationToken) Parameters user TUser The user whose email should be set. email string The email to set. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task The task object representing the asynchronous operation. SetEmailConfirmedAsync(TUser, bool, CancellationToken) Sets the flag indicating whether the specified user's email address has been confirmed or not. public Task SetEmailConfirmedAsync(TUser user, bool confirmed, CancellationToken cancellationToken) Parameters user TUser The user whose email confirmation status should be set. confirmed bool A flag indicating if the email address has been confirmed, true if the address is confirmed otherwise false. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task The task object representing the asynchronous operation. SetLockoutEnabledAsync(TUser, bool, CancellationToken) Set the flag indicating if the specified user can be locked out. public Task SetLockoutEnabledAsync(TUser user, bool enabled, CancellationToken cancellationToken) Parameters user TUser The user whose ability to be locked out should be set. enabled bool A flag indicating if lock out can be enabled for the specified user. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task The Task that represents the asynchronous operation. SetLockoutEndDateAsync(TUser, DateTimeOffset?, CancellationToken) Locks out a user until the specified end date has passed. Setting a end date in the past immediately unlocks a user. public Task SetLockoutEndDateAsync(TUser user, DateTimeOffset? lockoutEnd, CancellationToken cancellationToken) Parameters user TUser The user whose lockout date should be set. lockoutEnd DateTimeOffset? The DateTimeOffset after which the user's lockout should end. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task The Task that represents the asynchronous operation. SetNormalizedEmailAsync(TUser, string, CancellationToken) Sets the normalized email for the specified user. public Task SetNormalizedEmailAsync(TUser user, string normalizedEmail, CancellationToken cancellationToken) Parameters user TUser The user whose email address to set. normalizedEmail string The normalized email to set for the specified user. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task The task object representing the asynchronous operation. SetNormalizedUserNameAsync(TUser, string, CancellationToken) Sets the given normalized name for the specified user. public Task SetNormalizedUserNameAsync(TUser user, string normalizedName, CancellationToken cancellationToken) Parameters user TUser The user whose name should be set. normalizedName string The normalized name to set. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task The Task that represents the asynchronous operation. SetPasswordHashAsync(TUser, string, CancellationToken) Sets the password hash for the specified user. public Task SetPasswordHashAsync(TUser user, string passwordHash, CancellationToken cancellationToken) Parameters user TUser The user whose password hash to set. passwordHash string The password hash to set. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task The Task that represents the asynchronous operation. SetPhoneNumberAsync(TUser, string, CancellationToken) Sets the telephone number for the specified user. public Task SetPhoneNumberAsync(TUser user, string phoneNumber, CancellationToken cancellationToken) Parameters user TUser The user whose telephone number should be set. phoneNumber string The telephone number to set. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task The Task that represents the asynchronous operation. SetPhoneNumberConfirmedAsync(TUser, bool, CancellationToken) Sets a flag indicating if the specified user's phone number has been confirmed. public Task SetPhoneNumberConfirmedAsync(TUser user, bool confirmed, CancellationToken cancellationToken) Parameters user TUser The user whose telephone number confirmation status should be set. confirmed bool A flag indicating whether the user's telephone number has been confirmed. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task The Task that represents the asynchronous operation. SetSecurityStampAsync(TUser, string, CancellationToken) Sets the provided security stamp for the specified user. public Task SetSecurityStampAsync(TUser user, string stamp, CancellationToken cancellationToken) Parameters user TUser The user whose security stamp should be set. stamp string The security stamp to set. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task The Task that represents the asynchronous operation. SetTwoFactorEnabledAsync(TUser, bool, CancellationToken) Sets a flag indicating whether the specified user has two factor authentication enabled or not, as an asynchronous operation. public Task SetTwoFactorEnabledAsync(TUser user, bool enabled, CancellationToken cancellationToken) Parameters user TUser The user whose two factor authentication enabled status should be set. enabled bool A flag indicating whether the specified user has two factor authentication enabled. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task The Task that represents the asynchronous operation. SetUserNameAsync(TUser, string, CancellationToken) Sets the given userName for the specified user. public Task SetUserNameAsync(TUser user, string userName, CancellationToken cancellationToken) Parameters user TUser The user whose name should be set. userName string The user name to set. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task The Task that represents the asynchronous operation. UpdateAsync(TUser, CancellationToken) Updates the specified user in the user store. public Task<IdentityResult> UpdateAsync(TUser user, CancellationToken cancellationToken) Parameters user TUser The user to update. cancellationToken CancellationToken The CancellationToken used to propagate notifications that the operation should be canceled. Returns Task<IdentityResult> The Task that represents the asynchronous operation, containing the IdentityResult of the update operation."
  },
  "api/Hi.SqliteUtils.html": {
    "href": "api/Hi.SqliteUtils.html",
    "title": "Namespace Hi.SqliteUtils | HiAPI-C# 2025",
    "summary": "Namespace Hi.SqliteUtils Classes SqliteIdentityRole Base class for SQLite-based identity roles. SqliteIdentityStorage SQLite-based storage for ASP.NET Core Identity. SqliteIdentityStorage.RoleRow Represents a role row in the database. SqliteIdentityStorage.UserRow Represents a user row in the database. SqliteIdentityUser Base class for SQLite-based identity users. SqliteRoleStore<TRole> SQLite-based role store for ASP.NET Core Identity. SqliteStepStorage SQLite-based storage for milling step data. MillingStepLuggage data. SqliteStepStorage.MillingStepLuggageRow Represents a milling step luggage row in the database. SqliteUserStore<TUser> SQLite-based user store for ASP.NET Core Identity."
  },
  "api/Hi.Test.TestCollision.html": {
    "href": "api/Hi.Test.TestCollision.html",
    "title": "Class TestCollision | HiAPI-C# 2025",
    "summary": "Class TestCollision Namespace Hi.Test Assembly HiCbtr.dll For internal. public class TestCollision Inheritance object TestCollision Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Methods Main() For internal. [STAThread] public static void Main()"
  },
  "api/Hi.Test.html": {
    "href": "api/Hi.Test.html",
    "title": "Namespace Hi.Test | HiAPI-C# 2025",
    "summary": "Namespace Hi.Test Classes TestCollision For internal."
  },
  "api/Hi.UiExtensions.ChartBoundary.html": {
    "href": "api/Hi.UiExtensions.ChartBoundary.html",
    "title": "Class ChartBoundary | HiAPI-C# 2025",
    "summary": "Class ChartBoundary Namespace Hi.UiExtensions Assembly HiGeom.dll Boundary of Chart public class ChartBoundary Inheritance object ChartBoundary Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Fixed Gets or sets the fixed value for the chart boundary. Only applies when MainChartBoundaryEnum includes Fixed. public double Fixed { get; set; } Property Value double LowerLimit Gets or sets the lower limit of the chart boundary. Only applies when MainChartBoundaryEnum includes LowerLimit. public double LowerLimit { get; set; } Property Value double MainChartBoundaryEnum Gets or sets the boundary enumeration that controls the chart's behavior. public ChartBoundaryEnum MainChartBoundaryEnum { get; set; } Property Value ChartBoundaryEnum UpperLimit Gets or sets the upper limit of the chart boundary. Only applies when MainChartBoundaryEnum includes UpperLimit. public double UpperLimit { get; set; } Property Value double Methods ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object."
  },
  "api/Hi.UiExtensions.ChartBoundaryEnum.html": {
    "href": "api/Hi.UiExtensions.ChartBoundaryEnum.html",
    "title": "Enum ChartBoundaryEnum | HiAPI-C# 2025",
    "summary": "Enum ChartBoundaryEnum Namespace Hi.UiExtensions Assembly HiGeom.dll Enum control ChartBoundary. [Flags] public enum ChartBoundaryEnum Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Fixed = 1 Lock the chart boundary. Lock is exclusive from LowerLimit and UpperLimit. LowerLimit = 2 Lower limit of the chart boundary. None = 0 No limit of the chart boundary. UpperLimit = 4 Uppler limit of the chart boundary."
  },
  "api/Hi.UiExtensions.NativeVisibility.html": {
    "href": "api/Hi.UiExtensions.NativeVisibility.html",
    "title": "Enum NativeVisibility | HiAPI-C# 2025",
    "summary": "Enum NativeVisibility Namespace Hi.UiExtensions Assembly HiGeom.dll Enumeration representing visibility states for UI elements. public enum NativeVisibility : byte Extension Methods InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) MaskUtil.GetMaskedValue<T>(T, T, bool) MaskUtil.SetMask<T>(ref T, T, bool) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Fields Collapsed = 2 Element is hidden and does not take up layout space. Hidden = 1 Element is hidden but still takes up layout space. Visible = 0 Element is visible."
  },
  "api/Hi.UiExtensions.UiUtil.InvokeFunc.html": {
    "href": "api/Hi.UiExtensions.UiUtil.InvokeFunc.html",
    "title": "Delegate UiUtil.InvokeFunc | HiAPI-C# 2025",
    "summary": "Delegate UiUtil.InvokeFunc Namespace Hi.UiExtensions Assembly HiGeom.dll Delegate for invoking methods asynchronously or synchronously. public delegate object UiUtil.InvokeFunc(Delegate method, params object[] args) Parameters method Delegate The delegate method to invoke args object[] Arguments to pass to the method Returns object The result of the invocation Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object)"
  },
  "api/Hi.UiExtensions.UiUtil.html": {
    "href": "api/Hi.UiExtensions.UiUtil.html",
    "title": "Class UiUtil | HiAPI-C# 2025",
    "summary": "Class UiUtil Namespace Hi.UiExtensions Assembly HiGeom.dll The member should be initial for application begin. public static class UiUtil Inheritance object UiUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Properties BeginInvoke Gets or sets the function for beginning asynchronous invocation of methods. public static UiUtil.InvokeFunc BeginInvoke { get; set; } Property Value UiUtil.InvokeFunc Invoke Gets or sets the function for synchronous invocation of methods. public static UiUtil.InvokeFunc Invoke { get; set; } Property Value UiUtil.InvokeFunc"
  },
  "api/Hi.UiExtensions.html": {
    "href": "api/Hi.UiExtensions.html",
    "title": "Namespace Hi.UiExtensions | HiAPI-C# 2025",
    "summary": "Namespace Hi.UiExtensions Classes ChartBoundary Boundary of Chart UiUtil The member should be initial for application begin. Enums ChartBoundaryEnum Enum control ChartBoundary. NativeVisibility Enumeration representing visibility states for UI elements. Delegates UiUtil.InvokeFunc Delegate for invoking methods asynchronously or synchronously."
  },
  "api/Hi.Vibrations.AngularVelocityUtil.html": {
    "href": "api/Hi.Vibrations.AngularVelocityUtil.html",
    "title": "Class AngularVelocityUtil | HiAPI-C# 2025",
    "summary": "Class AngularVelocityUtil Namespace Hi.Vibrations Assembly HiMech.dll Provides utility methods for working with angular velocity. public static class AngularVelocityUtil Inheritance object AngularVelocityUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetFrequency(IAngularVelocityOwner) Gets the frequency in Hz from angular velocity. public static double GetFrequency(this IAngularVelocityOwner src) Parameters src IAngularVelocityOwner The angular velocity owner. Returns double The frequency in Hz. SetFrequency(IAngularVelocityOwner, double) Sets the angular velocity based on the specified frequency. public static void SetFrequency(this IAngularVelocityOwner src, double freq) Parameters src IAngularVelocityOwner The angular velocity owner. freq double The frequency in Hz."
  },
  "api/Hi.Vibrations.ForceAccelAmpPhase.html": {
    "href": "api/Hi.Vibrations.ForceAccelAmpPhase.html",
    "title": "Class ForceAccelAmpPhase | HiAPI-C# 2025",
    "summary": "Class ForceAccelAmpPhase Namespace Hi.Vibrations Assembly HiMech.dll Represents amplitude and phase information for force and acceleration in vibration analysis. public class ForceAccelAmpPhase Inheritance object ForceAccelAmpPhase Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties AccelAmpPhase Gets or sets the amplitude and phase information for acceleration components. public AmpPhase[] AccelAmpPhase { get; set; } Property Value AmpPhase[] ForceAmpPhase Gets or sets the amplitude and phase information for force components. public AmpPhase[] ForceAmpPhase { get; set; } Property Value AmpPhase[]"
  },
  "api/Hi.Vibrations.ForceAccelFourierSeries.html": {
    "href": "api/Hi.Vibrations.ForceAccelFourierSeries.html",
    "title": "Class ForceAccelFourierSeries | HiAPI-C# 2025",
    "summary": "Class ForceAccelFourierSeries Namespace Hi.Vibrations Assembly HiMech.dll Represents Fourier series data for force and acceleration measurements in three dimensions. public class ForceAccelFourierSeries Inheritance object ForceAccelFourierSeries Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) VibrationUtil.GetAmpPhaseTransformation(ForceAccelFourierSeries) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ForceAccelFourierSeries(double, List<Vec2d>, List<Vec2d>, List<Vec2d>, List<Vec2d>, List<Vec2d>, List<Vec2d>) Initializes a new instance of the ForceAccelFourierSeries class with the specified Fourier coefficients. public ForceAccelFourierSeries(double baseAngularVelocity, List<Vec2d> forceXFourierSeries, List<Vec2d> forceYFourierSeries, List<Vec2d> forceZFourierSeries, List<Vec2d> accelXFourierSeries, List<Vec2d> accelYFourierSeries, List<Vec2d> accelZFourierSeries) Parameters baseAngularVelocity double The base angular velocity for the Fourier series forceXFourierSeries List<Vec2d> Fourier coefficients for force in X direction forceYFourierSeries List<Vec2d> Fourier coefficients for force in Y direction forceZFourierSeries List<Vec2d> Fourier coefficients for force in Z direction accelXFourierSeries List<Vec2d> Fourier coefficients for acceleration in X direction accelYFourierSeries List<Vec2d> Fourier coefficients for acceleration in Y direction accelZFourierSeries List<Vec2d> Fourier coefficients for acceleration in Z direction Properties AccelXFourierSeries Gets or sets the Fourier series coefficients for acceleration in X direction. Each Vec2d represents a complex coefficient (real, imaginary). public List<Vec2d> AccelXFourierSeries { get; set; } Property Value List<Vec2d> AccelYFourierSeries Gets or sets the Fourier series coefficients for acceleration in Y direction. Each Vec2d represents a complex coefficient (real, imaginary). public List<Vec2d> AccelYFourierSeries { get; set; } Property Value List<Vec2d> AccelZFourierSeries Gets or sets the Fourier series coefficients for acceleration in Z direction. Each Vec2d represents a complex coefficient (real, imaginary). public List<Vec2d> AccelZFourierSeries { get; set; } Property Value List<Vec2d> BaseAngularVelocity Gets or sets the base angular velocity for the Fourier series. public double BaseAngularVelocity { get; set; } Property Value double ForceXFourierSeries Gets or sets the Fourier series coefficients for force in X direction. Each Vec2d represents a complex coefficient (real, imaginary). public List<Vec2d> ForceXFourierSeries { get; set; } Property Value List<Vec2d> ForceYFourierSeries Gets or sets the Fourier series coefficients for force in Y direction. Each Vec2d represents a complex coefficient (real, imaginary). public List<Vec2d> ForceYFourierSeries { get; set; } Property Value List<Vec2d> ForceZFourierSeries Gets or sets the Fourier series coefficients for force in Z direction. Each Vec2d represents a complex coefficient (real, imaginary). public List<Vec2d> ForceZFourierSeries { get; set; } Property Value List<Vec2d>"
  },
  "api/Hi.Vibrations.ForceAccelShot.html": {
    "href": "api/Hi.Vibrations.ForceAccelShot.html",
    "title": "Class ForceAccelShot | HiAPI-C# 2025",
    "summary": "Class ForceAccelShot Namespace Hi.Vibrations Assembly HiMech.dll Represents a data point containing force, acceleration, and moment measurements at a specific time. public class ForceAccelShot : IForceShot, IMomentShot, IAccelerationShot, ITimeShot, ITimecoded Inheritance object ForceAccelShot Implements IForceShot IMomentShot IAccelerationShot ITimeShot ITimecoded Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ForceAccelShot() Initializes a new instance of the ForceAccelShot class. public ForceAccelShot() ForceAccelShot(TimeSpan, Vec3d, Vec3d, Vec3d) Initializes a new instance of the ForceAccelShot class with the specified values. public ForceAccelShot(TimeSpan time, Vec3d force_N, Vec3d acceleration_g, Vec3d moment_Nm) Parameters time TimeSpan The time point of the measurement. force_N Vec3d The force vector in Newtons. acceleration_g Vec3d The acceleration vector in g-force units. moment_Nm Vec3d The moment vector in Newton-meters. Properties Acceleration_g Gets or sets the acceleration vector in g-force units (g). This property automatically converts between mm/s² and g, where 1g = 9.81 m/s². public Vec3d Acceleration_g { get; set; } Property Value Vec3d Remarks Conversion factors: From m/s² to g: divide by 9.81 From g to m/s²: multiply by 9.81 Common reference values: 1g: Earth's gravitational acceleration 0g: Free fall Acceleration_mds2 Gets or sets the acceleration vector in meters per second squared (m/s²). This property automatically converts between mm/s² and m/s². public Vec3d Acceleration_mds2 { get; set; } Property Value Vec3d Remarks Conversion factors: From mm/s² to m/s²: divide by 1000 From m/s² to mm/s²: multiply by 1000 Acceleration_mmds2 Gets or sets the acceleration vector in millimeters per second squared (mm/s²). This is the base unit for acceleration storage in the system. public Vec3d Acceleration_mmds2 { get; set; } Property Value Vec3d Remarks The acceleration vector components represent: X: Acceleration in the X direction (mm/s²) Y: Acceleration in the Y direction (mm/s²) Z: Acceleration in the Z direction (mm/s²) AxTag Gets the column name for X-axis acceleration data in CSV files. public static string AxTag { get; } Property Value string AyTag Gets the column name for Y-axis acceleration data in CSV files. public static string AyTag { get; } Property Value string AzTag Gets the column name for Z-axis acceleration data in CSV files. public static string AzTag { get; } Property Value string Force_N Gets or sets the force vector applied to the workpiece, measured in Newtons (N). public Vec3d Force_N { get; set; } Property Value Vec3d Remarks The force vector components represent: X: Force in the X direction (N) Y: Force in the Y direction (N) Z: Force in the Z direction (N) Positive values typically indicate: Forces acting in the positive direction of each axis Forces applied to the workpiece (rather than the tool) FxTags Gets the possible column names for X-axis force data in CSV files. public static string[] FxTags { get; } Property Value string[] FyTags Gets the possible column names for Y-axis force data in CSV files. public static string[] FyTags { get; } Property Value string[] FzTags Gets the possible column names for Z-axis force data in CSV files. public static string[] FzTags { get; } Property Value string[] Moment_Nm Gets or sets the moment (torque) vector, measured in Newton-meters (N⋅m). public Vec3d Moment_Nm { get; set; } Property Value Vec3d Remarks The moment vector components represent: X: Moment around the X axis (N⋅m) Y: Moment around the Y axis (N⋅m) Z: Moment around the Z axis (N⋅m) Positive values indicate: Clockwise moments when looking along the positive axis direction Following the right-hand rule convention MxTags Gets the possible column names for X-axis moment data in CSV files. public static string[] MxTags { get; } Property Value string[] MyTags Gets the possible column names for Y-axis moment data in CSV files. public static string[] MyTags { get; } Property Value string[] MzTags Gets the possible column names for Z-axis moment data in CSV files. public static string[] MzTags { get; } Property Value string[] TimeTags Gets the possible column names for time data in CSV files. public static string[] TimeTags { get; } Property Value string[] Timecode Gets or sets the time value in seconds. public TimeSpan Timecode { get; set; } Property Value TimeSpan Methods GetAdd(ITimeShot) Adds another time shot to this one. public ITimeShot GetAdd(ITimeShot shot) Parameters shot ITimeShot The time shot to add. Returns ITimeShot A new time shot representing the sum of the two shots. Remarks The addition should: Combine vector components appropriately Handle null or missing data gracefully Preserve the time value according to implementation rules GetScaled(double) Scales the values in this time shot by the specified factor. public ITimeShot GetScaled(double scale) Parameters scale double The scaling factor to apply to all vector components. Returns ITimeShot A new time shot with all values scaled by the given factor. Remarks The scaling should: Apply to all vector components Handle null or missing data gracefully Scale the time value if appropriate for the implementation ReadRows(string, Action<int>, CancellationToken?, Func<DateTime, TimeSpan>) Reads force and acceleration data from a CSV file. public static List<ForceAccelShot> ReadRows(string file, Action<int> lineReaded = null, CancellationToken? cancellationToken = null, Func<DateTime, TimeSpan> toTimecode = null) Parameters file string The path to the CSV file to read. lineReaded Action<int> Optional callback function to report progress. cancellationToken CancellationToken? Optional cancellation token to cancel the operation. toTimecode Func<DateTime, TimeSpan> Converter from an absolute sample DateTime to its timecode TimeSpan (used for step timing). Returns List<ForceAccelShot> A list of ForceAccelShot objects containing the data from the file. Exceptions InvalidDataException Thrown when the file format is invalid. ToString() Returns a string that represents the current object. public override string ToString() Returns string A string that represents the current object. ToString(string) Returns a string representation of the ForceAccelShot instance with the specified format. public string ToString(string format) Parameters format string The format string to use for numeric values. Returns string A string containing the formatted values. Operators operator +(ForceAccelShot, ForceAccelShot) Adds two ForceAccelShot instances together. public static ForceAccelShot operator +(ForceAccelShot a, ForceAccelShot b) Parameters a ForceAccelShot The first ForceAccelShot instance. b ForceAccelShot The second ForceAccelShot instance. Returns ForceAccelShot A new ForceAccelShot instance containing the sum of the two inputs. operator *(ForceAccelShot, double) Multiplies a ForceAccelShot instance by a scalar value. public static ForceAccelShot operator *(ForceAccelShot a, double s) Parameters a ForceAccelShot The ForceAccelShot instance to multiply. s double The scalar value to multiply by. Returns ForceAccelShot A new ForceAccelShot instance containing the scaled values."
  },
  "api/Hi.Vibrations.ForceAccelUtil.html": {
    "href": "api/Hi.Vibrations.ForceAccelUtil.html",
    "title": "Class ForceAccelUtil | HiAPI-C# 2025",
    "summary": "Class ForceAccelUtil Namespace Hi.Vibrations Assembly HiMech.dll Utility class for force and acceleration data processing. public static class ForceAccelUtil Inheritance object ForceAccelUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods GetForceAccelApSeries(List<ForceAccelShot>, TimeSpan, TimeSpan, int) Gets force and acceleration amplitude-phase series from shots. public static List<ForceAccelAmpPhase> GetForceAccelApSeries(this List<ForceAccelShot> shots, TimeSpan basePeriod, TimeSpan resolutionPeriod, int threadNum = 1) Parameters shots List<ForceAccelShot> The force-acceleration shot data. basePeriod TimeSpan The base period for the Fourier transform. resolutionPeriod TimeSpan The resolution period for the Fourier transform. threadNum int The number of threads to use for computation. Returns List<ForceAccelAmpPhase> A list of force and acceleration amplitude-phase data. GetForceAccelFourierSeries(List<ForceAccelShot>, TimeSpan, TimeSpan, int) Gets force and acceleration Fourier series from shots. public static ForceAccelFourierSeries GetForceAccelFourierSeries(this List<ForceAccelShot> shots, TimeSpan basePeriod, TimeSpan resolutionPeriod, int threadNum = 1) Parameters shots List<ForceAccelShot> The force-acceleration shot data. basePeriod TimeSpan The base period for the Fourier transform. resolutionPeriod TimeSpan The resolution period for the Fourier transform. threadNum int The number of threads to use for computation. Returns ForceAccelFourierSeries A force-acceleration Fourier series representation."
  },
  "api/Hi.Vibrations.IAngularVelocityOwner.html": {
    "href": "api/Hi.Vibrations.IAngularVelocityOwner.html",
    "title": "Interface IAngularVelocityOwner | HiAPI-C# 2025",
    "summary": "Interface IAngularVelocityOwner Namespace Hi.Vibrations Assembly HiMech.dll Provides functionality for objects that have an angular velocity property. public interface IAngularVelocityOwner Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) AngularVelocityUtil.GetFrequency(IAngularVelocityOwner) AngularVelocityUtil.SetFrequency(IAngularVelocityOwner, double) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties AngularVelocity Gets or sets the angular velocity in radians per second. double AngularVelocity { get; set; } Property Value double"
  },
  "api/Hi.Vibrations.VibrationUtil.html": {
    "href": "api/Hi.Vibrations.VibrationUtil.html",
    "title": "Class VibrationUtil | HiAPI-C# 2025",
    "summary": "Class VibrationUtil Namespace Hi.Vibrations Assembly HiMech.dll Utility class for vibration analysis and processing. public static class VibrationUtil Inheritance object VibrationUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Methods BuildDampingSystem(List<ForceAccelFourierSeries>) Builds a damping system model based on force and acceleration data. public static void BuildDampingSystem(List<ForceAccelFourierSeries> src) Parameters src List<ForceAccelFourierSeries> List of force-acceleration Fourier series used to build the system. GetAmpPhaseTransformation(ForceAccelFourierSeries) Gets the amplitude-phase transformations across XYZ axes from a force-acceleration Fourier series. public static List<WAmpPhaseXyzTransformation> GetAmpPhaseTransformation(this ForceAccelFourierSeries src) Parameters src ForceAccelFourierSeries The source force-acceleration Fourier series. Returns List<WAmpPhaseXyzTransformation> A list of frequency-based amplitude-phase transformations for the XYZ axes. Main(string[]) Main method for testing vibration analysis. public static void Main(string[] argv) Parameters argv string[] Command line arguments."
  },
  "api/Hi.Vibrations.WAmpPhase.html": {
    "href": "api/Hi.Vibrations.WAmpPhase.html",
    "title": "Class WAmpPhase | HiAPI-C# 2025",
    "summary": "Class WAmpPhase Namespace Hi.Vibrations Assembly HiMech.dll Represents amplitude and phase information with angular velocity. public class WAmpPhase : IAngularVelocityOwner Inheritance object WAmpPhase Implements IAngularVelocityOwner Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods AngularVelocityUtil.GetFrequency(IAngularVelocityOwner) AngularVelocityUtil.SetFrequency(IAngularVelocityOwner, double) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors WAmpPhase(double, AmpPhase) Initializes a new instance of the WAmpPhase class with the specified angular velocity and amplitude-phase information. public WAmpPhase(double angularVelocity, AmpPhase ampPhase) Parameters angularVelocity double The angular velocity in radians per second. ampPhase AmpPhase The amplitude and phase information. Properties AmpPhase Gets or sets the amplitude and phase information. public AmpPhase AmpPhase { get; set; } Property Value AmpPhase AngularVelocity Gets or sets the angular velocity in radians per second. public double AngularVelocity { get; set; } Property Value double Frequency Gets or sets the frequency in Hz. public double Frequency { get; set; } Property Value double"
  },
  "api/Hi.Vibrations.WAmpPhaseXyzTransformation.html": {
    "href": "api/Hi.Vibrations.WAmpPhaseXyzTransformation.html",
    "title": "Class WAmpPhaseXyzTransformation | HiAPI-C# 2025",
    "summary": "Class WAmpPhaseXyzTransformation Namespace Hi.Vibrations Assembly HiMech.dll Represents amplitude and phase information with angular velocity for XYZ transformations. public class WAmpPhaseXyzTransformation Inheritance object WAmpPhaseXyzTransformation Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors WAmpPhaseXyzTransformation(double, AmpPhase, AmpPhase, AmpPhase) Initializes a new instance of the WAmpPhaseXyzTransformation class with the specified angular velocity and amplitude-phase information for each axis. public WAmpPhaseXyzTransformation(double angularVelocity, AmpPhase ampPhaseX, AmpPhase ampPhaseY, AmpPhase ampPhaseZ) Parameters angularVelocity double The angular velocity in radians per second. ampPhaseX AmpPhase The amplitude and phase information for the X axis. ampPhaseY AmpPhase The amplitude and phase information for the Y axis. ampPhaseZ AmpPhase The amplitude and phase information for the Z axis. Properties AmpPhaseX Gets or sets the amplitude and phase information for the X axis. public AmpPhase AmpPhaseX { get; set; } Property Value AmpPhase AmpPhaseY Gets or sets the amplitude and phase information for the Y axis. public AmpPhase AmpPhaseY { get; set; } Property Value AmpPhase AmpPhaseZ Gets or sets the amplitude and phase information for the Z axis. public AmpPhase AmpPhaseZ { get; set; } Property Value AmpPhase AngularVelocity Gets or sets the angular velocity in radians per second. public double AngularVelocity { get; set; } Property Value double"
  },
  "api/Hi.Vibrations.html": {
    "href": "api/Hi.Vibrations.html",
    "title": "Namespace Hi.Vibrations | HiAPI-C# 2025",
    "summary": "Namespace Hi.Vibrations Classes AngularVelocityUtil Provides utility methods for working with angular velocity. ForceAccelAmpPhase Represents amplitude and phase information for force and acceleration in vibration analysis. ForceAccelFourierSeries Represents Fourier series data for force and acceleration measurements in three dimensions. ForceAccelShot Represents a data point containing force, acceleration, and moment measurements at a specific time. ForceAccelUtil Utility class for force and acceleration data processing. VibrationUtil Utility class for vibration analysis and processing. WAmpPhase Represents amplitude and phase information with angular velocity. WAmpPhaseXyzTransformation Represents amplitude and phase information with angular velocity for XYZ transformations. Interfaces IAngularVelocityOwner Provides functionality for objects that have an angular velocity property."
  },
  "api/Hi.WinForm.Disp.RenderingCanvas.html": {
    "href": "api/Hi.WinForm.Disp.RenderingCanvas.html",
    "title": "Class RenderingCanvas | HiAPI-C# 2025",
    "summary": "Class RenderingCanvas Namespace Hi.WinForm.Disp Assembly Hi.WinForm.dll Window Form Displayer. public class RenderingCanvas : UserControl, IDropTarget, ISynchronizeInvoke, IWin32Window, IBindableComponent, IComponent, IDisposable, IContainerControl Inheritance object MarshalByRefObject Component Control ScrollableControl ContainerControl UserControl RenderingCanvas Implements IDropTarget ISynchronizeInvoke IWin32Window IBindableComponent IComponent IDisposable IContainerControl Inherited Members UserControl.ValidateChildren() UserControl.ValidateChildren(ValidationConstraints) UserControl.OnCreateControl() UserControl.OnLoad(EventArgs) UserControl.OnResize(EventArgs) UserControl.OnMouseDown(MouseEventArgs) UserControl.AutoSize UserControl.AutoSizeMode UserControl.AutoValidate UserControl.BorderStyle UserControl.CreateParams UserControl.DefaultSize UserControl.AutoSizeChanged UserControl.AutoValidateChanged UserControl.Load ContainerControl.AdjustFormScrollbars(bool) ContainerControl.OnAutoValidateChanged(EventArgs) ContainerControl.OnFontChanged(EventArgs) ContainerControl.OnLayout(LayoutEventArgs) ContainerControl.OnMove(EventArgs) ContainerControl.OnParentChanged(EventArgs) ContainerControl.PerformAutoScale() ContainerControl.ScaleMinMaxSize(float, float, bool) ContainerControl.ProcessDialogChar(char) ContainerControl.ProcessDialogKey(Keys) ContainerControl.ProcessCmdKey(ref Message, Keys) ContainerControl.ProcessMnemonic(char) ContainerControl.ProcessTabKey(bool) ContainerControl.RescaleConstantsForDpi(int, int) ContainerControl.Select(bool, bool) ContainerControl.UpdateDefaultButton() ContainerControl.Validate() ContainerControl.Validate(bool) ContainerControl.AutoScaleDimensions ContainerControl.AutoScaleFactor ContainerControl.AutoScaleMode ContainerControl.BindingContext ContainerControl.CanEnableIme ContainerControl.ActiveControl ContainerControl.CurrentAutoScaleDimensions ContainerControl.ParentForm ScrollableControl.ScrollStateAutoScrolling ScrollableControl.ScrollStateHScrollVisible ScrollableControl.ScrollStateVScrollVisible ScrollableControl.ScrollStateUserHasScrolled ScrollableControl.ScrollStateFullDrag ScrollableControl.GetScrollState(int) ScrollableControl.OnMouseWheel(MouseEventArgs) ScrollableControl.OnRightToLeftChanged(EventArgs) ScrollableControl.OnPaintBackground(PaintEventArgs) ScrollableControl.OnPaddingChanged(EventArgs) ScrollableControl.OnVisibleChanged(EventArgs) ScrollableControl.ScaleControl(SizeF, BoundsSpecified) ScrollableControl.SetDisplayRectLocation(int, int) ScrollableControl.ScrollControlIntoView(Control) ScrollableControl.ScrollToControl(Control) ScrollableControl.OnScroll(ScrollEventArgs) ScrollableControl.SetAutoScrollMargin(int, int) ScrollableControl.SetScrollState(int, bool) ScrollableControl.AutoScroll ScrollableControl.AutoScrollMargin ScrollableControl.AutoScrollPosition ScrollableControl.AutoScrollMinSize ScrollableControl.DisplayRectangle ScrollableControl.HScroll ScrollableControl.HorizontalScroll ScrollableControl.VScroll ScrollableControl.VerticalScroll ScrollableControl.Scroll Control.GetAccessibilityObjectById(int) Control.SetAutoSizeMode(AutoSizeMode) Control.GetAutoSizeMode() Control.GetPreferredSize(Size) Control.AccessibilityNotifyClients(AccessibleEvents, int) Control.AccessibilityNotifyClients(AccessibleEvents, int, int) Control.BeginInvoke(Delegate) Control.BeginInvoke(Action) Control.BeginInvoke(Delegate, params object[]) Control.BringToFront() Control.Contains(Control) Control.CreateAccessibilityInstance() Control.CreateControlsInstance() Control.CreateGraphics() Control.CreateHandle() Control.CreateControl() Control.DefWndProc(ref Message) Control.DestroyHandle() Control.DoDragDropAsJson<T>(T, DragDropEffects) Control.DoDragDropAsJson<T>(T, DragDropEffects, Bitmap, Point, bool) Control.DoDragDrop(object, DragDropEffects) Control.DoDragDrop(object, DragDropEffects, Bitmap, Point, bool) Control.DrawToBitmap(Bitmap, Rectangle) Control.EndInvoke(IAsyncResult) Control.FindForm() Control.GetTopLevel() Control.RaiseKeyEvent(object, KeyEventArgs) Control.RaiseMouseEvent(object, MouseEventArgs) Control.Focus() Control.FromChildHandle(nint) Control.FromHandle(nint) Control.GetChildAtPoint(Point, GetChildAtPointSkip) Control.GetChildAtPoint(Point) Control.GetContainerControl() Control.GetScaledBounds(Rectangle, SizeF, BoundsSpecified) Control.GetNextControl(Control, bool) Control.GetStyle(ControlStyles) Control.Hide() Control.InitLayout() Control.Invalidate(Region) Control.Invalidate(Region, bool) Control.Invalidate() Control.Invalidate(bool) Control.Invalidate(Rectangle) Control.Invalidate(Rectangle, bool) Control.Invoke(Action) Control.Invoke(Delegate) Control.Invoke(Delegate, params object[]) Control.Invoke<T>(Func<T>) Control.InvokePaint(Control, PaintEventArgs) Control.InvokePaintBackground(Control, PaintEventArgs) Control.IsKeyLocked(Keys) Control.IsInputChar(char) Control.IsMnemonic(char, string) Control.LogicalToDeviceUnits(int) Control.LogicalToDeviceUnits(Size) Control.ScaleBitmapLogicalToDevice(ref Bitmap) Control.NotifyInvalidate(Rectangle) Control.InvokeOnClick(Control, EventArgs) Control.OnAutoSizeChanged(EventArgs) Control.OnBackColorChanged(EventArgs) Control.OnBackgroundImageChanged(EventArgs) Control.OnBackgroundImageLayoutChanged(EventArgs) Control.OnBindingContextChanged(EventArgs) Control.OnCausesValidationChanged(EventArgs) Control.OnContextMenuStripChanged(EventArgs) Control.OnCursorChanged(EventArgs) Control.OnDataContextChanged(EventArgs) Control.OnDockChanged(EventArgs) Control.OnEnabledChanged(EventArgs) Control.OnForeColorChanged(EventArgs) Control.OnNotifyMessage(Message) Control.OnParentBackColorChanged(EventArgs) Control.OnParentBackgroundImageChanged(EventArgs) Control.OnParentBindingContextChanged(EventArgs) Control.OnParentCursorChanged(EventArgs) Control.OnParentDataContextChanged(EventArgs) Control.OnParentEnabledChanged(EventArgs) Control.OnParentFontChanged(EventArgs) Control.OnParentForeColorChanged(EventArgs) Control.OnParentRightToLeftChanged(EventArgs) Control.OnParentVisibleChanged(EventArgs) Control.OnPrint(PaintEventArgs) Control.OnTabIndexChanged(EventArgs) Control.OnTabStopChanged(EventArgs) Control.OnTextChanged(EventArgs) Control.OnClick(EventArgs) Control.OnClientSizeChanged(EventArgs) Control.OnControlAdded(ControlEventArgs) Control.OnControlRemoved(ControlEventArgs) Control.OnHandleCreated(EventArgs) Control.OnLocationChanged(EventArgs) Control.OnHandleDestroyed(EventArgs) Control.OnDoubleClick(EventArgs) Control.OnDragEnter(DragEventArgs) Control.OnDragOver(DragEventArgs) Control.OnDragLeave(EventArgs) Control.OnDragDrop(DragEventArgs) Control.OnGiveFeedback(GiveFeedbackEventArgs) Control.OnEnter(EventArgs) Control.InvokeGotFocus(Control, EventArgs) Control.OnGotFocus(EventArgs) Control.OnHelpRequested(HelpEventArgs) Control.OnInvalidated(InvalidateEventArgs) Control.OnKeyDown(KeyEventArgs) Control.OnKeyPress(KeyPressEventArgs) Control.OnKeyUp(KeyEventArgs) Control.OnLeave(EventArgs) Control.InvokeLostFocus(Control, EventArgs) Control.OnLostFocus(EventArgs) Control.OnMarginChanged(EventArgs) Control.OnMouseDoubleClick(MouseEventArgs) Control.OnMouseClick(MouseEventArgs) Control.OnMouseCaptureChanged(EventArgs) Control.OnMouseEnter(EventArgs) Control.OnMouseLeave(EventArgs) Control.OnDpiChangedBeforeParent(EventArgs) Control.OnDpiChangedAfterParent(EventArgs) Control.OnMouseHover(EventArgs) Control.OnMouseMove(MouseEventArgs) Control.OnMouseUp(MouseEventArgs) Control.OnPaint(PaintEventArgs) Control.OnQueryContinueDrag(QueryContinueDragEventArgs) Control.OnRegionChanged(EventArgs) Control.OnPreviewKeyDown(PreviewKeyDownEventArgs) Control.OnSizeChanged(EventArgs) Control.OnChangeUICues(UICuesEventArgs) Control.OnStyleChanged(EventArgs) Control.OnSystemColorsChanged(EventArgs) Control.OnValidating(CancelEventArgs) Control.OnValidated(EventArgs) Control.PerformLayout() Control.PerformLayout(Control, string) Control.PointToClient(Point) Control.PointToScreen(Point) Control.PreProcessMessage(ref Message) Control.PreProcessControlMessage(ref Message) Control.ProcessKeyEventArgs(ref Message) Control.ProcessKeyMessage(ref Message) Control.ProcessKeyPreview(ref Message) Control.RaiseDragEvent(object, DragEventArgs) Control.RaisePaintEvent(object, PaintEventArgs) Control.RecreateHandle() Control.RectangleToClient(Rectangle) Control.RectangleToScreen(Rectangle) Control.ReflectMessage(nint, ref Message) Control.Refresh() Control.ResetMouseEventArgs() Control.ResetText() Control.ResumeLayout() Control.ResumeLayout(bool) Control.Scale(SizeF) Control.Select() Control.SelectNextControl(Control, bool, bool, bool, bool) Control.SendToBack() Control.SetBounds(int, int, int, int) Control.SetBounds(int, int, int, int, BoundsSpecified) Control.SetBoundsCore(int, int, int, int, BoundsSpecified) Control.SetClientSizeCore(int, int) Control.SizeFromClientSize(Size) Control.SetStyle(ControlStyles, bool) Control.SetTopLevel(bool) Control.SetVisibleCore(bool) Control.RtlTranslateAlignment(HorizontalAlignment) Control.RtlTranslateAlignment(LeftRightAlignment) Control.RtlTranslateAlignment(ContentAlignment) Control.RtlTranslateHorizontal(HorizontalAlignment) Control.RtlTranslateLeftRight(LeftRightAlignment) Control.RtlTranslateContent(ContentAlignment) Control.Show() Control.SuspendLayout() Control.Update() Control.UpdateBounds() Control.UpdateBounds(int, int, int, int) Control.UpdateBounds(int, int, int, int, int, int) Control.UpdateZOrder() Control.UpdateStyles() Control.OnImeModeChanged(EventArgs) Control.InvokeAsync(Action, CancellationToken) Control.InvokeAsync<T>(Func<T>, CancellationToken) Control.InvokeAsync(Func<CancellationToken, ValueTask>, CancellationToken) Control.InvokeAsync<T>(Func<CancellationToken, ValueTask<T>>, CancellationToken) Control.AccessibilityObject Control.AccessibleDefaultActionDescription Control.AccessibleDescription Control.AccessibleName Control.AccessibleRole Control.AllowDrop Control.Anchor Control.AutoScrollOffset Control.LayoutEngine Control.DataContext Control.BackColor Control.BackgroundImage Control.BackgroundImageLayout Control.Bottom Control.Bounds Control.CanFocus Control.CanRaiseEvents Control.CanSelect Control.Capture Control.CausesValidation Control.CheckForIllegalCrossThreadCalls Control.ClientRectangle Control.ClientSize Control.CompanyName Control.ContainsFocus Control.ContextMenuStrip Control.Controls Control.Created Control.Cursor Control.DataBindings Control.DefaultBackColor Control.DefaultCursor Control.DefaultFont Control.DefaultForeColor Control.DefaultMargin Control.DefaultMaximumSize Control.DefaultMinimumSize Control.DefaultPadding Control.DeviceDpi Control.IsDisposed Control.Disposing Control.Dock Control.DoubleBuffered Control.Enabled Control.Focused Control.Font Control.FontHeight Control.ForeColor Control.Handle Control.HasChildren Control.Height Control.IsHandleCreated Control.InvokeRequired Control.IsAccessible Control.IsAncestorSiteInDesignMode Control.IsMirrored Control.Left Control.Location Control.Margin Control.MaximumSize Control.MinimumSize Control.ModifierKeys Control.MouseButtons Control.MousePosition Control.Name Control.Parent Control.ProductName Control.ProductVersion Control.RecreatingHandle Control.Region Control.RenderRightToLeft Control.ResizeRedraw Control.Right Control.RightToLeft Control.ScaleChildren Control.Site Control.Size Control.TabIndex Control.TabStop Control.Tag Control.Text Control.Top Control.TopLevelControl Control.ShowKeyboardCues Control.ShowFocusCues Control.UseWaitCursor Control.Visible Control.Width Control.PreferredSize Control.Padding Control.DefaultImeMode Control.ImeMode Control.ImeModeBase Control.PropagatingImeMode Control.BackColorChanged Control.BackgroundImageChanged Control.BackgroundImageLayoutChanged Control.BindingContextChanged Control.CausesValidationChanged Control.ClientSizeChanged Control.ContextMenuStripChanged Control.CursorChanged Control.DockChanged Control.EnabledChanged Control.FontChanged Control.ForeColorChanged Control.LocationChanged Control.MarginChanged Control.RegionChanged Control.RightToLeftChanged Control.SizeChanged Control.TabIndexChanged Control.TabStopChanged Control.TextChanged Control.VisibleChanged Control.Click Control.ControlAdded Control.ControlRemoved Control.DataContextChanged Control.DragDrop Control.DragEnter Control.DragOver Control.DragLeave Control.GiveFeedback Control.HandleCreated Control.HandleDestroyed Control.HelpRequested Control.Invalidated Control.PaddingChanged Control.Paint Control.QueryContinueDrag Control.QueryAccessibilityHelp Control.DoubleClick Control.Enter Control.GotFocus Control.KeyDown Control.KeyPress Control.KeyUp Control.Layout Control.Leave Control.LostFocus Control.MouseClick Control.MouseDoubleClick Control.MouseCaptureChanged Control.MouseDown Control.MouseEnter Control.MouseLeave Control.DpiChangedBeforeParent Control.DpiChangedAfterParent Control.MouseHover Control.MouseMove Control.MouseUp Control.MouseWheel Control.Move Control.PreviewKeyDown Control.Resize Control.ChangeUICues Control.StyleChanged Control.SystemColorsChanged Control.Validating Control.Validated Control.ParentChanged Control.ImeModeChanged Component.Dispose() Component.GetService(Type) Component.ToString() Component.Container Component.DesignMode Component.Events Component.Disposed MarshalByRefObject.GetLifetimeService() MarshalByRefObject.InitializeLifetimeService() MarshalByRefObject.MemberwiseClone(bool) object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors RenderingCanvas(params IDisplayee[]) Ctor. public RenderingCanvas(params IDisplayee[] displayees) Parameters displayees IDisplayee[] displayees Properties DispEngine DispEngine. public DispEngine DispEngine { get; } Property Value DispEngine Methods Dispose(bool) Clean up any resources being used. protected override void Dispose(bool disposing) Parameters disposing bool true if managed resources should be disposed; otherwise, false. IsInputKey(Keys) Determines whether the specified key is a regular input key or a special key that requires preprocessing. protected override bool IsInputKey(Keys keyData) Parameters keyData Keys One of the Keys values. Returns bool true if the specified key is a regular input key; otherwise, false. WndProc(ref Message) Processes Windows messages, handling touch input and forwarding other messages to the base class. protected override void WndProc(ref Message m) Parameters m Message The Windows message to process."
  },
  "api/Hi.WinForm.Disp.RenderingForm.html": {
    "href": "api/Hi.WinForm.Disp.RenderingForm.html",
    "title": "Class RenderingForm | HiAPI-C# 2025",
    "summary": "Class RenderingForm Namespace Hi.WinForm.Disp Assembly Hi.WinForm.dll A Form contains RenderingCanvas. This class is usually used for debug due to its simplicity. public class RenderingForm : Form, IDropTarget, ISynchronizeInvoke, IWin32Window, IBindableComponent, IComponent, IDisposable, IContainerControl, IGetDispEngine Inheritance object MarshalByRefObject Component Control ScrollableControl ContainerControl Form RenderingForm Implements IDropTarget ISynchronizeInvoke IWin32Window IBindableComponent IComponent IDisposable IContainerControl IGetDispEngine Inherited Members Form.SetVisibleCore(bool) Form.OnFormCornerPreferenceChanged(EventArgs) Form.OnFormBorderColorChanged(EventArgs) Form.OnFormCaptionBackColorChanged(EventArgs) Form.OnFormCaptionTextColorChanged(EventArgs) Form.Activate() Form.ActivateMdiChild(Form) Form.AddOwnedForm(Form) Form.AdjustFormScrollbars(bool) Form.Close() Form.CreateAccessibilityInstance() Form.CreateControlsInstance() Form.CreateHandle() Form.DefWndProc(ref Message) Form.ProcessMnemonic(char) Form.CenterToParent() Form.CenterToScreen() Form.LayoutMdi(MdiLayout) Form.OnActivated(EventArgs) Form.OnBackgroundImageChanged(EventArgs) Form.OnBackgroundImageLayoutChanged(EventArgs) Form.OnFormClosing(FormClosingEventArgs) Form.OnFormClosed(FormClosedEventArgs) Form.OnCreateControl() Form.OnDeactivate(EventArgs) Form.OnEnabledChanged(EventArgs) Form.OnEnter(EventArgs) Form.OnFontChanged(EventArgs) Form.OnGotFocus(EventArgs) Form.OnHandleCreated(EventArgs) Form.OnHandleDestroyed(EventArgs) Form.OnHelpButtonClicked(CancelEventArgs) Form.OnLayout(LayoutEventArgs) Form.OnLoad(EventArgs) Form.OnMaximizedBoundsChanged(EventArgs) Form.OnMaximumSizeChanged(EventArgs) Form.OnMinimumSizeChanged(EventArgs) Form.OnInputLanguageChanged(InputLanguageChangedEventArgs) Form.OnInputLanguageChanging(InputLanguageChangingEventArgs) Form.OnVisibleChanged(EventArgs) Form.OnMdiChildActivate(EventArgs) Form.OnMenuStart(EventArgs) Form.OnMenuComplete(EventArgs) Form.OnPaint(PaintEventArgs) Form.OnResize(EventArgs) Form.OnDpiChanged(DpiChangedEventArgs) Form.OnGetDpiScaledSize(int, int, ref Size) Form.OnRightToLeftLayoutChanged(EventArgs) Form.OnShown(EventArgs) Form.OnTextChanged(EventArgs) Form.ProcessCmdKey(ref Message, Keys) Form.ProcessDialogKey(Keys) Form.ProcessDialogChar(char) Form.ProcessKeyPreview(ref Message) Form.ProcessTabKey(bool) Form.RemoveOwnedForm(Form) Form.Select(bool, bool) Form.ScaleMinMaxSize(float, float, bool) Form.GetScaledBounds(Rectangle, SizeF, BoundsSpecified) Form.ScaleControl(SizeF, BoundsSpecified) Form.SetBoundsCore(int, int, int, int, BoundsSpecified) Form.SetClientSizeCore(int, int) Form.SetDesktopBounds(int, int, int, int) Form.SetDesktopLocation(int, int) Form.Show(IWin32Window) Form.ShowAsync(IWin32Window) Form.ShowDialog() Form.ShowDialog(IWin32Window) Form.ShowDialogAsync() Form.ShowDialogAsync(IWin32Window) Form.ToString() Form.UpdateDefaultButton() Form.OnResizeBegin(EventArgs) Form.OnResizeEnd(EventArgs) Form.OnStyleChanged(EventArgs) Form.ValidateChildren() Form.ValidateChildren(ValidationConstraints) Form.WndProc(ref Message) Form.AcceptButton Form.ActiveForm Form.ActiveMdiChild Form.AllowTransparency Form.AutoScroll Form.AutoSize Form.AutoSizeMode Form.AutoValidate Form.BackColor Form.FormBorderStyle Form.CancelButton Form.ClientSize Form.ControlBox Form.CreateParams Form.DefaultImeMode Form.DefaultSize Form.DesktopBounds Form.DesktopLocation Form.DialogResult Form.HelpButton Form.Icon Form.IsMdiChild Form.IsMdiContainer Form.IsRestrictedWindow Form.KeyPreview Form.Location Form.MaximizedBounds Form.MaximumSize Form.MainMenuStrip Form.MinimumSize Form.MaximizeBox Form.MdiChildren Form.MdiChildrenMinimizedAnchorBottom Form.MdiParent Form.MinimizeBox Form.Modal Form.Opacity Form.OwnedForms Form.Owner Form.RestoreBounds Form.RightToLeftLayout Form.FormScreenCaptureMode Form.ShowInTaskbar Form.ShowIcon Form.ShowWithoutActivation Form.Size Form.SizeGripStyle Form.StartPosition Form.Text Form.TopLevel Form.TopMost Form.TransparencyKey Form.FormCornerPreference Form.FormBorderColor Form.FormCaptionBackColor Form.FormCaptionTextColor Form.WindowState Form.AutoSizeChanged Form.AutoValidateChanged Form.HelpButtonClicked Form.MaximizedBoundsChanged Form.MaximumSizeChanged Form.MinimumSizeChanged Form.Activated Form.Deactivate Form.FormClosing Form.FormBorderColorChanged Form.FormCaptionBackColorChanged Form.FormCaptionTextColorChanged Form.FormCornerPreferenceChanged Form.FormClosed Form.Load Form.MdiChildActivate Form.MenuComplete Form.MenuStart Form.InputLanguageChanged Form.InputLanguageChanging Form.RightToLeftLayoutChanged Form.Shown Form.DpiChanged Form.ResizeBegin Form.ResizeEnd ContainerControl.OnAutoValidateChanged(EventArgs) ContainerControl.OnMove(EventArgs) ContainerControl.OnParentChanged(EventArgs) ContainerControl.PerformAutoScale() ContainerControl.RescaleConstantsForDpi(int, int) ContainerControl.Validate() ContainerControl.Validate(bool) ContainerControl.AutoScaleDimensions ContainerControl.AutoScaleFactor ContainerControl.AutoScaleMode ContainerControl.BindingContext ContainerControl.CanEnableIme ContainerControl.ActiveControl ContainerControl.CurrentAutoScaleDimensions ContainerControl.ParentForm ScrollableControl.ScrollStateAutoScrolling ScrollableControl.ScrollStateHScrollVisible ScrollableControl.ScrollStateVScrollVisible ScrollableControl.ScrollStateUserHasScrolled ScrollableControl.ScrollStateFullDrag ScrollableControl.GetScrollState(int) ScrollableControl.OnMouseWheel(MouseEventArgs) ScrollableControl.OnRightToLeftChanged(EventArgs) ScrollableControl.OnPaintBackground(PaintEventArgs) ScrollableControl.OnPaddingChanged(EventArgs) ScrollableControl.SetDisplayRectLocation(int, int) ScrollableControl.ScrollControlIntoView(Control) ScrollableControl.ScrollToControl(Control) ScrollableControl.OnScroll(ScrollEventArgs) ScrollableControl.SetAutoScrollMargin(int, int) ScrollableControl.SetScrollState(int, bool) ScrollableControl.AutoScrollMargin ScrollableControl.AutoScrollPosition ScrollableControl.AutoScrollMinSize ScrollableControl.DisplayRectangle ScrollableControl.HScroll ScrollableControl.HorizontalScroll ScrollableControl.VScroll ScrollableControl.VerticalScroll ScrollableControl.Scroll Control.GetAccessibilityObjectById(int) Control.SetAutoSizeMode(AutoSizeMode) Control.GetAutoSizeMode() Control.GetPreferredSize(Size) Control.AccessibilityNotifyClients(AccessibleEvents, int) Control.AccessibilityNotifyClients(AccessibleEvents, int, int) Control.BeginInvoke(Delegate) Control.BeginInvoke(Action) Control.BeginInvoke(Delegate, params object[]) Control.BringToFront() Control.Contains(Control) Control.CreateGraphics() Control.CreateControl() Control.DestroyHandle() Control.DoDragDropAsJson<T>(T, DragDropEffects) Control.DoDragDropAsJson<T>(T, DragDropEffects, Bitmap, Point, bool) Control.DoDragDrop(object, DragDropEffects) Control.DoDragDrop(object, DragDropEffects, Bitmap, Point, bool) Control.DrawToBitmap(Bitmap, Rectangle) Control.EndInvoke(IAsyncResult) Control.FindForm() Control.GetTopLevel() Control.RaiseKeyEvent(object, KeyEventArgs) Control.RaiseMouseEvent(object, MouseEventArgs) Control.Focus() Control.FromChildHandle(nint) Control.FromHandle(nint) Control.GetChildAtPoint(Point, GetChildAtPointSkip) Control.GetChildAtPoint(Point) Control.GetContainerControl() Control.GetNextControl(Control, bool) Control.GetStyle(ControlStyles) Control.Hide() Control.InitLayout() Control.Invalidate(Region) Control.Invalidate(Region, bool) Control.Invalidate() Control.Invalidate(bool) Control.Invalidate(Rectangle) Control.Invalidate(Rectangle, bool) Control.Invoke(Action) Control.Invoke(Delegate) Control.Invoke(Delegate, params object[]) Control.Invoke<T>(Func<T>) Control.InvokePaint(Control, PaintEventArgs) Control.InvokePaintBackground(Control, PaintEventArgs) Control.IsKeyLocked(Keys) Control.IsInputChar(char) Control.IsInputKey(Keys) Control.IsMnemonic(char, string) Control.LogicalToDeviceUnits(int) Control.LogicalToDeviceUnits(Size) Control.ScaleBitmapLogicalToDevice(ref Bitmap) Control.NotifyInvalidate(Rectangle) Control.InvokeOnClick(Control, EventArgs) Control.OnAutoSizeChanged(EventArgs) Control.OnBackColorChanged(EventArgs) Control.OnBindingContextChanged(EventArgs) Control.OnCausesValidationChanged(EventArgs) Control.OnContextMenuStripChanged(EventArgs) Control.OnCursorChanged(EventArgs) Control.OnDataContextChanged(EventArgs) Control.OnDockChanged(EventArgs) Control.OnForeColorChanged(EventArgs) Control.OnNotifyMessage(Message) Control.OnParentBackColorChanged(EventArgs) Control.OnParentBackgroundImageChanged(EventArgs) Control.OnParentBindingContextChanged(EventArgs) Control.OnParentCursorChanged(EventArgs) Control.OnParentDataContextChanged(EventArgs) Control.OnParentEnabledChanged(EventArgs) Control.OnParentFontChanged(EventArgs) Control.OnParentForeColorChanged(EventArgs) Control.OnParentRightToLeftChanged(EventArgs) Control.OnParentVisibleChanged(EventArgs) Control.OnPrint(PaintEventArgs) Control.OnTabIndexChanged(EventArgs) Control.OnTabStopChanged(EventArgs) Control.OnClick(EventArgs) Control.OnClientSizeChanged(EventArgs) Control.OnControlAdded(ControlEventArgs) Control.OnControlRemoved(ControlEventArgs) Control.OnLocationChanged(EventArgs) Control.OnDoubleClick(EventArgs) Control.OnDragEnter(DragEventArgs) Control.OnDragOver(DragEventArgs) Control.OnDragLeave(EventArgs) Control.OnDragDrop(DragEventArgs) Control.OnGiveFeedback(GiveFeedbackEventArgs) Control.InvokeGotFocus(Control, EventArgs) Control.OnHelpRequested(HelpEventArgs) Control.OnInvalidated(InvalidateEventArgs) Control.OnKeyDown(KeyEventArgs) Control.OnKeyPress(KeyPressEventArgs) Control.OnKeyUp(KeyEventArgs) Control.OnLeave(EventArgs) Control.InvokeLostFocus(Control, EventArgs) Control.OnLostFocus(EventArgs) Control.OnMarginChanged(EventArgs) Control.OnMouseDoubleClick(MouseEventArgs) Control.OnMouseClick(MouseEventArgs) Control.OnMouseCaptureChanged(EventArgs) Control.OnMouseDown(MouseEventArgs) Control.OnMouseEnter(EventArgs) Control.OnMouseLeave(EventArgs) Control.OnDpiChangedBeforeParent(EventArgs) Control.OnDpiChangedAfterParent(EventArgs) Control.OnMouseHover(EventArgs) Control.OnMouseMove(MouseEventArgs) Control.OnMouseUp(MouseEventArgs) Control.OnQueryContinueDrag(QueryContinueDragEventArgs) Control.OnRegionChanged(EventArgs) Control.OnPreviewKeyDown(PreviewKeyDownEventArgs) Control.OnSizeChanged(EventArgs) Control.OnChangeUICues(UICuesEventArgs) Control.OnSystemColorsChanged(EventArgs) Control.OnValidating(CancelEventArgs) Control.OnValidated(EventArgs) Control.PerformLayout() Control.PerformLayout(Control, string) Control.PointToClient(Point) Control.PointToScreen(Point) Control.PreProcessMessage(ref Message) Control.PreProcessControlMessage(ref Message) Control.ProcessKeyEventArgs(ref Message) Control.ProcessKeyMessage(ref Message) Control.RaiseDragEvent(object, DragEventArgs) Control.RaisePaintEvent(object, PaintEventArgs) Control.RecreateHandle() Control.RectangleToClient(Rectangle) Control.RectangleToScreen(Rectangle) Control.ReflectMessage(nint, ref Message) Control.Refresh() Control.ResetMouseEventArgs() Control.ResetText() Control.ResumeLayout() Control.ResumeLayout(bool) Control.Scale(SizeF) Control.Select() Control.SelectNextControl(Control, bool, bool, bool, bool) Control.SendToBack() Control.SetBounds(int, int, int, int) Control.SetBounds(int, int, int, int, BoundsSpecified) Control.SizeFromClientSize(Size) Control.SetStyle(ControlStyles, bool) Control.SetTopLevel(bool) Control.RtlTranslateAlignment(HorizontalAlignment) Control.RtlTranslateAlignment(LeftRightAlignment) Control.RtlTranslateAlignment(ContentAlignment) Control.RtlTranslateHorizontal(HorizontalAlignment) Control.RtlTranslateLeftRight(LeftRightAlignment) Control.RtlTranslateContent(ContentAlignment) Control.Show() Control.SuspendLayout() Control.Update() Control.UpdateBounds() Control.UpdateBounds(int, int, int, int) Control.UpdateBounds(int, int, int, int, int, int) Control.UpdateZOrder() Control.UpdateStyles() Control.OnImeModeChanged(EventArgs) Control.InvokeAsync(Action, CancellationToken) Control.InvokeAsync<T>(Func<T>, CancellationToken) Control.InvokeAsync(Func<CancellationToken, ValueTask>, CancellationToken) Control.InvokeAsync<T>(Func<CancellationToken, ValueTask<T>>, CancellationToken) Control.AccessibilityObject Control.AccessibleDefaultActionDescription Control.AccessibleDescription Control.AccessibleName Control.AccessibleRole Control.AllowDrop Control.Anchor Control.AutoScrollOffset Control.LayoutEngine Control.DataContext Control.BackgroundImage Control.BackgroundImageLayout Control.Bottom Control.Bounds Control.CanFocus Control.CanRaiseEvents Control.CanSelect Control.Capture Control.CausesValidation Control.CheckForIllegalCrossThreadCalls Control.ClientRectangle Control.CompanyName Control.ContainsFocus Control.ContextMenuStrip Control.Controls Control.Created Control.Cursor Control.DataBindings Control.DefaultBackColor Control.DefaultCursor Control.DefaultFont Control.DefaultForeColor Control.DefaultMargin Control.DefaultMaximumSize Control.DefaultMinimumSize Control.DefaultPadding Control.DeviceDpi Control.IsDisposed Control.Disposing Control.Dock Control.DoubleBuffered Control.Enabled Control.Focused Control.Font Control.FontHeight Control.ForeColor Control.Handle Control.HasChildren Control.Height Control.IsHandleCreated Control.InvokeRequired Control.IsAccessible Control.IsAncestorSiteInDesignMode Control.IsMirrored Control.Left Control.Margin Control.ModifierKeys Control.MouseButtons Control.MousePosition Control.Name Control.Parent Control.ProductName Control.ProductVersion Control.RecreatingHandle Control.Region Control.RenderRightToLeft Control.ResizeRedraw Control.Right Control.RightToLeft Control.ScaleChildren Control.Site Control.TabIndex Control.TabStop Control.Tag Control.Top Control.TopLevelControl Control.ShowKeyboardCues Control.ShowFocusCues Control.UseWaitCursor Control.Visible Control.Width Control.PreferredSize Control.Padding Control.ImeMode Control.ImeModeBase Control.PropagatingImeMode Control.BackColorChanged Control.BackgroundImageChanged Control.BackgroundImageLayoutChanged Control.BindingContextChanged Control.CausesValidationChanged Control.ClientSizeChanged Control.ContextMenuStripChanged Control.CursorChanged Control.DockChanged Control.EnabledChanged Control.FontChanged Control.ForeColorChanged Control.LocationChanged Control.MarginChanged Control.RegionChanged Control.RightToLeftChanged Control.SizeChanged Control.TabIndexChanged Control.TabStopChanged Control.TextChanged Control.VisibleChanged Control.Click Control.ControlAdded Control.ControlRemoved Control.DataContextChanged Control.DragDrop Control.DragEnter Control.DragOver Control.DragLeave Control.GiveFeedback Control.HandleCreated Control.HandleDestroyed Control.HelpRequested Control.Invalidated Control.PaddingChanged Control.Paint Control.QueryContinueDrag Control.QueryAccessibilityHelp Control.DoubleClick Control.Enter Control.GotFocus Control.KeyDown Control.KeyPress Control.KeyUp Control.Layout Control.Leave Control.LostFocus Control.MouseClick Control.MouseDoubleClick Control.MouseCaptureChanged Control.MouseDown Control.MouseEnter Control.MouseLeave Control.DpiChangedBeforeParent Control.DpiChangedAfterParent Control.MouseHover Control.MouseMove Control.MouseUp Control.MouseWheel Control.Move Control.PreviewKeyDown Control.Resize Control.ChangeUICues Control.StyleChanged Control.SystemColorsChanged Control.Validating Control.Validated Control.ParentChanged Control.ImeModeChanged Component.Dispose() Component.GetService(Type) Component.Container Component.DesignMode Component.Events Component.Disposed MarshalByRefObject.GetLifetimeService() MarshalByRefObject.InitializeLifetimeService() MarshalByRefObject.MemberwiseClone(bool) object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Properties Displayee Gets or sets the displayee object for rendering. public IDisplayee Displayee { get; set; } Property Value IDisplayee DisplayerMap See Call(string, params IDisplayee[]) to get the information. public static ConcurrentDictionary<string, RenderingForm> DisplayerMap { get; } Property Value ConcurrentDictionary<string, RenderingForm> RenderingCanvas The contained RenderingCanvas. public RenderingCanvas RenderingCanvas { get; } Property Value RenderingCanvas Methods Call(string, params IDisplayee[]) Create and obtain a RenderingForm if the key has not existed; Otherwise, the old one is obtained. displayees are set to the obtained RenderingForm. The dictionary of this function is DisplayerMap. public static RenderingForm Call(string key, params IDisplayee[] displayees) Parameters key string key displayees IDisplayee[] The displayees set to the obtained RenderingForm. Returns RenderingForm A RenderingForm obtained by the key. Dispose(bool) Clean up any resources being used. protected override void Dispose(bool disposing) Parameters disposing bool true if managed resources should be disposed; otherwise, false. GetDispEngine() Get DispEngine. public DispEngine GetDispEngine() Returns DispEngine DispEngine"
  },
  "api/Hi.WinForm.Disp.html": {
    "href": "api/Hi.WinForm.Disp.html",
    "title": "Namespace Hi.WinForm.Disp | HiAPI-C# 2025",
    "summary": "Namespace Hi.WinForm.Disp Classes RenderingCanvas Window Form Displayer. RenderingForm A Form contains RenderingCanvas. This class is usually used for debug due to its simplicity."
  },
  "api/Hi.WpfPlus.Disp.RenderingCanvas.html": {
    "href": "api/Hi.WpfPlus.Disp.RenderingCanvas.html",
    "title": "Class RenderingCanvas | HiAPI-C# 2025",
    "summary": "Class RenderingCanvas Namespace Hi.WpfPlus.Disp Assembly Hi.WpfPlus.dll Provides a WPF rendering canvas for 3D visualization of HiAPI components. Handles user interactions, rendering, and integration with the DispEngine system. public class RenderingCanvas : UserControl, IAnimatable, ISupportInitialize, IFrameworkInputElement, IInputElement, IQueryAmbient, IAddChild, IDisposable Inheritance object DispatcherObject DependencyObject Visual UIElement FrameworkElement Control ContentControl UserControl RenderingCanvas Implements IAnimatable ISupportInitialize IFrameworkInputElement IInputElement IQueryAmbient IAddChild IDisposable Inherited Members UserControl.OnCreateAutomationPeer() ContentControl.ContentProperty ContentControl.ContentStringFormatProperty ContentControl.ContentTemplateProperty ContentControl.ContentTemplateSelectorProperty ContentControl.HasContentProperty ContentControl.AddChild(object) ContentControl.AddText(string) ContentControl.OnContentChanged(object, object) ContentControl.OnContentStringFormatChanged(string, string) ContentControl.OnContentTemplateChanged(DataTemplate, DataTemplate) ContentControl.OnContentTemplateSelectorChanged(DataTemplateSelector, DataTemplateSelector) ContentControl.Content ContentControl.ContentStringFormat ContentControl.ContentTemplate ContentControl.ContentTemplateSelector ContentControl.HasContent ContentControl.LogicalChildren Control.BackgroundProperty Control.BorderBrushProperty Control.BorderThicknessProperty Control.FontFamilyProperty Control.FontSizeProperty Control.FontStretchProperty Control.FontStyleProperty Control.FontWeightProperty Control.ForegroundProperty Control.HorizontalContentAlignmentProperty Control.IsTabStopProperty Control.MouseDoubleClickEvent Control.PaddingProperty Control.PreviewMouseDoubleClickEvent Control.TabIndexProperty Control.TemplateProperty Control.VerticalContentAlignmentProperty Control.ArrangeOverride(Size) Control.MeasureOverride(Size) Control.OnMouseDoubleClick(MouseButtonEventArgs) Control.OnPreviewMouseDoubleClick(MouseButtonEventArgs) Control.OnTemplateChanged(ControlTemplate, ControlTemplate) Control.ToString() Control.Background Control.BorderBrush Control.BorderThickness Control.FontFamily Control.FontSize Control.FontStretch Control.FontStyle Control.FontWeight Control.Foreground Control.HandlesScrolling Control.HorizontalContentAlignment Control.IsTabStop Control.Padding Control.TabIndex Control.Template Control.VerticalContentAlignment Control.MouseDoubleClick Control.PreviewMouseDoubleClick FrameworkElement.ActualHeightProperty FrameworkElement.ActualWidthProperty FrameworkElement.BindingGroupProperty FrameworkElement.ContextMenuClosingEvent FrameworkElement.ContextMenuOpeningEvent FrameworkElement.ContextMenuProperty FrameworkElement.CursorProperty FrameworkElement.DataContextProperty FrameworkElement.DefaultStyleKeyProperty FrameworkElement.FlowDirectionProperty FrameworkElement.FocusVisualStyleProperty FrameworkElement.ForceCursorProperty FrameworkElement.HeightProperty FrameworkElement.HorizontalAlignmentProperty FrameworkElement.InputScopeProperty FrameworkElement.LanguageProperty FrameworkElement.LayoutTransformProperty FrameworkElement.LoadedEvent FrameworkElement.MarginProperty FrameworkElement.MaxHeightProperty FrameworkElement.MaxWidthProperty FrameworkElement.MinHeightProperty FrameworkElement.MinWidthProperty FrameworkElement.NameProperty FrameworkElement.OverridesDefaultStyleProperty FrameworkElement.RequestBringIntoViewEvent FrameworkElement.SizeChangedEvent FrameworkElement.StyleProperty FrameworkElement.TagProperty FrameworkElement.ToolTipClosingEvent FrameworkElement.ToolTipOpeningEvent FrameworkElement.ToolTipProperty FrameworkElement.UnloadedEvent FrameworkElement.UseLayoutRoundingProperty FrameworkElement.VerticalAlignmentProperty FrameworkElement.WidthProperty FrameworkElement.AddLogicalChild(object) FrameworkElement.ApplyTemplate() FrameworkElement.ArrangeCore(Rect) FrameworkElement.BeginInit() FrameworkElement.BeginStoryboard(Storyboard) FrameworkElement.BeginStoryboard(Storyboard, HandoffBehavior) FrameworkElement.BeginStoryboard(Storyboard, HandoffBehavior, bool) FrameworkElement.BringIntoView() FrameworkElement.BringIntoView(Rect) FrameworkElement.EndInit() FrameworkElement.FindName(string) FrameworkElement.FindResource(object) FrameworkElement.GetBindingExpression(DependencyProperty) FrameworkElement.GetFlowDirection(DependencyObject) FrameworkElement.GetLayoutClip(Size) FrameworkElement.GetTemplateChild(string) FrameworkElement.GetUIParentCore() FrameworkElement.GetVisualChild(int) FrameworkElement.MeasureCore(Size) FrameworkElement.MoveFocus(TraversalRequest) FrameworkElement.OnApplyTemplate() FrameworkElement.OnContextMenuClosing(ContextMenuEventArgs) FrameworkElement.OnContextMenuOpening(ContextMenuEventArgs) FrameworkElement.OnGotFocus(RoutedEventArgs) FrameworkElement.OnInitialized(EventArgs) FrameworkElement.OnPropertyChanged(DependencyPropertyChangedEventArgs) FrameworkElement.OnRenderSizeChanged(SizeChangedInfo) FrameworkElement.OnStyleChanged(Style, Style) FrameworkElement.OnToolTipClosing(ToolTipEventArgs) FrameworkElement.OnToolTipOpening(ToolTipEventArgs) FrameworkElement.OnVisualParentChanged(DependencyObject) FrameworkElement.ParentLayoutInvalidated(UIElement) FrameworkElement.PredictFocus(FocusNavigationDirection) FrameworkElement.RegisterName(string, object) FrameworkElement.RemoveLogicalChild(object) FrameworkElement.SetBinding(DependencyProperty, string) FrameworkElement.SetBinding(DependencyProperty, BindingBase) FrameworkElement.SetFlowDirection(DependencyObject, FlowDirection) FrameworkElement.SetResourceReference(DependencyProperty, object) FrameworkElement.TryFindResource(object) FrameworkElement.UnregisterName(string) FrameworkElement.UpdateDefaultStyle() FrameworkElement.ActualHeight FrameworkElement.ActualWidth FrameworkElement.BindingGroup FrameworkElement.ContextMenu FrameworkElement.Cursor FrameworkElement.DataContext FrameworkElement.DefaultStyleKey FrameworkElement.FlowDirection FrameworkElement.FocusVisualStyle FrameworkElement.ForceCursor FrameworkElement.Height FrameworkElement.HorizontalAlignment FrameworkElement.InheritanceBehavior FrameworkElement.InputScope FrameworkElement.IsInitialized FrameworkElement.IsLoaded FrameworkElement.Language FrameworkElement.LayoutTransform FrameworkElement.Margin FrameworkElement.MaxHeight FrameworkElement.MaxWidth FrameworkElement.MinHeight FrameworkElement.MinWidth FrameworkElement.Name FrameworkElement.OverridesDefaultStyle FrameworkElement.Parent FrameworkElement.Resources FrameworkElement.Style FrameworkElement.Tag FrameworkElement.TemplatedParent FrameworkElement.ToolTip FrameworkElement.Triggers FrameworkElement.UseLayoutRounding FrameworkElement.VerticalAlignment FrameworkElement.VisualChildrenCount FrameworkElement.Width FrameworkElement.ContextMenuClosing FrameworkElement.ContextMenuOpening FrameworkElement.DataContextChanged FrameworkElement.Initialized FrameworkElement.Loaded FrameworkElement.RequestBringIntoView FrameworkElement.SizeChanged FrameworkElement.SourceUpdated FrameworkElement.TargetUpdated FrameworkElement.ToolTipClosing FrameworkElement.ToolTipOpening FrameworkElement.Unloaded UIElement.AllowDropProperty UIElement.AreAnyTouchesCapturedProperty UIElement.AreAnyTouchesCapturedWithinProperty UIElement.AreAnyTouchesDirectlyOverProperty UIElement.AreAnyTouchesOverProperty UIElement.BitmapEffectInputProperty UIElement.BitmapEffectProperty UIElement.CacheModeProperty UIElement.ClipProperty UIElement.ClipToBoundsProperty UIElement.DragEnterEvent UIElement.DragLeaveEvent UIElement.DragOverEvent UIElement.DropEvent UIElement.EffectProperty UIElement.FocusableProperty UIElement.GiveFeedbackEvent UIElement.GotFocusEvent UIElement.GotKeyboardFocusEvent UIElement.GotMouseCaptureEvent UIElement.GotStylusCaptureEvent UIElement.GotTouchCaptureEvent UIElement.IsEnabledProperty UIElement.IsFocusedProperty UIElement.IsHitTestVisibleProperty UIElement.IsKeyboardFocusedProperty UIElement.IsKeyboardFocusWithinProperty UIElement.IsManipulationEnabledProperty UIElement.IsMouseCapturedProperty UIElement.IsMouseCaptureWithinProperty UIElement.IsMouseDirectlyOverProperty UIElement.IsMouseOverProperty UIElement.IsStylusCapturedProperty UIElement.IsStylusCaptureWithinProperty UIElement.IsStylusDirectlyOverProperty UIElement.IsStylusOverProperty UIElement.IsVisibleProperty UIElement.KeyDownEvent UIElement.KeyUpEvent UIElement.LostFocusEvent UIElement.LostKeyboardFocusEvent UIElement.LostMouseCaptureEvent UIElement.LostStylusCaptureEvent UIElement.LostTouchCaptureEvent UIElement.ManipulationBoundaryFeedbackEvent UIElement.ManipulationCompletedEvent UIElement.ManipulationDeltaEvent UIElement.ManipulationInertiaStartingEvent UIElement.ManipulationStartedEvent UIElement.ManipulationStartingEvent UIElement.MouseDownEvent UIElement.MouseEnterEvent UIElement.MouseLeaveEvent UIElement.MouseLeftButtonDownEvent UIElement.MouseLeftButtonUpEvent UIElement.MouseMoveEvent UIElement.MouseRightButtonDownEvent UIElement.MouseRightButtonUpEvent UIElement.MouseUpEvent UIElement.MouseWheelEvent UIElement.OpacityMaskProperty UIElement.OpacityProperty UIElement.PreviewDragEnterEvent UIElement.PreviewDragLeaveEvent UIElement.PreviewDragOverEvent UIElement.PreviewDropEvent UIElement.PreviewGiveFeedbackEvent UIElement.PreviewGotKeyboardFocusEvent UIElement.PreviewKeyDownEvent UIElement.PreviewKeyUpEvent UIElement.PreviewLostKeyboardFocusEvent UIElement.PreviewMouseDownEvent UIElement.PreviewMouseLeftButtonDownEvent UIElement.PreviewMouseLeftButtonUpEvent UIElement.PreviewMouseMoveEvent UIElement.PreviewMouseRightButtonDownEvent UIElement.PreviewMouseRightButtonUpEvent UIElement.PreviewMouseUpEvent UIElement.PreviewMouseWheelEvent UIElement.PreviewQueryContinueDragEvent UIElement.PreviewStylusButtonDownEvent UIElement.PreviewStylusButtonUpEvent UIElement.PreviewStylusDownEvent UIElement.PreviewStylusInAirMoveEvent UIElement.PreviewStylusInRangeEvent UIElement.PreviewStylusMoveEvent UIElement.PreviewStylusOutOfRangeEvent UIElement.PreviewStylusSystemGestureEvent UIElement.PreviewStylusUpEvent UIElement.PreviewTextInputEvent UIElement.PreviewTouchDownEvent UIElement.PreviewTouchMoveEvent UIElement.PreviewTouchUpEvent UIElement.QueryContinueDragEvent UIElement.QueryCursorEvent UIElement.RenderTransformOriginProperty UIElement.RenderTransformProperty UIElement.SnapsToDevicePixelsProperty UIElement.StylusButtonDownEvent UIElement.StylusButtonUpEvent UIElement.StylusDownEvent UIElement.StylusEnterEvent UIElement.StylusInAirMoveEvent UIElement.StylusInRangeEvent UIElement.StylusLeaveEvent UIElement.StylusMoveEvent UIElement.StylusOutOfRangeEvent UIElement.StylusSystemGestureEvent UIElement.StylusUpEvent UIElement.TextInputEvent UIElement.TouchDownEvent UIElement.TouchEnterEvent UIElement.TouchLeaveEvent UIElement.TouchMoveEvent UIElement.TouchUpEvent UIElement.UidProperty UIElement.VisibilityProperty UIElement.AddHandler(RoutedEvent, Delegate) UIElement.AddHandler(RoutedEvent, Delegate, bool) UIElement.AddToEventRoute(EventRoute, RoutedEventArgs) UIElement.ApplyAnimationClock(DependencyProperty, AnimationClock) UIElement.ApplyAnimationClock(DependencyProperty, AnimationClock, HandoffBehavior) UIElement.Arrange(Rect) UIElement.BeginAnimation(DependencyProperty, AnimationTimeline) UIElement.BeginAnimation(DependencyProperty, AnimationTimeline, HandoffBehavior) UIElement.CaptureMouse() UIElement.CaptureStylus() UIElement.CaptureTouch(TouchDevice) UIElement.Focus() UIElement.GetAnimationBaseValue(DependencyProperty) UIElement.HitTestCore(GeometryHitTestParameters) UIElement.HitTestCore(PointHitTestParameters) UIElement.InputHitTest(Point) UIElement.InvalidateArrange() UIElement.InvalidateMeasure() UIElement.InvalidateVisual() UIElement.Measure(Size) UIElement.OnAccessKey(AccessKeyEventArgs) UIElement.OnChildDesiredSizeChanged(UIElement) UIElement.OnDragEnter(DragEventArgs) UIElement.OnDragLeave(DragEventArgs) UIElement.OnDragOver(DragEventArgs) UIElement.OnDrop(DragEventArgs) UIElement.OnGiveFeedback(GiveFeedbackEventArgs) UIElement.OnGotKeyboardFocus(KeyboardFocusChangedEventArgs) UIElement.OnGotMouseCapture(MouseEventArgs) UIElement.OnGotStylusCapture(StylusEventArgs) UIElement.OnGotTouchCapture(TouchEventArgs) UIElement.OnIsKeyboardFocusedChanged(DependencyPropertyChangedEventArgs) UIElement.OnIsKeyboardFocusWithinChanged(DependencyPropertyChangedEventArgs) UIElement.OnIsMouseCapturedChanged(DependencyPropertyChangedEventArgs) UIElement.OnIsMouseCaptureWithinChanged(DependencyPropertyChangedEventArgs) UIElement.OnIsMouseDirectlyOverChanged(DependencyPropertyChangedEventArgs) UIElement.OnIsStylusCapturedChanged(DependencyPropertyChangedEventArgs) UIElement.OnIsStylusCaptureWithinChanged(DependencyPropertyChangedEventArgs) UIElement.OnIsStylusDirectlyOverChanged(DependencyPropertyChangedEventArgs) UIElement.OnKeyDown(KeyEventArgs) UIElement.OnKeyUp(KeyEventArgs) UIElement.OnLostFocus(RoutedEventArgs) UIElement.OnLostKeyboardFocus(KeyboardFocusChangedEventArgs) UIElement.OnLostMouseCapture(MouseEventArgs) UIElement.OnLostStylusCapture(StylusEventArgs) UIElement.OnLostTouchCapture(TouchEventArgs) UIElement.OnManipulationBoundaryFeedback(ManipulationBoundaryFeedbackEventArgs) UIElement.OnManipulationCompleted(ManipulationCompletedEventArgs) UIElement.OnManipulationDelta(ManipulationDeltaEventArgs) UIElement.OnManipulationInertiaStarting(ManipulationInertiaStartingEventArgs) UIElement.OnManipulationStarted(ManipulationStartedEventArgs) UIElement.OnManipulationStarting(ManipulationStartingEventArgs) UIElement.OnMouseDown(MouseButtonEventArgs) UIElement.OnMouseEnter(MouseEventArgs) UIElement.OnMouseLeave(MouseEventArgs) UIElement.OnMouseLeftButtonDown(MouseButtonEventArgs) UIElement.OnMouseLeftButtonUp(MouseButtonEventArgs) UIElement.OnMouseMove(MouseEventArgs) UIElement.OnMouseRightButtonDown(MouseButtonEventArgs) UIElement.OnMouseRightButtonUp(MouseButtonEventArgs) UIElement.OnMouseUp(MouseButtonEventArgs) UIElement.OnMouseWheel(MouseWheelEventArgs) UIElement.OnPreviewDragEnter(DragEventArgs) UIElement.OnPreviewDragLeave(DragEventArgs) UIElement.OnPreviewDragOver(DragEventArgs) UIElement.OnPreviewDrop(DragEventArgs) UIElement.OnPreviewGiveFeedback(GiveFeedbackEventArgs) UIElement.OnPreviewGotKeyboardFocus(KeyboardFocusChangedEventArgs) UIElement.OnPreviewKeyDown(KeyEventArgs) UIElement.OnPreviewKeyUp(KeyEventArgs) UIElement.OnPreviewLostKeyboardFocus(KeyboardFocusChangedEventArgs) UIElement.OnPreviewMouseDown(MouseButtonEventArgs) UIElement.OnPreviewMouseLeftButtonDown(MouseButtonEventArgs) UIElement.OnPreviewMouseLeftButtonUp(MouseButtonEventArgs) UIElement.OnPreviewMouseMove(MouseEventArgs) UIElement.OnPreviewMouseRightButtonDown(MouseButtonEventArgs) UIElement.OnPreviewMouseRightButtonUp(MouseButtonEventArgs) UIElement.OnPreviewMouseUp(MouseButtonEventArgs) UIElement.OnPreviewMouseWheel(MouseWheelEventArgs) UIElement.OnPreviewQueryContinueDrag(QueryContinueDragEventArgs) UIElement.OnPreviewStylusButtonDown(StylusButtonEventArgs) UIElement.OnPreviewStylusButtonUp(StylusButtonEventArgs) UIElement.OnPreviewStylusDown(StylusDownEventArgs) UIElement.OnPreviewStylusInAirMove(StylusEventArgs) UIElement.OnPreviewStylusInRange(StylusEventArgs) UIElement.OnPreviewStylusMove(StylusEventArgs) UIElement.OnPreviewStylusOutOfRange(StylusEventArgs) UIElement.OnPreviewStylusSystemGesture(StylusSystemGestureEventArgs) UIElement.OnPreviewStylusUp(StylusEventArgs) UIElement.OnPreviewTextInput(TextCompositionEventArgs) UIElement.OnPreviewTouchDown(TouchEventArgs) UIElement.OnPreviewTouchMove(TouchEventArgs) UIElement.OnPreviewTouchUp(TouchEventArgs) UIElement.OnQueryContinueDrag(QueryContinueDragEventArgs) UIElement.OnQueryCursor(QueryCursorEventArgs) UIElement.OnRender(DrawingContext) UIElement.OnStylusButtonDown(StylusButtonEventArgs) UIElement.OnStylusButtonUp(StylusButtonEventArgs) UIElement.OnStylusDown(StylusDownEventArgs) UIElement.OnStylusEnter(StylusEventArgs) UIElement.OnStylusInAirMove(StylusEventArgs) UIElement.OnStylusInRange(StylusEventArgs) UIElement.OnStylusLeave(StylusEventArgs) UIElement.OnStylusMove(StylusEventArgs) UIElement.OnStylusOutOfRange(StylusEventArgs) UIElement.OnStylusSystemGesture(StylusSystemGestureEventArgs) UIElement.OnStylusUp(StylusEventArgs) UIElement.OnTextInput(TextCompositionEventArgs) UIElement.OnTouchDown(TouchEventArgs) UIElement.OnTouchEnter(TouchEventArgs) UIElement.OnTouchLeave(TouchEventArgs) UIElement.OnTouchMove(TouchEventArgs) UIElement.OnTouchUp(TouchEventArgs) UIElement.RaiseEvent(RoutedEventArgs) UIElement.ReleaseAllTouchCaptures() UIElement.ReleaseMouseCapture() UIElement.ReleaseStylusCapture() UIElement.ReleaseTouchCapture(TouchDevice) UIElement.RemoveHandler(RoutedEvent, Delegate) UIElement.TranslatePoint(Point, UIElement) UIElement.UpdateLayout() UIElement.AllowDrop UIElement.AreAnyTouchesCaptured UIElement.AreAnyTouchesCapturedWithin UIElement.AreAnyTouchesDirectlyOver UIElement.AreAnyTouchesOver UIElement.BitmapEffect UIElement.BitmapEffectInput UIElement.CacheMode UIElement.Clip UIElement.ClipToBounds UIElement.CommandBindings UIElement.DesiredSize UIElement.Effect UIElement.Focusable UIElement.HasAnimatedProperties UIElement.HasEffectiveKeyboardFocus UIElement.InputBindings UIElement.IsArrangeValid UIElement.IsEnabled UIElement.IsEnabledCore UIElement.IsFocused UIElement.IsHitTestVisible UIElement.IsInputMethodEnabled UIElement.IsKeyboardFocused UIElement.IsKeyboardFocusWithin UIElement.IsManipulationEnabled UIElement.IsMeasureValid UIElement.IsMouseCaptured UIElement.IsMouseCaptureWithin UIElement.IsMouseDirectlyOver UIElement.IsMouseOver UIElement.IsStylusCaptured UIElement.IsStylusCaptureWithin UIElement.IsStylusDirectlyOver UIElement.IsStylusOver UIElement.IsVisible UIElement.Opacity UIElement.OpacityMask UIElement.PersistId UIElement.RenderSize UIElement.RenderTransform UIElement.RenderTransformOrigin UIElement.SnapsToDevicePixels UIElement.StylusPlugIns UIElement.TouchesCaptured UIElement.TouchesCapturedWithin UIElement.TouchesDirectlyOver UIElement.TouchesOver UIElement.Uid UIElement.Visibility UIElement.DragEnter UIElement.DragLeave UIElement.DragOver UIElement.Drop UIElement.FocusableChanged UIElement.GiveFeedback UIElement.GotFocus UIElement.GotKeyboardFocus UIElement.GotMouseCapture UIElement.GotStylusCapture UIElement.GotTouchCapture UIElement.IsEnabledChanged UIElement.IsHitTestVisibleChanged UIElement.IsKeyboardFocusedChanged UIElement.IsKeyboardFocusWithinChanged UIElement.IsMouseCapturedChanged UIElement.IsMouseCaptureWithinChanged UIElement.IsMouseDirectlyOverChanged UIElement.IsStylusCapturedChanged UIElement.IsStylusCaptureWithinChanged UIElement.IsStylusDirectlyOverChanged UIElement.IsVisibleChanged UIElement.KeyDown UIElement.KeyUp UIElement.LayoutUpdated UIElement.LostFocus UIElement.LostKeyboardFocus UIElement.LostMouseCapture UIElement.LostStylusCapture UIElement.LostTouchCapture UIElement.ManipulationBoundaryFeedback UIElement.ManipulationCompleted UIElement.ManipulationDelta UIElement.ManipulationInertiaStarting UIElement.ManipulationStarted UIElement.ManipulationStarting UIElement.MouseDown UIElement.MouseEnter UIElement.MouseLeave UIElement.MouseLeftButtonDown UIElement.MouseLeftButtonUp UIElement.MouseMove UIElement.MouseRightButtonDown UIElement.MouseRightButtonUp UIElement.MouseUp UIElement.MouseWheel UIElement.PreviewDragEnter UIElement.PreviewDragLeave UIElement.PreviewDragOver UIElement.PreviewDrop UIElement.PreviewGiveFeedback UIElement.PreviewGotKeyboardFocus UIElement.PreviewKeyDown UIElement.PreviewKeyUp UIElement.PreviewLostKeyboardFocus UIElement.PreviewMouseDown UIElement.PreviewMouseLeftButtonDown UIElement.PreviewMouseLeftButtonUp UIElement.PreviewMouseMove UIElement.PreviewMouseRightButtonDown UIElement.PreviewMouseRightButtonUp UIElement.PreviewMouseUp UIElement.PreviewMouseWheel UIElement.PreviewQueryContinueDrag UIElement.PreviewStylusButtonDown UIElement.PreviewStylusButtonUp UIElement.PreviewStylusDown UIElement.PreviewStylusInAirMove UIElement.PreviewStylusInRange UIElement.PreviewStylusMove UIElement.PreviewStylusOutOfRange UIElement.PreviewStylusSystemGesture UIElement.PreviewStylusUp UIElement.PreviewTextInput UIElement.PreviewTouchDown UIElement.PreviewTouchMove UIElement.PreviewTouchUp UIElement.QueryContinueDrag UIElement.QueryCursor UIElement.StylusButtonDown UIElement.StylusButtonUp UIElement.StylusDown UIElement.StylusEnter UIElement.StylusInAirMove UIElement.StylusInRange UIElement.StylusLeave UIElement.StylusMove UIElement.StylusOutOfRange UIElement.StylusSystemGesture UIElement.StylusUp UIElement.TextInput UIElement.TouchDown UIElement.TouchEnter UIElement.TouchLeave UIElement.TouchMove UIElement.TouchUp Visual.AddVisualChild(Visual) Visual.FindCommonVisualAncestor(DependencyObject) Visual.IsAncestorOf(DependencyObject) Visual.IsDescendantOf(DependencyObject) Visual.OnDpiChanged(DpiScale, DpiScale) Visual.OnVisualChildrenChanged(DependencyObject, DependencyObject) Visual.PointFromScreen(Point) Visual.PointToScreen(Point) Visual.RemoveVisualChild(Visual) Visual.TransformToAncestor(Visual3D) Visual.TransformToAncestor(Visual) Visual.TransformToDescendant(Visual) Visual.TransformToVisual(Visual) Visual.VisualBitmapEffect Visual.VisualBitmapEffectInput Visual.VisualBitmapScalingMode Visual.VisualCacheMode Visual.VisualClearTypeHint Visual.VisualClip Visual.VisualEdgeMode Visual.VisualEffect Visual.VisualOffset Visual.VisualOpacity Visual.VisualOpacityMask Visual.VisualParent Visual.VisualScrollableAreaClip Visual.VisualTextHintingMode Visual.VisualTextRenderingMode Visual.VisualTransform Visual.VisualXSnappingGuidelines Visual.VisualYSnappingGuidelines DependencyObject.ClearValue(DependencyProperty) DependencyObject.ClearValue(DependencyPropertyKey) DependencyObject.CoerceValue(DependencyProperty) DependencyObject.Equals(object) DependencyObject.GetHashCode() DependencyObject.GetLocalValueEnumerator() DependencyObject.GetValue(DependencyProperty) DependencyObject.InvalidateProperty(DependencyProperty) DependencyObject.ReadLocalValue(DependencyProperty) DependencyObject.SetCurrentValue(DependencyProperty, object) DependencyObject.SetValue(DependencyProperty, object) DependencyObject.SetValue(DependencyPropertyKey, object) DependencyObject.ShouldSerializeProperty(DependencyProperty) DependencyObject.DependencyObjectType DependencyObject.IsSealed DispatcherObject.Dispatcher object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Remarks This canvas provides the core rendering capabilities for WPF applications using HiAPI. It manages mouse, keyboard, and touch events, and transforms them into appropriate actions in the 3D environment. Constructors RenderingCanvas() Initializes a new instance of the RenderingCanvas public RenderingCanvas() Properties DispEngine The DispEngine instance that handles rendering and user interactions public DispEngine DispEngine { get; } Property Value DispEngine Methods Dispose() Public dispose method to free resources public void Dispose() Dispose(bool) Disposes managed resources protected virtual void Dispose(bool disposing) Parameters disposing bool"
  },
  "api/Hi.WpfPlus.Disp.RenderingWindow.html": {
    "href": "api/Hi.WpfPlus.Disp.RenderingWindow.html",
    "title": "Class RenderingWindow | HiAPI-C# 2025",
    "summary": "Class RenderingWindow Namespace Hi.WpfPlus.Disp Assembly Hi.WpfPlus.dll Window for 3D rendering. public class RenderingWindow : Window, IAnimatable, ISupportInitialize, IFrameworkInputElement, IInputElement, IQueryAmbient, IAddChild, IGetDispEngine Inheritance object DispatcherObject DependencyObject Visual UIElement FrameworkElement Control ContentControl Window RenderingWindow Implements IAnimatable ISupportInitialize IFrameworkInputElement IInputElement IQueryAmbient IAddChild IGetDispEngine Inherited Members Window.AllowsTransparencyProperty Window.DpiChangedEvent Window.IconProperty Window.IsActiveProperty Window.LeftProperty Window.ResizeModeProperty Window.ShowActivatedProperty Window.ShowInTaskbarProperty Window.SizeToContentProperty Window.TaskbarItemInfoProperty Window.TitleProperty Window.TopmostProperty Window.TopProperty Window.WindowStateProperty Window.WindowStyleProperty Window.Activate() Window.ArrangeOverride(Size) Window.Close() Window.DragMove() Window.GetWindow(DependencyObject) Window.Hide() Window.MeasureOverride(Size) Window.OnActivated(EventArgs) Window.OnClosed(EventArgs) Window.OnClosing(CancelEventArgs) Window.OnContentChanged(object, object) Window.OnContentRendered(EventArgs) Window.OnCreateAutomationPeer() Window.OnDeactivated(EventArgs) Window.OnDpiChanged(DpiScale, DpiScale) Window.OnLocationChanged(EventArgs) Window.OnManipulationBoundaryFeedback(ManipulationBoundaryFeedbackEventArgs) Window.OnSourceInitialized(EventArgs) Window.OnStateChanged(EventArgs) Window.OnVisualChildrenChanged(DependencyObject, DependencyObject) Window.OnVisualParentChanged(DependencyObject) Window.Show() Window.ShowDialog() Window.AllowsTransparency Window.DialogResult Window.Icon Window.IsActive Window.Left Window.LogicalChildren Window.OwnedWindows Window.Owner Window.ResizeMode Window.RestoreBounds Window.ShowActivated Window.ShowInTaskbar Window.SizeToContent Window.TaskbarItemInfo Window.ThemeMode Window.Title Window.Top Window.Topmost Window.WindowStartupLocation Window.WindowState Window.WindowStyle Window.Activated Window.Closed Window.Closing Window.ContentRendered Window.Deactivated Window.DpiChanged Window.LocationChanged Window.SourceInitialized Window.StateChanged ContentControl.ContentProperty ContentControl.ContentStringFormatProperty ContentControl.ContentTemplateProperty ContentControl.ContentTemplateSelectorProperty ContentControl.HasContentProperty ContentControl.AddChild(object) ContentControl.AddText(string) ContentControl.OnContentStringFormatChanged(string, string) ContentControl.OnContentTemplateChanged(DataTemplate, DataTemplate) ContentControl.OnContentTemplateSelectorChanged(DataTemplateSelector, DataTemplateSelector) ContentControl.Content ContentControl.ContentStringFormat ContentControl.ContentTemplate ContentControl.ContentTemplateSelector ContentControl.HasContent Control.BackgroundProperty Control.BorderBrushProperty Control.BorderThicknessProperty Control.FontFamilyProperty Control.FontSizeProperty Control.FontStretchProperty Control.FontStyleProperty Control.FontWeightProperty Control.ForegroundProperty Control.HorizontalContentAlignmentProperty Control.IsTabStopProperty Control.MouseDoubleClickEvent Control.PaddingProperty Control.PreviewMouseDoubleClickEvent Control.TabIndexProperty Control.TemplateProperty Control.VerticalContentAlignmentProperty Control.OnMouseDoubleClick(MouseButtonEventArgs) Control.OnPreviewMouseDoubleClick(MouseButtonEventArgs) Control.OnTemplateChanged(ControlTemplate, ControlTemplate) Control.ToString() Control.Background Control.BorderBrush Control.BorderThickness Control.FontFamily Control.FontSize Control.FontStretch Control.FontStyle Control.FontWeight Control.Foreground Control.HandlesScrolling Control.HorizontalContentAlignment Control.IsTabStop Control.Padding Control.TabIndex Control.Template Control.VerticalContentAlignment Control.MouseDoubleClick Control.PreviewMouseDoubleClick FrameworkElement.ActualHeightProperty FrameworkElement.ActualWidthProperty FrameworkElement.BindingGroupProperty FrameworkElement.ContextMenuClosingEvent FrameworkElement.ContextMenuOpeningEvent FrameworkElement.ContextMenuProperty FrameworkElement.CursorProperty FrameworkElement.DataContextProperty FrameworkElement.DefaultStyleKeyProperty FrameworkElement.FlowDirectionProperty FrameworkElement.FocusVisualStyleProperty FrameworkElement.ForceCursorProperty FrameworkElement.HeightProperty FrameworkElement.HorizontalAlignmentProperty FrameworkElement.InputScopeProperty FrameworkElement.LanguageProperty FrameworkElement.LayoutTransformProperty FrameworkElement.LoadedEvent FrameworkElement.MarginProperty FrameworkElement.MaxHeightProperty FrameworkElement.MaxWidthProperty FrameworkElement.MinHeightProperty FrameworkElement.MinWidthProperty FrameworkElement.NameProperty FrameworkElement.OverridesDefaultStyleProperty FrameworkElement.RequestBringIntoViewEvent FrameworkElement.SizeChangedEvent FrameworkElement.StyleProperty FrameworkElement.TagProperty FrameworkElement.ToolTipClosingEvent FrameworkElement.ToolTipOpeningEvent FrameworkElement.ToolTipProperty FrameworkElement.UnloadedEvent FrameworkElement.UseLayoutRoundingProperty FrameworkElement.VerticalAlignmentProperty FrameworkElement.WidthProperty FrameworkElement.AddLogicalChild(object) FrameworkElement.ApplyTemplate() FrameworkElement.ArrangeCore(Rect) FrameworkElement.BeginInit() FrameworkElement.BeginStoryboard(Storyboard) FrameworkElement.BeginStoryboard(Storyboard, HandoffBehavior) FrameworkElement.BeginStoryboard(Storyboard, HandoffBehavior, bool) FrameworkElement.BringIntoView() FrameworkElement.BringIntoView(Rect) FrameworkElement.EndInit() FrameworkElement.FindName(string) FrameworkElement.FindResource(object) FrameworkElement.GetBindingExpression(DependencyProperty) FrameworkElement.GetFlowDirection(DependencyObject) FrameworkElement.GetLayoutClip(Size) FrameworkElement.GetTemplateChild(string) FrameworkElement.GetUIParentCore() FrameworkElement.GetVisualChild(int) FrameworkElement.MeasureCore(Size) FrameworkElement.MoveFocus(TraversalRequest) FrameworkElement.OnApplyTemplate() FrameworkElement.OnContextMenuClosing(ContextMenuEventArgs) FrameworkElement.OnContextMenuOpening(ContextMenuEventArgs) FrameworkElement.OnGotFocus(RoutedEventArgs) FrameworkElement.OnInitialized(EventArgs) FrameworkElement.OnPropertyChanged(DependencyPropertyChangedEventArgs) FrameworkElement.OnRenderSizeChanged(SizeChangedInfo) FrameworkElement.OnStyleChanged(Style, Style) FrameworkElement.OnToolTipClosing(ToolTipEventArgs) FrameworkElement.OnToolTipOpening(ToolTipEventArgs) FrameworkElement.ParentLayoutInvalidated(UIElement) FrameworkElement.PredictFocus(FocusNavigationDirection) FrameworkElement.RegisterName(string, object) FrameworkElement.RemoveLogicalChild(object) FrameworkElement.SetBinding(DependencyProperty, string) FrameworkElement.SetBinding(DependencyProperty, BindingBase) FrameworkElement.SetFlowDirection(DependencyObject, FlowDirection) FrameworkElement.SetResourceReference(DependencyProperty, object) FrameworkElement.TryFindResource(object) FrameworkElement.UnregisterName(string) FrameworkElement.UpdateDefaultStyle() FrameworkElement.ActualHeight FrameworkElement.ActualWidth FrameworkElement.BindingGroup FrameworkElement.ContextMenu FrameworkElement.Cursor FrameworkElement.DataContext FrameworkElement.DefaultStyleKey FrameworkElement.FlowDirection FrameworkElement.FocusVisualStyle FrameworkElement.ForceCursor FrameworkElement.Height FrameworkElement.HorizontalAlignment FrameworkElement.InheritanceBehavior FrameworkElement.InputScope FrameworkElement.IsInitialized FrameworkElement.IsLoaded FrameworkElement.Language FrameworkElement.LayoutTransform FrameworkElement.Margin FrameworkElement.MaxHeight FrameworkElement.MaxWidth FrameworkElement.MinHeight FrameworkElement.MinWidth FrameworkElement.Name FrameworkElement.OverridesDefaultStyle FrameworkElement.Parent FrameworkElement.Resources FrameworkElement.Style FrameworkElement.Tag FrameworkElement.TemplatedParent FrameworkElement.ToolTip FrameworkElement.Triggers FrameworkElement.UseLayoutRounding FrameworkElement.VerticalAlignment FrameworkElement.VisualChildrenCount FrameworkElement.Width FrameworkElement.ContextMenuClosing FrameworkElement.ContextMenuOpening FrameworkElement.DataContextChanged FrameworkElement.Initialized FrameworkElement.Loaded FrameworkElement.RequestBringIntoView FrameworkElement.SizeChanged FrameworkElement.SourceUpdated FrameworkElement.TargetUpdated FrameworkElement.ToolTipClosing FrameworkElement.ToolTipOpening FrameworkElement.Unloaded UIElement.AllowDropProperty UIElement.AreAnyTouchesCapturedProperty UIElement.AreAnyTouchesCapturedWithinProperty UIElement.AreAnyTouchesDirectlyOverProperty UIElement.AreAnyTouchesOverProperty UIElement.BitmapEffectInputProperty UIElement.BitmapEffectProperty UIElement.CacheModeProperty UIElement.ClipProperty UIElement.ClipToBoundsProperty UIElement.DragEnterEvent UIElement.DragLeaveEvent UIElement.DragOverEvent UIElement.DropEvent UIElement.EffectProperty UIElement.FocusableProperty UIElement.GiveFeedbackEvent UIElement.GotFocusEvent UIElement.GotKeyboardFocusEvent UIElement.GotMouseCaptureEvent UIElement.GotStylusCaptureEvent UIElement.GotTouchCaptureEvent UIElement.IsEnabledProperty UIElement.IsFocusedProperty UIElement.IsHitTestVisibleProperty UIElement.IsKeyboardFocusedProperty UIElement.IsKeyboardFocusWithinProperty UIElement.IsManipulationEnabledProperty UIElement.IsMouseCapturedProperty UIElement.IsMouseCaptureWithinProperty UIElement.IsMouseDirectlyOverProperty UIElement.IsMouseOverProperty UIElement.IsStylusCapturedProperty UIElement.IsStylusCaptureWithinProperty UIElement.IsStylusDirectlyOverProperty UIElement.IsStylusOverProperty UIElement.IsVisibleProperty UIElement.KeyDownEvent UIElement.KeyUpEvent UIElement.LostFocusEvent UIElement.LostKeyboardFocusEvent UIElement.LostMouseCaptureEvent UIElement.LostStylusCaptureEvent UIElement.LostTouchCaptureEvent UIElement.ManipulationBoundaryFeedbackEvent UIElement.ManipulationCompletedEvent UIElement.ManipulationDeltaEvent UIElement.ManipulationInertiaStartingEvent UIElement.ManipulationStartedEvent UIElement.ManipulationStartingEvent UIElement.MouseDownEvent UIElement.MouseEnterEvent UIElement.MouseLeaveEvent UIElement.MouseLeftButtonDownEvent UIElement.MouseLeftButtonUpEvent UIElement.MouseMoveEvent UIElement.MouseRightButtonDownEvent UIElement.MouseRightButtonUpEvent UIElement.MouseUpEvent UIElement.MouseWheelEvent UIElement.OpacityMaskProperty UIElement.OpacityProperty UIElement.PreviewDragEnterEvent UIElement.PreviewDragLeaveEvent UIElement.PreviewDragOverEvent UIElement.PreviewDropEvent UIElement.PreviewGiveFeedbackEvent UIElement.PreviewGotKeyboardFocusEvent UIElement.PreviewKeyDownEvent UIElement.PreviewKeyUpEvent UIElement.PreviewLostKeyboardFocusEvent UIElement.PreviewMouseDownEvent UIElement.PreviewMouseLeftButtonDownEvent UIElement.PreviewMouseLeftButtonUpEvent UIElement.PreviewMouseMoveEvent UIElement.PreviewMouseRightButtonDownEvent UIElement.PreviewMouseRightButtonUpEvent UIElement.PreviewMouseUpEvent UIElement.PreviewMouseWheelEvent UIElement.PreviewQueryContinueDragEvent UIElement.PreviewStylusButtonDownEvent UIElement.PreviewStylusButtonUpEvent UIElement.PreviewStylusDownEvent UIElement.PreviewStylusInAirMoveEvent UIElement.PreviewStylusInRangeEvent UIElement.PreviewStylusMoveEvent UIElement.PreviewStylusOutOfRangeEvent UIElement.PreviewStylusSystemGestureEvent UIElement.PreviewStylusUpEvent UIElement.PreviewTextInputEvent UIElement.PreviewTouchDownEvent UIElement.PreviewTouchMoveEvent UIElement.PreviewTouchUpEvent UIElement.QueryContinueDragEvent UIElement.QueryCursorEvent UIElement.RenderTransformOriginProperty UIElement.RenderTransformProperty UIElement.SnapsToDevicePixelsProperty UIElement.StylusButtonDownEvent UIElement.StylusButtonUpEvent UIElement.StylusDownEvent UIElement.StylusEnterEvent UIElement.StylusInAirMoveEvent UIElement.StylusInRangeEvent UIElement.StylusLeaveEvent UIElement.StylusMoveEvent UIElement.StylusOutOfRangeEvent UIElement.StylusSystemGestureEvent UIElement.StylusUpEvent UIElement.TextInputEvent UIElement.TouchDownEvent UIElement.TouchEnterEvent UIElement.TouchLeaveEvent UIElement.TouchMoveEvent UIElement.TouchUpEvent UIElement.UidProperty UIElement.VisibilityProperty UIElement.AddHandler(RoutedEvent, Delegate) UIElement.AddHandler(RoutedEvent, Delegate, bool) UIElement.AddToEventRoute(EventRoute, RoutedEventArgs) UIElement.ApplyAnimationClock(DependencyProperty, AnimationClock) UIElement.ApplyAnimationClock(DependencyProperty, AnimationClock, HandoffBehavior) UIElement.Arrange(Rect) UIElement.BeginAnimation(DependencyProperty, AnimationTimeline) UIElement.BeginAnimation(DependencyProperty, AnimationTimeline, HandoffBehavior) UIElement.CaptureMouse() UIElement.CaptureStylus() UIElement.CaptureTouch(TouchDevice) UIElement.Focus() UIElement.GetAnimationBaseValue(DependencyProperty) UIElement.HitTestCore(GeometryHitTestParameters) UIElement.HitTestCore(PointHitTestParameters) UIElement.InputHitTest(Point) UIElement.InvalidateArrange() UIElement.InvalidateMeasure() UIElement.InvalidateVisual() UIElement.Measure(Size) UIElement.OnAccessKey(AccessKeyEventArgs) UIElement.OnChildDesiredSizeChanged(UIElement) UIElement.OnDragEnter(DragEventArgs) UIElement.OnDragLeave(DragEventArgs) UIElement.OnDragOver(DragEventArgs) UIElement.OnDrop(DragEventArgs) UIElement.OnGiveFeedback(GiveFeedbackEventArgs) UIElement.OnGotKeyboardFocus(KeyboardFocusChangedEventArgs) UIElement.OnGotMouseCapture(MouseEventArgs) UIElement.OnGotStylusCapture(StylusEventArgs) UIElement.OnGotTouchCapture(TouchEventArgs) UIElement.OnIsKeyboardFocusedChanged(DependencyPropertyChangedEventArgs) UIElement.OnIsKeyboardFocusWithinChanged(DependencyPropertyChangedEventArgs) UIElement.OnIsMouseCapturedChanged(DependencyPropertyChangedEventArgs) UIElement.OnIsMouseCaptureWithinChanged(DependencyPropertyChangedEventArgs) UIElement.OnIsMouseDirectlyOverChanged(DependencyPropertyChangedEventArgs) UIElement.OnIsStylusCapturedChanged(DependencyPropertyChangedEventArgs) UIElement.OnIsStylusCaptureWithinChanged(DependencyPropertyChangedEventArgs) UIElement.OnIsStylusDirectlyOverChanged(DependencyPropertyChangedEventArgs) UIElement.OnKeyDown(KeyEventArgs) UIElement.OnKeyUp(KeyEventArgs) UIElement.OnLostFocus(RoutedEventArgs) UIElement.OnLostKeyboardFocus(KeyboardFocusChangedEventArgs) UIElement.OnLostMouseCapture(MouseEventArgs) UIElement.OnLostStylusCapture(StylusEventArgs) UIElement.OnLostTouchCapture(TouchEventArgs) UIElement.OnManipulationCompleted(ManipulationCompletedEventArgs) UIElement.OnManipulationDelta(ManipulationDeltaEventArgs) UIElement.OnManipulationInertiaStarting(ManipulationInertiaStartingEventArgs) UIElement.OnManipulationStarted(ManipulationStartedEventArgs) UIElement.OnManipulationStarting(ManipulationStartingEventArgs) UIElement.OnMouseDown(MouseButtonEventArgs) UIElement.OnMouseEnter(MouseEventArgs) UIElement.OnMouseLeave(MouseEventArgs) UIElement.OnMouseLeftButtonDown(MouseButtonEventArgs) UIElement.OnMouseLeftButtonUp(MouseButtonEventArgs) UIElement.OnMouseMove(MouseEventArgs) UIElement.OnMouseRightButtonDown(MouseButtonEventArgs) UIElement.OnMouseRightButtonUp(MouseButtonEventArgs) UIElement.OnMouseUp(MouseButtonEventArgs) UIElement.OnMouseWheel(MouseWheelEventArgs) UIElement.OnPreviewDragEnter(DragEventArgs) UIElement.OnPreviewDragLeave(DragEventArgs) UIElement.OnPreviewDragOver(DragEventArgs) UIElement.OnPreviewDrop(DragEventArgs) UIElement.OnPreviewGiveFeedback(GiveFeedbackEventArgs) UIElement.OnPreviewGotKeyboardFocus(KeyboardFocusChangedEventArgs) UIElement.OnPreviewKeyDown(KeyEventArgs) UIElement.OnPreviewKeyUp(KeyEventArgs) UIElement.OnPreviewLostKeyboardFocus(KeyboardFocusChangedEventArgs) UIElement.OnPreviewMouseDown(MouseButtonEventArgs) UIElement.OnPreviewMouseLeftButtonDown(MouseButtonEventArgs) UIElement.OnPreviewMouseLeftButtonUp(MouseButtonEventArgs) UIElement.OnPreviewMouseMove(MouseEventArgs) UIElement.OnPreviewMouseRightButtonDown(MouseButtonEventArgs) UIElement.OnPreviewMouseRightButtonUp(MouseButtonEventArgs) UIElement.OnPreviewMouseUp(MouseButtonEventArgs) UIElement.OnPreviewMouseWheel(MouseWheelEventArgs) UIElement.OnPreviewQueryContinueDrag(QueryContinueDragEventArgs) UIElement.OnPreviewStylusButtonDown(StylusButtonEventArgs) UIElement.OnPreviewStylusButtonUp(StylusButtonEventArgs) UIElement.OnPreviewStylusDown(StylusDownEventArgs) UIElement.OnPreviewStylusInAirMove(StylusEventArgs) UIElement.OnPreviewStylusInRange(StylusEventArgs) UIElement.OnPreviewStylusMove(StylusEventArgs) UIElement.OnPreviewStylusOutOfRange(StylusEventArgs) UIElement.OnPreviewStylusSystemGesture(StylusSystemGestureEventArgs) UIElement.OnPreviewStylusUp(StylusEventArgs) UIElement.OnPreviewTextInput(TextCompositionEventArgs) UIElement.OnPreviewTouchDown(TouchEventArgs) UIElement.OnPreviewTouchMove(TouchEventArgs) UIElement.OnPreviewTouchUp(TouchEventArgs) UIElement.OnQueryContinueDrag(QueryContinueDragEventArgs) UIElement.OnQueryCursor(QueryCursorEventArgs) UIElement.OnRender(DrawingContext) UIElement.OnStylusButtonDown(StylusButtonEventArgs) UIElement.OnStylusButtonUp(StylusButtonEventArgs) UIElement.OnStylusDown(StylusDownEventArgs) UIElement.OnStylusEnter(StylusEventArgs) UIElement.OnStylusInAirMove(StylusEventArgs) UIElement.OnStylusInRange(StylusEventArgs) UIElement.OnStylusLeave(StylusEventArgs) UIElement.OnStylusMove(StylusEventArgs) UIElement.OnStylusOutOfRange(StylusEventArgs) UIElement.OnStylusSystemGesture(StylusSystemGestureEventArgs) UIElement.OnStylusUp(StylusEventArgs) UIElement.OnTextInput(TextCompositionEventArgs) UIElement.OnTouchDown(TouchEventArgs) UIElement.OnTouchEnter(TouchEventArgs) UIElement.OnTouchLeave(TouchEventArgs) UIElement.OnTouchMove(TouchEventArgs) UIElement.OnTouchUp(TouchEventArgs) UIElement.RaiseEvent(RoutedEventArgs) UIElement.ReleaseAllTouchCaptures() UIElement.ReleaseMouseCapture() UIElement.ReleaseStylusCapture() UIElement.ReleaseTouchCapture(TouchDevice) UIElement.RemoveHandler(RoutedEvent, Delegate) UIElement.TranslatePoint(Point, UIElement) UIElement.UpdateLayout() UIElement.AllowDrop UIElement.AreAnyTouchesCaptured UIElement.AreAnyTouchesCapturedWithin UIElement.AreAnyTouchesDirectlyOver UIElement.AreAnyTouchesOver UIElement.BitmapEffect UIElement.BitmapEffectInput UIElement.CacheMode UIElement.Clip UIElement.ClipToBounds UIElement.CommandBindings UIElement.DesiredSize UIElement.Effect UIElement.Focusable UIElement.HasAnimatedProperties UIElement.HasEffectiveKeyboardFocus UIElement.InputBindings UIElement.IsArrangeValid UIElement.IsEnabled UIElement.IsEnabledCore UIElement.IsFocused UIElement.IsHitTestVisible UIElement.IsInputMethodEnabled UIElement.IsKeyboardFocused UIElement.IsKeyboardFocusWithin UIElement.IsManipulationEnabled UIElement.IsMeasureValid UIElement.IsMouseCaptured UIElement.IsMouseCaptureWithin UIElement.IsMouseDirectlyOver UIElement.IsMouseOver UIElement.IsStylusCaptured UIElement.IsStylusCaptureWithin UIElement.IsStylusDirectlyOver UIElement.IsStylusOver UIElement.IsVisible UIElement.Opacity UIElement.OpacityMask UIElement.PersistId UIElement.RenderSize UIElement.RenderTransform UIElement.RenderTransformOrigin UIElement.SnapsToDevicePixels UIElement.StylusPlugIns UIElement.TouchesCaptured UIElement.TouchesCapturedWithin UIElement.TouchesDirectlyOver UIElement.TouchesOver UIElement.Uid UIElement.Visibility UIElement.DragEnter UIElement.DragLeave UIElement.DragOver UIElement.Drop UIElement.FocusableChanged UIElement.GiveFeedback UIElement.GotFocus UIElement.GotKeyboardFocus UIElement.GotMouseCapture UIElement.GotStylusCapture UIElement.GotTouchCapture UIElement.IsEnabledChanged UIElement.IsHitTestVisibleChanged UIElement.IsKeyboardFocusedChanged UIElement.IsKeyboardFocusWithinChanged UIElement.IsMouseCapturedChanged UIElement.IsMouseCaptureWithinChanged UIElement.IsMouseDirectlyOverChanged UIElement.IsStylusCapturedChanged UIElement.IsStylusCaptureWithinChanged UIElement.IsStylusDirectlyOverChanged UIElement.IsVisibleChanged UIElement.KeyDown UIElement.KeyUp UIElement.LayoutUpdated UIElement.LostFocus UIElement.LostKeyboardFocus UIElement.LostMouseCapture UIElement.LostStylusCapture UIElement.LostTouchCapture UIElement.ManipulationBoundaryFeedback UIElement.ManipulationCompleted UIElement.ManipulationDelta UIElement.ManipulationInertiaStarting UIElement.ManipulationStarted UIElement.ManipulationStarting UIElement.MouseDown UIElement.MouseEnter UIElement.MouseLeave UIElement.MouseLeftButtonDown UIElement.MouseLeftButtonUp UIElement.MouseMove UIElement.MouseRightButtonDown UIElement.MouseRightButtonUp UIElement.MouseUp UIElement.MouseWheel UIElement.PreviewDragEnter UIElement.PreviewDragLeave UIElement.PreviewDragOver UIElement.PreviewDrop UIElement.PreviewGiveFeedback UIElement.PreviewGotKeyboardFocus UIElement.PreviewKeyDown UIElement.PreviewKeyUp UIElement.PreviewLostKeyboardFocus UIElement.PreviewMouseDown UIElement.PreviewMouseLeftButtonDown UIElement.PreviewMouseLeftButtonUp UIElement.PreviewMouseMove UIElement.PreviewMouseRightButtonDown UIElement.PreviewMouseRightButtonUp UIElement.PreviewMouseUp UIElement.PreviewMouseWheel UIElement.PreviewQueryContinueDrag UIElement.PreviewStylusButtonDown UIElement.PreviewStylusButtonUp UIElement.PreviewStylusDown UIElement.PreviewStylusInAirMove UIElement.PreviewStylusInRange UIElement.PreviewStylusMove UIElement.PreviewStylusOutOfRange UIElement.PreviewStylusSystemGesture UIElement.PreviewStylusUp UIElement.PreviewTextInput UIElement.PreviewTouchDown UIElement.PreviewTouchMove UIElement.PreviewTouchUp UIElement.QueryContinueDrag UIElement.QueryCursor UIElement.StylusButtonDown UIElement.StylusButtonUp UIElement.StylusDown UIElement.StylusEnter UIElement.StylusInAirMove UIElement.StylusInRange UIElement.StylusLeave UIElement.StylusMove UIElement.StylusOutOfRange UIElement.StylusSystemGesture UIElement.StylusUp UIElement.TextInput UIElement.TouchDown UIElement.TouchEnter UIElement.TouchLeave UIElement.TouchMove UIElement.TouchUp Visual.AddVisualChild(Visual) Visual.FindCommonVisualAncestor(DependencyObject) Visual.IsAncestorOf(DependencyObject) Visual.IsDescendantOf(DependencyObject) Visual.PointFromScreen(Point) Visual.PointToScreen(Point) Visual.RemoveVisualChild(Visual) Visual.TransformToAncestor(Visual3D) Visual.TransformToAncestor(Visual) Visual.TransformToDescendant(Visual) Visual.TransformToVisual(Visual) Visual.VisualBitmapEffect Visual.VisualBitmapEffectInput Visual.VisualBitmapScalingMode Visual.VisualCacheMode Visual.VisualClearTypeHint Visual.VisualClip Visual.VisualEdgeMode Visual.VisualEffect Visual.VisualOffset Visual.VisualOpacity Visual.VisualOpacityMask Visual.VisualParent Visual.VisualScrollableAreaClip Visual.VisualTextHintingMode Visual.VisualTextRenderingMode Visual.VisualTransform Visual.VisualXSnappingGuidelines Visual.VisualYSnappingGuidelines DependencyObject.ClearValue(DependencyProperty) DependencyObject.ClearValue(DependencyPropertyKey) DependencyObject.CoerceValue(DependencyProperty) DependencyObject.Equals(object) DependencyObject.GetHashCode() DependencyObject.GetLocalValueEnumerator() DependencyObject.GetValue(DependencyProperty) DependencyObject.InvalidateProperty(DependencyProperty) DependencyObject.ReadLocalValue(DependencyProperty) DependencyObject.SetCurrentValue(DependencyProperty, object) DependencyObject.SetValue(DependencyProperty, object) DependencyObject.SetValue(DependencyPropertyKey, object) DependencyObject.ShouldSerializeProperty(DependencyProperty) DependencyObject.DependencyObjectType DependencyObject.IsSealed DispatcherObject.Dispatcher object.Equals(object, object) object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) Extension Methods DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors RenderingWindow() Ctor. public RenderingWindow() Properties Displayee Gets or sets the current displayable 3D object. When setting a new displayee, the view will be reset to home position if no previous displayee was set. public IDisplayee Displayee { get; set; } Property Value IDisplayee RenderingCanvas Gets the rendering canvas control used for displaying 3D content. public RenderingCanvas RenderingCanvas { get; } Property Value RenderingCanvas Methods GetDispEngine() Get DispEngine. public DispEngine GetDispEngine() Returns DispEngine DispEngine"
  },
  "api/Hi.WpfPlus.Disp.WpfDispUtil.html": {
    "href": "api/Hi.WpfPlus.Disp.WpfDispUtil.html",
    "title": "Class WpfDispUtil | HiAPI-C# 2025",
    "summary": "Class WpfDispUtil Namespace Hi.WpfPlus.Disp Assembly Hi.WpfPlus.dll Registers WPF as the display framework for DispFrameUtil, supporting multiple windows identified by key. public static class WpfDispUtil Inheritance object WpfDispUtil Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Remarks Usage pattern: call Call(string, params IDisplayee[]) to queue display content, then call RunApplication() to start the WPF application and show windows. Each unique key creates a separate RenderingWindow. Calling Call(string, params IDisplayee[]) with the same key updates the existing window. // Queue display content (before or after Run) DispFrameUtil.CallDispFrame(\"Window1\", displayee1); DispFrameUtil.CallDispFrame(\"Window2\", displayee2); // Start the WPF application (blocks until all windows are closed) DispFrameWpf.Run(); Methods Call(string, params IDisplayee[]) Configures the display engine with the specified displayees for the given title. public static DispEngineConfig Call(string title, params IDisplayee[] displayees) Parameters title string The title/key to identify the display window. displayees IDisplayee[] The displayees to be configured. Returns DispEngineConfig The display engine configuration. Init() Initializes the display engine. public static void Init() RunApplication() Starts the WPF application and shows all configured windows. Blocks until all windows are closed. public static void RunApplication() RunApplication(string, params IDisplayee[]) Configures the display engine with the specified displayees and starts the WPF application. public static void RunApplication(string title, params IDisplayee[] displayees) Parameters title string The title/key to identify the display window. displayees IDisplayee[] The displayees to be configured."
  },
  "api/Hi.WpfPlus.Disp.html": {
    "href": "api/Hi.WpfPlus.Disp.html",
    "title": "Namespace Hi.WpfPlus.Disp | HiAPI-C# 2025",
    "summary": "Namespace Hi.WpfPlus.Disp Classes RenderingCanvas Provides a WPF rendering canvas for 3D visualization of HiAPI components. Handles user interactions, rendering, and integration with the DispEngine system. RenderingWindow Window for 3D rendering. WpfDispUtil Registers WPF as the display framework for DispFrameUtil, supporting multiple windows identified by key."
  },
  "api/HiMachining.Milling.ClMillingDevice.html": {
    "href": "api/HiMachining.Milling.ClMillingDevice.html",
    "title": "Class ClMillingDevice | HiAPI-C# 2025",
    "summary": "Class ClMillingDevice Namespace HiMachining.Milling Assembly HiMech.dll A milling device driven by CL(Cutter Location). public class ClMillingDevice : IMachiningChain, IGetAsmb, IGetAnchor, IGetTopoIndex, IMakeXmlSource, IGetAnchorToSolidDictionary Inheritance object ClMillingDevice Implements IMachiningChain IGetAsmb IGetAnchor IGetTopoIndex IMakeXmlSource IGetAnchorToSolidDictionary Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Extension Methods MachiningChainUtil.GetMcCodeTransformerDictionary(IMachiningChain) TopoUtil.Display(IGetAnchor, Bind, Dictionary<Anchor, Mat4d>) TopoUtil.ExpandToBox3d(IGetAnchor, Box3d, Dictionary<Anchor, Mat4d>) DuplicateUtil.TryDuplicate<TSelf>(TSelf, params object[]) InvokeUtil.SelfInvoke<TSrc>(TSrc, Action<TSrc>) InvokeUtil.SelfInvoke<TSrc, TDst>(TSrc, Func<TSrc, TDst>) ColorUtil.GetGloomyColor(object, double, double) NameUtil.GetSelectionName(object) StringUtil.GetPropertyStringIfToStringNotOverloaded(object, bool, bool) LockUtil.Lock(object) Constructors ClMillingDevice() Ctor. public ClMillingDevice() ClMillingDevice(XElement, string) Initializes a new instance from XML. public ClMillingDevice(XElement src, string baseDirectory) Parameters src XElement The XML source element. baseDirectory string The base directory for resolving relative paths. Properties Cl Gets or sets the current program cutter location in workpiece coordinates. public DVec3d Cl { get; set; } Property Value DVec3d KeyBranch Gets the branch connecting table buckle and tool buckle. public Branch KeyBranch { get; } Property Value Branch KeyTransformer An ITransformer driven by Cl. Null when KeyBranch is absent (a serialized device whose assembly carries no direct table-to-tool branch). public DynamicFreeform KeyTransformer { get; set; } Property Value DynamicFreeform MachiningEquipmentGetter Runtime property. For managing CL. public Func<MachiningEquipment> MachiningEquipmentGetter { get; set; } Property Value Func<MachiningEquipment> MainAsmb Main MainAsmb of this device. public Asmb MainAsmb { get; } Property Value Asmb McCodes Gets the machine coordinate code sequence for decoding the MC array. public string[] McCodes { get; } Property Value string[] McTransformers Gets the machine coordinate transformers. public IDynamicRegular[] McTransformers { get; } Property Value IDynamicRegular[] TableBuckle Table buckle. public Anchor TableBuckle { get; } Property Value Anchor ToolBuckle Tool buckle. public Anchor ToolBuckle { get; } Property Value Anchor XName Name of XML element. public static string XName { get; } Property Value string Methods GetAnchor() Get key anchor. (i.e. root anchor) public Anchor GetAnchor() Returns Anchor key anchor GetAnchorToSolidDictionary() Gets a dictionary that maps Anchor objects to their corresponding Solid objects. public Dictionary<Anchor, Solid> GetAnchorToSolidDictionary() Returns Dictionary<Anchor, Solid> A dictionary where keys are anchors and values are their associated solids. GetAsmb() Gets the key asmb. public Asmb GetAsmb() Returns Asmb The key asmb. GetTableBuckle() Gets the table buckle anchor point. public IGetAnchor GetTableBuckle() Returns IGetAnchor The table buckle anchor point. GetToolBuckle() Gets the tool buckle anchor point. public IGetAnchor GetToolBuckle() Returns IGetAnchor The tool buckle anchor point. MakeXmlSource(string, string, bool) Creates an XML representation of the object. This method may also generate additional resources such as related files. public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) Parameters baseDirectory string The base directory for resolving relative paths relFile string The relative file path for the XML source exhibitionOnly bool if true, the extended file creation is suppressed. Returns XElement An XML element representing the object's state Remarks For the demand of easy moving source folder (especially project folder) without configuration file path corruption, the relative file path is applied. The baseDirectory is typically the folder at the nearest configuration file folder. Since the folder can be moving with the configuration file. Reg(XFactory) Registers this type's deserializer with the given XFactory and chains Reg(factory) on dependents. Idempotent. public static void Reg(XFactory factory = null) Parameters factory XFactory ResetPose() Restores KeyTransformer to identity. The runtime-reset counterpart of re-homing an IXyzabcChain: without it, a paused/aborted run leaves the device at its last executed cutter location, and the next session's tool-change step would stamp a cut at that stale position. public void ResetPose()"
  },
  "api/HiMachining.Milling.html": {
    "href": "api/HiMachining.Milling.html",
    "title": "Namespace HiMachining.Milling | HiAPI-C# 2025",
    "summary": "Namespace HiMachining.Milling Classes ClMillingDevice A milling device driven by CL(Cutter Location)."
  },
  "index.html": {
    "href": "index.html",
    "title": "HiNC Documentation | HiAPI-C# 2025",
    "summary": "HiNC Documentation HiNC is a virtual machine tool and milling simulation software by Tech Coordinate. It performs pre-machining verification and optimization through high-precision simulation and milling physics analysis — including cutting force, moment, deflection, heat, wear, and more. flowchart TD subgraph Setup[\"Setup (ordering-free)\"] Mt[\"Build / Load<br>Virtual Machine Tool\"] ControlPreset[\"Configure<br>Drive Mode\"] BasicConfig[\"Set Workpiece, Fixture,<br>Tool House, Controller & NC\"] MaterialConfig[\"Set Cutting<br>Parameters\"] ImportData[\"Import Sensor Data<br>(dynamometer / smart tool holder)\"] end Setup --> Sim[\"Run Simulation\"] Sim --> Collision[\"Collision Detection\"] Sim --> Examine[\"Inspect & Analyze<br>(force, moment, heat,<br>deflection, wear, power)\"] ImportData --> Examine Sim --> Train[\"Train Milling<br>Parameters\"] ImportData --> Train Train --> MaterialConfig Sim --> Opt[\"Generate Optimized NC<br>(re-interpolation,<br>feedrate adjustment)\"] subgraph Inspection Collision Examine end subgraph Output Opt end Where to Start Running a job from end to end. Workflows takes one job from the data you have to the result you want, in order, in a single page. Operating the application. Manual is the screen-by-screen reference for the HiNC web application — the frame, the equipment, the run, and the supporting screens. Understanding why the numbers come out the way they do. Technique carries the milling physics, machine capability, measurement and NC optimization knowledge, independently of any screen. Writing C# against the HiAPI packages. Technique also carries the developer layer — API foundations, scripting, rendering, the mechanism topology and the NC dialects — and the API Reference is its generated class-by-class companion. Sections Every entry below is a section index: it states its own ordering principle and lists what it holds, so navigation is top-down — this page, then the section index, then the sub-folder index, then the page. Manual — Operating the web application, chapter by chapter: basics, setup, running a simulation, utilities Workflows — End-to-end task guides, each read start to finish Technique — The durable knowledge behind the numbers: milling physics, machine capability, measurement, NC optimization, and the API layer applications are built on App Anatomy — The shipped applications broken down component by component: view ↔ model ↔ source API Reference — The generated C# class and method reference for the HiAPI packages Release Note — What changed in each release, and what upgrading costs Product — About Tech Coordinate, system requirements, license terms, activation and multi-station setup"
  },
  "manual/basics/finding-your-way.html": {
    "href": "manual/basics/finding-your-way.html",
    "title": "Finding Your Way | HiAPI-C# 2025",
    "summary": "Finding Your Way The application is a handful of screens, and most of what a job configures lives inside a tree on two of them. The Page menu reaches six of those screens, and it is not all of them. Every node of a tree has an address of its own, so a place in the application can be linked to rather than described. The screens The Page dropdown on the menu bar carries six entries in three groups. The first group is the job, in the order a job uses it: Tool House — the tools, one editor per tool General Setup — the equipment: the machine tool, the spindle capability, the background and coolant conditions, the fixture, the workpiece and the controller Execution — the run: the mission that is executed, the program as it was played, and what the run reports Below a separator, the two utilities: File Explorer — browsing the files under the roots the service exposes Mechanism Builder — authoring a kinematic chain Below a second separator, one more: Legacy-Controller — the controller settings that the General Setup tree's Controller branch has no editor for. The page it opens is titled Controller. No entry is ever greyed out. All six are selectable with no project open; what they lead to is what changes. Three screens have no entry in this menu: Machine Tool, at /machine-tool, reached by address only. It shows the machine chain beside a folder button whose tooltip reads Browse and a GUI / XML view switch, so it is more than a look at the chain — and it needs a project open. Log Viewer, reached from the Show Log button near the right-hand end of the menu bar. Its address is /preference/log. The sign-in page, which the service raises on its own when it wants one. Selecting inside a tree General Setup and Execution each carry a Control Tree in their left dock, under a header reading Control Tree, with the selected node's editor in the row beneath it. That editor row is titled with the path of the selection — General Setup / Workpiece / Anchor / Geom To Fixture — which is also how these pages name a place in prose. General Setup's tree has one root, General Setup, holding Machine Tool, Spindle Capability, Background, Coolant, Fixture, Workpiece and Controller, in that order. With a project open, a CSV Controller and a CL Controller node follow, each behind its own Preference checkbox — as siblings of Controller at the same level, not as children of it. With no project open neither node is built, whatever the preferences say. Execution's tree has one root, Execution, holding Mission above Program. General Setup's middle column belongs to the Spindle Capability branch: its items put their power and torque charts there. Every other selection leaves the column reading The selected item has no expanded content. That is the column's resting state rather than a fault. General Setup at /general-setup?tree=equipment/workpiece/anchor/geom-to-fixture, with the Workpiece branch's Anchor group expanded and Geom To Fixture selected. Its editor is the row below the tree, the middle column carries the empty-content message, and the canvas on the right draws the workpiece with its anchor labels. Linking to a node The selection rides in the address as a ?tree= value, so the address bar is already the link: copying it copies the node, not just the page. To take a link from the tree instead, right-click a node's label. Every label is a real link to that node's address, so the browser's own copy-link and open-in-new-tab entries both apply to it. Ctrl-click, Cmd-click or Shift-click a label to open that node in a new tab. The current tab's selection stays where it is. A plain left click selects the node in place, without navigating. Paste a ?tree= value belonging to the other tree page and it redirects to the page that owns it, so a link does not have to name the right screen to reach the right node. Tool House has no ?tree= at all — its address already names the selection, as /tool-house/<tool>/<tab>/<sub-tab>, so /tool-house/1/cutter/material is a link to one tool's Material sub-tab. Arriving at a tree page with no ?tree= still lands on a selected node — the last selection this browser made there, or the tree's root — and the address takes that node's ?tree= value on as soon as the tree is built, so the address bar is a whole link from then on. Important An address for a node its Preference checkbox is currently hiding — a CSV Controller or CL Controller node — is honoured only when the tree is built while that address is the current one, and it reveals nothing without a project open. In practice that means a full page load: pasting the link into a new tab, or reloading on it. Jumping to it from a screen that has already shown General Setup for the current project does not rebuild that tree, so the address is dropped in silence with the selection left where it was. The same page at /general-setup?tree=equipment/controller-csv, loaded fresh on that address with the CSV Controller preference still off — the address alone is what puts the node in the tree. CSV Controller sits below Controller at the same indent — a sibling of it — and its editor describes the fields as column tags matched against the CSV header line: Machine coordinate prefix MC., Cutter location prefix CL. and Tool id column ToolId. The addresses Nine addresses render a screen of their own. The bracketed segments are optional, so the bare address resolves too and the screen fills them in from its own state; File Explorer's trailing path carries as many segments as the browsed folder is deep. Address Screen /execution Execution /general-setup General Setup /tool-house/<tool>/<tab>/<sub-tab> Tool House /machine-tool Machine Tool /controller/<tab> Controller /util/file-explorer/<root>/<path> File Explorer /util/mech-builder Mechanism Builder /preference/log Log Viewer /login the sign-in page / lands on Execution. Six further addresses render nothing of their own and redirect into a tree page's node instead: Address Lands on /spindle-capability/<tab> General Setup, the Spindle Capability branch — on that tab's item when the segment names one, on the branch itself otherwise /equipment/spindle General Setup, the Spindle Capability branch /fixture, and anything below it General Setup, the Fixture branch /workpiece, and anything below it General Setup, the Workpiece branch /equipment/background-coolant General Setup, the Background item /mission Execution, the Mission branch An address matching none of these lands on the application's own 404 Not Found page, which prints the address it could not match and offers Back to Execution. A ?tree= value naming no node of the built tree is ignored instead: the page opens with nothing selected, and the editor row reads Select an item in the Control Tree to edit it here. Warning Tree ids are not promised to survive a version change. An old link keeps resolving because the application migrates known older ids, but nothing should be built on an id staying the same. If the tree is not there The left dock is one of the column toggles at the right-hand end of the menu bar, left of the page title — three of them on General Setup, one per column — and its title is Toggle the Control Tree / editor dock. Switching it off removes the dock whole, tree and editor together, and the browser remembers the choice, so the dock is still gone after a reload. The same button switches it back on. General Setup's middle column has a toggle of its own beside it, which is the other way that page can arrive looking short of a column. See Also Basics — the rest of what is true on every screen The Application Window — the menu bar the Page dropdown sits on, and what keeps a visited screen alive between visits Signing In — the screen that has no menu entry because the service raises it Projects — what a project change does to a tree, and to the node an address selects Preferences — the two checkboxes behind the controller nodes, and the setting that changes what a tree carries"
  },
  "manual/basics/index.html": {
    "href": "manual/basics/index.html",
    "title": "Basics | HiAPI-C# 2025",
    "summary": "Basics This section covers the sign-in gate in front of the application and what is true on every screen behind it: the frame that stays put while the page area changes, the project the rest of the application is configured against, the ways one screen leads to another, and the surfaces that report what the service is doing. The task sections build on it rather than restating it. The pages below are ordered as the application presents them: the gate, the frame, the project, the screens, the settings, the messages. For a first end-to-end run rather than a reference, start with Basic Machining Simulation. Pages Signing In — Whether the service asks for a sign-in, what to do when it does, and what happens when it cannot answer The Application Window — The menu bar, the page area and the footer, and what a project change does to them Projects — Creating, opening, saving and closing a project, and what Save As does and does not copy Finding Your Way — The screens the Page menu reaches and the ones it does not, selecting inside a tree, and linking to a node Preferences — The settings the service keeps for everyone on it, and the ones the browser keeps for the device it is sitting at Messages and Logs — The footer's three channels, the four session message tabs and the service log, and which answers which question See Also Setup — configuring the equipment, once a project is open Running a Simulation — building a mission and playing it, once the equipment is set up Utilities — the supporting screens beside these tasks"
  },
  "manual/basics/messages-and-logs.html": {
    "href": "manual/basics/messages-and-logs.html",
    "title": "Messages and Logs | HiAPI-C# 2025",
    "summary": "Messages and Logs Where a message lands decides how long it lasts and who else can see it, and that is usually more useful than what it said at the time. The toasts and the footer belong to one browser and are gone at its next reload; the four session message lists and the day's log file are held by the service. Picking the right surface is most of the difference between a specific question and a vague one. Where a message can land The application has several places to put a message, and they do not carry the same things. A toast — bottom right, for a few seconds, then gone. The only surface that interrupts, and the only one that keeps nothing itself. The footer's latest line, and the recent list behind it — every toast that carried any text is copied here before it is shown, so this list is the toast's afterlife. Only a toast with neither message nor caption is skipped, and a small number of status lines are written straight here and never toast at all. The footer's session strip — the middle of the bar, drawn once a run has produced something and empty until then. The footer's background zone — the right end, drawn only while a project file operation is in flight, naming the operation and the path it is working on. The Session Messages panel — on the Execution page, four lists kept by the service. The Log Viewer — the file the service itself writes for the current day. The footer summarises; it does not hold. Everything a run reports also goes into one of the panel's four lists, and the panel is where it stays. Messages a project load raises Opening or re-reading a project can report holes in it — a referenced STL missing from disk, or a mesh-geometry .wct file a raw geometry names but that is not there. None of these fail the load. The project opens, the body that needed the missing file simply comes up without its geometry, and the action still reports success. The message is the only thing that says otherwise. These messages then take a path of their own, and it has a consequence worth knowing before you rely on it. A project file operation runs outside any session, so the panel's four lists — which belong to the service, and are where everything a run reports stays — never see them. Instead the first five errors and warnings are toasted, anything past that goes straight to the footer's recent list, and one more toast says how many did not get their own. Anything milder than a warning is not surfaced in the window at all. That leaves the footer's recent list holding the only copy in the window, and that list is the browser's: a reload empties it. So read the messages when a project opens with pieces missing, or read the service log, which has them either way. The Session Messages panel will not. The footer The left region is this browser's own record and nothing else's. The list behind the latest line is newest first, capped at a hundred entries, emptied by its Clear button and by a reload, and written down nowhere — nothing about it survives closing the tab. Each entry keeps the wording it was raised in, so switching the language leaves the list as a mixture while the panel's lists re-render at once. The frame page describes the regions themselves: see The Application Window. Nothing marks the list as having something new in it. The button carries no badge and no dot, deliberately, because a toast has already drawn attention once. The consequence is the failure this page exists to prevent: a message raised while another screen was open, or while the window was behind something else, is invisible until that menu is opened by hand. Opening it after an action that seemed to do nothing is the cheapest check available. The middle strip is the other way round — the service pushes it, so every connected browser sees the same run activity, and each browser keeps its own short ring of the last entries behind it. What it last showed stays on the bar after the run has ended; a project change is what empties the ring and takes the strip away with it. A cursor line carries Sn and the sentence index it sits on; a message line carries whatever anchor the message supplies. Two limits are worth knowing: the strip mirrors the newest message across three of the four lists — nothing from NC Manipulation reaches it — and it is sampled rather than recorded, so messages arriving faster than it refreshes never appear on it at all. The lists on the service drop nothing. The session message panel The panel sits on the Execution page, in the middle column, below the 3D Rendering Canvas. Its header row reads Session Messages and stays visible when the panel is collapsed, so a grey strip with that name on it is the panel, shut. The whole column can be switched off, and nothing on the page says so. The column quick-toggles in the middle of the menu bar include one whose tooltip reads Toggle the Execution canvas & messages column; with it off, neither the panel nor its header row is drawn, and the page simply looks like it has fewer parts. That choice is the browser's and survives a reload. The expanded or collapsed state of the panel itself is not: it is kept by the service, and is therefore the same for every browser that opens the page afterwards. Four tabs, each a separate list: Tab What it holds Shell The session's own lifecycle and routine progress — what began, what finished, what was refused. It is empty outside a session, because the list is created with the session. NC Diagnostics What the NC pipeline reported while playing a program. Step Diagnostics What was reported against a machining step rather than against program text. NC Manipulation What converting a played program to NC, or optimising one, reported. Each such run clears the list before it starts filling it again. A tab shows a small count badge only once its list has something in it, so an empty sink is a tab with nothing beside its name. Where a message carries a position, the row shows it in a monospaced anchor column: a step diagnostic names its step, and its block as well when it has one; an NC diagnostic names the block's position in execution order, and its tooltip adds the source file and line where the diagnostic carries them. Not every NC diagnostic has one — a complaint about the pipeline rather than about a particular block has no anchor to show, and shell messages never have one. A run of consecutive identical messages arrives already folded into a single row with a multiplier badge. A row with more behind its one line carries a chevron; clicking it opens what the message brought with it, with a Copy of its own. Each tab filters independently: a Severity list, a Category list, a Filter text… box, and a Reset. The badge at the right of that toolbar reads two numbers separated by a slash, and they count different things — rows currently shown on the left, raw messages on the right, so folding alone makes them differ, and on a long session the left number stops at the most recent thousand while the right goes on counting. That badge is also the tab's connection indicator: it is outlined green only while the connection behind that list is up, and its tooltip names the state. Export writes the tab's filtered rows to a CSV file. Important Two different controls on this screen answer to Reset, and only one of them is labelled with it. The labelled one sits in each tab's filter toolbar and clears that tab's three filters and nothing else. The other is the transport group's eject button, which carries no text at all and reads Reset only in its tooltip; it ends the session and empties three of the four lists — Shell, NC Diagnostics and Step Diagnostics. Only NC Manipulation is left standing, and the same is true of a project change: opening, reloading, creating or closing a project empties the same three and leaves that one alone. It is the list to read for what the last conversion or optimisation said, long after the run that produced it has been reset away. The lists are the service's, not the browser's. They survive a reload, a move to another screen and a second tab opened on the same service, and two browsers watching the same run read the same four lists. That is also what makes collapsing the panel harmless. Collapsing it takes it down entirely rather than hiding it, and all four connections drop with it. Nothing is lost, because nothing was being held here. What does not come back is the arrangement: re-expanding builds the panel fresh, on the first tab, with every tab's severity, category and text filters back at their defaults. The service log Show Log, near the right-hand end of the menu bar, opens the Log Viewer at /preference/log. Its tooltip reads View the application log, and the page it opens is titled Log Viewer. The viewer shows one file: the one the service is writing for the current day. There is no way to reach an earlier day's file from this page. Read the header row for what is on screen — the day the file covers, the time it was last fetched, and how many lines came back. The pane opens at the end of the file, which is where the newest lines are, and stays at the end through later fetches unless it has been scrolled away from the bottom. Press Refresh for a fresh copy, or switch Auto on and choose an interval — two, five, ten or thirty seconds — to have it re-fetched on its own. Take the text with Copy, or the whole file with Download. Both are unavailable while there is nothing loaded. Switch Auto off before leaving the page. Moving to another screen does not stop it: the page is kept alive behind the one on screen and goes on re-fetching at its interval. Reloading the browser stops it, and so does a project change, because both rebuild the page area from scratch. An empty file and a missing file look almost alike and are not the same thing. Both show No log file for today., and both hide the line count entirely — no count is drawn at all rather than one reading zero, so the caption simply being absent is itself the signal that nothing came back. The day badge is what separates them: when the file exists, the day comes from the service's own clock; when there is no file at all, it comes from the browser's clock in UTC, which need not name the same day. A fetch that fails replaces the pane with the reason and a Retry button, and posts the reason to the footer under the viewer's own name — one of the few lines that reaches the footer without ever having been a toast. The Log Viewer at /preference/log, on a service that has been running for a while. The header carries the page name, the day the file covers, when it was last loaded and its line count, then the Auto toggle — off here — beside its interval, and Refresh, Copy and Download. The lines in view are the service's own connection traffic for a whole screen: everything a page connects — the four message tabs among them — arrives in one block and leaves in another once the page is left, and most of what lies between is the rendering canvas being set up and reporting frames. This is the log of the service, not of the browser. A message seen in the footer reaches it only if the service also recorded it, and much of what it holds was never shown anywhere in the application. Which surface answers which question To find out Read what the last action reported the footer's latest line what was reported while another screen was open the recent list behind it — nothing else will mention it where a run has got to the footer's session strip whether a project file operation is still running the footer's background zone what the session itself started, finished or refused the Shell tab why a program did not do what its text says the NC Diagnostics tab why a move behaved the way it did the Step Diagnostics tab what the last conversion or optimisation reported the NC Manipulation tab, which a reset does not clear why a project opened with pieces missing the toasts it raised, or the Log Viewer — not the Session Messages panel what the service recorded, shown or not the Log Viewer See Also Basics — the rest of what is true on every screen The Application Window — the footer's three regions, and the menu bar Show Log sits on Preferences — the Preference menu that Show Log is not an entry of, and what else the service keeps for everyone on it Projects — the actions behind the footer's background zone, and what a project change clears When Something Goes Wrong — using these lists on a run that did not do what was expected"
  },
  "manual/basics/preferences.html": {
    "href": "manual/basics/preferences.html",
    "title": "Preferences | HiAPI-C# 2025",
    "summary": "Preferences The settings that follow the application rather than the project are kept on two sides: the service, where one value serves every browser signed in to it, and the browser, for the device it is sitting at. The Preference menu is where most of them are set, and the rest are reached from the panel each one belongs to. Which side keeps a setting is the thing worth knowing about it, because that is what decides who else sees the change. Where it is The Preference dropdown on the menu bar, after Project and Page. It carries no OK and no Cancel: every control commits the moment it is pressed. Picking a language closes the language submenu and leaves the dropdown itself open, exactly as the checkboxes do; nothing in the dropdown commits on a close. A setting the service refuses is rolled back in the menu, so the dropdown never shows a value that did not take — the refusal arrives separately, as a message naming what failed. What the dropdown carries Language opens a submenu of the codes the service offers, each row carrying a language's own name over the code that names it — English over en, and the two Chinese scripts over zh-Hans and zh-Hant. The caption on the parent row is the language in force. Picking one re-resolves the interface immediately and without navigating, which is why the confirmation message already reads in the language just chosen. The service keeps this one. Show Physics Options reveals the physics-only parts of two editors, named under Making a physics change take below, and switches the cutter drawn on the Tool House canvas and on the Execution page's CWE canvas from a plain bounding shape to its detailed flute geometry. The service reports whether the physics feature is licensed alongside the setting itself, and without that licence the checkbox is drawn disabled and clear, with nothing in the menu saying more about why. Where the licence is present the setting starts on: a service that has never had a preference saved reports it as on. The service keeps this one too. CSV Controller and CL Controller each add a node of their own to the General Setup tree once a project is open — with no project open neither node is built, whatever the boxes say. Both are kept by the browser, are clear by default, and are never sent to the service. The caption under each box says whether the open project actually plays that kind — This project plays CSV, or Not used by this project — and is blank when no project is open and when the service cannot say; it is read when the menu opens, so it answers for whatever project is open at that moment. What is kept where One service holds one set of values. There is nothing per account: two people signed in under different names read and write the same language, the same physics setting, the same everything else on this side. A change one browser makes is what the next browser to ask will be told. What the service keeps this way is the language, the physics setting, the properties the Execution page lists for a selected step, which of that page's charts, its Session Messages panel and its Step Properties panel are switched on, the General Setup canvas's display options including the work coordinate its marker draws, and the graphic cache budget. The browser keeps the arrangement of the screen in front of it. That is the two tree pages' layout — which columns are shown, how wide the docks are, which tree nodes are left unfolded and which node each tree page reopens on — together with the two controller checkboxes above, and the File Explorer's editor pane, its split and its sort order. Three of the Execution page's panels sit on this side rather than with that page's others: the 3D Rendering Canvas, CWE and Sentence Syntax. The browser also holds a copy of the language, used only to paint the first frame before the service can be asked; the service's value wins every disagreement, so a language changed from another browser shows up here immediately after that first frame. The graphic cache budget is the exception on the service side. A new budget takes effect at once and applies to every browser on that service, exactly like the rest — but the write stops there. It reaches the service's preference file only when some later preference save writes that file out, so a service stopped before any such save comes back on the budget it had before. Making a physics change take Show Physics Options is read while a tree or a tab row is being built, not while one is on screen, so the four routes below are what the tree and the tab row need; the two canvases pick the change up on their own next draw instead. Ticking it therefore changes nothing already built: the tree does not grow the nodes it gates, and the Tool House tab row does not grow the tab, until something builds them again. Folding a branch shut and opening it again is not a rebuild. Four things do rebuild one: Reload the browser. That rebuilds the whole application, every tree included. The project under the session changes — New, Load, Close Project, or a Save As to a location other than the one already open. Every screen the session has built is discarded and built again, and ReLoad does the same on the path already open. On Tool House, select a different tool in the left column and come back. The tab row is built for whichever tool is being shown, so moving between two tools rebuilds it twice. Edit the structure of a branch and that branch alone is rebuilt — adding, removing or re-kinding a mission command, or installing a different tool house — so a branch being worked on picks the setting up without being asked. What appears once one of those has happened: in the Execution tree's Mission branch, the Shot Files Output and Optimization Output blocks under a Post-Execution command; and in Tool House, the cutter's Material section tab. Tool House at /tool-house/1/cutter/material, with the setting on. The tab row above the editor — General, Cutter, Holder, Clamping, Int. Holder — belongs to the tool; the section tabs below the Cutter fields belong to the cutter, and Material leads that row only while the physics setting is on. With it off the row starts at Flute Profile and the address is left alone, so a link naming the Material tab opens a complete, plausible-looking panel that is not the one it named. Settings that live elsewhere Show Log is a button on the menu bar, not an entry of this dropdown. Step Present — which properties the Execution page lists for the selected step — opens from the title bar of that page's Step Properties panel, in the Step Info column; the small button there is titled Step Present — choose which properties are displayed. Its Clear and its Reset each ask for confirmation before they act, and its lists of keys are fetched again every time it opens and again whenever the language changes. Graphic Cache is reached through a panel rather than through the menu bar. On the Execution page, with the canvas-and-messages column shown and the 3D Rendering Canvas panel expanded, that panel's title bar carries a toolbar; its Meshed Geom dropdown holds Graphic Cache, which opens the Graphic Cache (MB) panel — a Lower and an Upper field bounding a Current field and its slider. The toolbar belongs to the canvas and is only lent to the title bar, so collapsing the panel takes the whole toolbar away with it, Graphic Cache included. Taking settings to another machine Nothing carries a preference from one installation to another. A second service starts on the built-in defaults — English, and the physics options on wherever the licence allows them — and has no preference file at all until something is saved on it, so an installation that has never had a preference changed has nothing to carry in the first place. What the browser keeps travels less far still. It belongs to one browser profile on one device, so the same person at a second machine, or in a private window on the same one, finds the tree pages laid out as they come and both controller checkboxes clear. See Also Basics — the rest of what is true on every screen The Application Window — the menu bar this dropdown sits on, and what a language switch does to the footer Messages and Logs — where the Show Log button goes, since it is not an entry here Signing In — why one language setting serves everyone on the service Finding Your Way — the tree nodes the two controller checkboxes add, and the branch the physics setting changes"
  },
  "manual/basics/projects.html": {
    "href": "manual/basics/projects.html",
    "title": "Projects | HiAPI-C# 2025",
    "summary": "Projects A project is the whole of what a simulation runs against: the machine tool, the spindle capability, the background and coolant conditions, the fixture, the workpiece, the tool house, the controller and the NC programs a mission plays. It is a project file together with the folder that file sits in, and the Project dropdown on the menu bar is where one is created, opened, saved and closed. The equipment and mission screens are editors on whichever project is open, so a change of project reaches all of them at once. Where it is The Project dropdown, at the left of the menu bar beside Page and Preference. Its first row is a read-only field holding the path of the open project — selectable, so it can be copied — and reading No Project Loaded until one is open. The path is written relative to the admin directory the service was started against rather than as a location on the machine running it. That row is the only place the path stays put; everywhere else it is transient — a line drawn while something is happening, or a record of something that has. While a project action is running, the footer's background zone names the action and the path together, as Loading project: … and its equivalents for the other entries. The toast that reports the finished action carries the path as its caption, and that line outlives the toast in the footer's Recent messages list. The service holds one open project rather than one per browser, so every browser connected to it is working on the same project. What each entry does Entry What it does New Creates a project at a chosen path and opens it, refusing a path that already holds a file Load Opens an existing project file ReLoad Re-reads the open project from its own path, discarding anything unsaved Save Writes the open project back to its own path Save As Writes it to a chosen path, which then becomes the open project Close Project Closes it, leaving the application with no project ReLoad, Save, Save As and Close Project are greyed out until a project is open. New and Load are always selectable. The three entries that need a path — New, Load and Save As — open the shared file browser as a picker, filtered to HiNC Project (*.hincproj). It never offers the Resource root: the Admin root is always there, and the Project root beside it only while a project is open. It opens at the Admin root — in the folder the open project sits in, when there is one. Saving forces the extension, so a name typed without one still gets it. What a project actually is The project file is an XML document of references. Values that mean nothing outside this one project are written into it directly, while the pieces that are shared, large or edited on their own — the machine chain, the spindle capability, the workpiece and cutter materials, the cutting parameters, the mesh geometry — are held as references to files beside it, each named by a path relative to the project file's own folder. Opening the project file in a text editor shows those references rather than what they point at. Important A reference that points at nothing does not stop the project opening. Load and ReLoad read what they can and report what they could not — a missing STL, or a mesh-geometry .wct file a raw geometry names — and the project comes up with that body simply having no geometry, the action still reporting success. The message is the only thing that says otherwise, and it is not kept where a run's messages are kept: see Messages a project load raises. A project is therefore a folder at least as much as a file. Copying one to another machine, archiving one, or handing one to somebody else means taking the folder. The demo project's own folder, at /util/file-explorer/Project. The File Explorer's root switcher, beside the page name, is set to Project — the root that exists only while a project is open, and that resolves to the folder holding the open project file — and the path field reads ., the root folder itself. Three folders sit at the top, MachineTool, NC and Output, and five files below them: the cutting parameters and the workpiece material, the project file itself at about 135 KB, the spindle capability, and a cutter material. The right-hand pane is the explorer's text editor, waiting on a file to be given to it. Warning A Save As into a new folder can produce a project that finds none of its programs. Save As writes out every side file the project file holds as a reference, into the new folder and at the same relative place, and nothing it does not. What it leaves behind is whatever the project names as a plain path instead of as a reference — and the NC programs a mission plays are named that way. Nothing rewrites those paths either, so the saved project still asks for NC/…, now underneath the new folder, where nothing has put it. The programs have to be brought across by hand, or the Save As aimed at a folder that already holds them. The folder a run writes its output into is named the same way, and it is not a dependency of the same kind: nothing has to put it there, because the writers create it on demand under the folder the open project was read from. A Save As does not move it — a run still writes beside the folder the project came from, until that project is opened at its new path. What a project change does to the rest of the window What decides a rebuild is the path changing, not the entry chosen. New, a Load that picks a different project, Close Project and a Save As to a location other than the one already open all change it, and each throws away every screen the browser has built and rebuilds against whatever the project is afterwards — which is what stops one screen showing values from a project that is not open any more. ReLoad always rebuilds as well, being the entry meant for re-reading the same path. A Load that picks the project already open rebuilds nothing: the file is read again on the service, but the screens keep what they were showing. The Application Window states the same rule from the frame's side, and covers what a rebuild costs a screen carrying unsaved state. How far a change travels beyond the browser that made it is not the same for every entry. The three that change which project the service holds open are announced to every browser connected to it, so all of them follow. ReLoad re-reads the same path: the browser that asked for it rebuilds, while a second browser — whose path did not change — carries on with what it was showing. Save As announces nothing at all. The service moves onto the new path, and only the browser that performed the Save As is told, in the reply to its own request. Every other browser goes on displaying the old path in its Project dropdown, although the service is working with the new one underneath — so a Save from any of them writes to the new path. A stale row corrects itself the next time the service reports its state to that browser: a reload, another project change, or a run being started, paused, finished or reset from any browser. New, Load, ReLoad, Save and Save As take a turn each. A second one asked for while the first is still running is refused rather than queued, and the refusal arrives as a warning reading Another project operation is in progress. Please try again. Close Project takes no part in that turn-taking: it neither waits for a running operation nor holds one off, and it never raises the warning. Losing work Nothing keeps track of whether the open project has unsaved changes. No marker in the menu bar or in the path row says the project has been edited, there is no prompt in front of ReLoad or Close Project, and nothing at all stands in the way of a browser tab being closed or reloaded. Both ReLoad and Close Project discard what the service is holding and has not written, in silence and at once; a Save beforehand is the only thing that keeps it. Save As asks nothing either. Its dialog opens on the open project's own folder with the open project's own file name already filled in, and nothing checks whether a file is already at the path chosen: confirming writes over whatever is there. Confirming on the name as it arrives therefore overwrites the project that is open — which is harmless, being what Save does — but the same confirmation one folder away overwrites a different project just as quietly. New is the one entry that refuses: it will not create a project where a file already exists, and reports that as an error whose message can carry the location in full. Before one is built The data to collect from the machine owner before a project can be built is a checklist of its own: Project Data Checklist. The order the pieces then go together in is Project Construction. See Also Basics — the rest of what is true on every screen The Application Window — the menu bar this dropdown sits on, and the page rebuild a project change triggers Finding Your Way — the screens a project change rebuilds, and what happens to a selection in one Messages and Logs — the footer's background zone and the toasts a project action raises, and where they can be read afterwards File Explorer — the browser these entries open as a picker, and the Project root that is this folder A Mission That Resumes — what a project's folder has to hold for a run to restart where the last one stopped"
  },
  "manual/basics/signing-in.html": {
    "href": "manual/basics/signing-in.html",
    "title": "Signing In | HiAPI-C# 2025",
    "summary": "Signing In The sign-in card is the /login route, and whether anyone ever reaches it is the service's decision rather than the browser's. With the gate on, the service's data and its live updates stay closed until a browser has signed in; with it off, the route sends every visitor straight back into the application. A sign-in buys admission and nothing more — the service matches a name and a password once, then carries the name only to label the sign-out button, and nothing it does afterwards depends on which account was used. Whether the gate is on The Auth section of the service's configuration decides it, through its Enabled flag. The flag falls back to off when nothing sets it, so a service whose configuration carries no Auth section, or carries one with the flag off, runs with no login at all. The configuration as shipped turns the flag on and supplies one account, so a service started from it asks for a sign-in. The accounts are the Users list in that same section — username and password pairs, read once when the service starts. Every entry grants exactly the same access: there are no roles, no group memberships, and nothing at all is kept per account. There is also no way to create an account, change a password or recover one from inside the application. All three are edits to the service's configuration, made by whoever runs the service, and they take effect at its next restart. What the gate closes is the service's own surface: the requests each screen makes for data, and the live channels that keep those screens current. It does not close the page. The application shell, the brand image and the sign-in card itself are served before authorization is consulted, which is what lets the card be drawn for a browser that holds no session. Signing in The card asks for one pair of credentials, under the prompt Please sign in to continue. Type the account name into Username and the password into Password. The username field already holds the focus when the card appears, and the eye icon at the right of the password field toggles the typing visible. Submit with the Sign In button, or by pressing Enter in either field. Neither field is checked in the browser, so whatever is entered — an empty pair included — goes to the service, and a refusal comes from there rather than from the form. It arrives as one red line under the password field, Incorrect username or password, and the card stays as it is. A successful sign-in reloads the application at the screen that was wanted. When the browser was sent to the card while trying to reach a particular screen, that address travels with it in the card's redirect query argument — ?tree= selection included — and is where the sign-in returns to. A browser that came to the card on its own lands on the Execution page. Two smaller things the card carries. The grey line below the name is a version mark, the same version the menu bar shows from inside. And the card's own language is whichever this browser last used, or the browser's own language on a first visit, because the language setting belongs to the service and is behind the gate like everything else there; after signing in, the interface follows that setting — one value for everyone on the service — chosen in the Preference menu's language submenu (see Preferences). The sign-in card at /login, in a browser holding no session. The card is all the screen holds — none of the application frame is drawn behind it — with the version mark and the prompt under the name, the focus already in Username, and the eye toggle at the right of Password. When the sign-in page does not appear Three situations account for it, in the order they are likely. The gate is off. With no Auth section, or with Enabled off, the /login route redirects every visitor back into the application instead of showing a form. From inside, the quickest tell is the menu bar: a service with no gate carries no sign-out button. The browser is already signed in. Its session cookie is still good, so the card is skipped and the screen that was asked for opens directly. The service could not say. The application asks the service once, on its first navigation, whether a gate exists and whether this browser has passed it. If that question fails to get an answer, the application assumes there is no gate and lets the browser through — it fails open. On a service whose gate is in fact on, the result is a window that opens on the screen that was asked for and can then load nothing: no project, panels that never fill, and requests the service is refusing behind them. The menu bar is the giveaway — no version mark beside the brand image, and no sign-out button at the right end, because both are filled in from the answer that never arrived. In this state nothing offers a sign-in card and nothing redirects to one. Reloading the page puts the question again; it is re-asked on every navigation until it is answered, and once the service answers, the browser reaches the card in the ordinary way. Signing out The sign-out button sits at the right end of the menu bar, after Show Log. It is labelled with the signed-in user name — or with Logout when the service reported no name — and its tooltip reads Log out. It is drawn only while the gate is on and this browser is signed in. Press it to end this browser's session. The page is torn down and rebuilt at the sign-in card. If the request to the service did not get through, the service still holds this browser as signed in, so the card sends it straight back into the application — press the button again. What ends is one browser's admission. Another browser signed in under the same account is untouched and carries on working: the service keeps no register of who is connected, so there is no notice that an account is in use elsewhere, and no limit on how many browsers may hold it. When a session ends on its own A sign-in belongs to the browser session, so closing the browser ends it whatever the configuration says. While the browser stays open it lasts up to the number of hours in the Auth section's SessionHours setting — eight in the configuration as shipped, and never less than one whatever the setting says. Sliding expiration is on by default, and the service describes that setting as refreshing the expiry with activity. Nothing announces that the end is near. There is no countdown, no prompt and no way to extend. The first sign is the sign-in card, which arrives the moment a screen next asks the service for something and is refused. Recovery is a second sign-in. The screen that was open travels in the redirect argument, so signing in comes straight back to it; what does not come back is anything entered or arranged on that screen and not yet saved, because a sign-in reloads the application from scratch. The session is the browser's admission and nothing else — ending it changes what that browser may ask for, not what the service is holding. Locked out A gate that is on over an empty account list admits nobody, and it looks exactly like a mistyped password — the same single red line, for every name tried, in every browser. Nothing counts attempts and nothing locks after a bad one, so a refusal that repeats for every account anyone can think of is the symptom to read as a configuration problem rather than a credential one. The way out is one entry. Add a username and password pair to the Users list in the Auth section of the service's configuration, then restart the service — that list is read once at startup. The state is neither permanent nor damaging. The service runs normally the whole time it is turning browsers away; it simply has no credential to match one against. See Also Basics — the rest of what is true on every screen The Application Window — the menu bar the sign-out button sits at the end of Finding Your Way — the screens a sign-in returns to, and the addresses that name them Preferences — the settings the service keeps for everyone on it, the language among them"
  },
  "manual/basics/the-app-window.html": {
    "href": "manual/basics/the-app-window.html",
    "title": "The Application Window | HiAPI-C# 2025",
    "summary": "The Application Window One frame surrounds every screen: a menu bar across the top, the current page between, and a footer along the bottom. The frame is built once and stays mounted for the whole session, so everything described here is present on every page. A project change is the one event that reaches into it and rebuilds what the middle holds. The whole frame at /execution, with the demo project open. Only the column quick-toggles and the connection badge, in the middle of the bar, are there because of the page underneath them — the logo, the three dropdowns, the page title and Show Log sit on the bar whatever page is open, and the sign-out button turns on whether a sign-in is asked for rather than on the page. The strip along the very bottom is the footer, reading Ready because nothing has been reported yet. The menu bar From the left: the brand logo, a version badge, and the Project, Page and Preference dropdowns. The badge is filled from the service's own reply about itself rather than from anything in a project, so it carries a version before a project is open. It is drawn only when that reply carried one, so a service that cannot answer its own status probe leaves the space empty. The bar is not drawn on the sign-in screen at all — the same version appears under the logo on the sign-in card instead. The rest of the bar is pushed to the right, and renders in this order: The column quick-toggles — one button per column the current page actually has: four on Execution (the dock, the canvas-and-messages column, the Strip Charts column, the Step Info column), three on General Setup. Each glyph is a small map of the page with its own column filled, and each tooltip names the column it toggles. Tool House lays itself out with draggable splitters and gets no buttons here. The connection badge — the Execution page only. See below. The current page's title — the destination's own title, which is where two controls read differently from where they land: the Page menu's Legacy-Controller entry opens the page titled Controller, and Show Log opens the page titled Log Viewer. Show Log — present on every page. The sign-out button — labelled with the signed-in user name, or Logout when the service has no name for it. It is there only while the service asks for a sign-in. The page area Everything between the bars is the current page, and every page reached during a session stays built: there is no cap and nothing is excluded. Coming back to one finds its component state, an edit left half-finished and an established rendering connection exactly as they were. Two things it does not carry over. Nothing restores a scroll position inside a panel: coming back to a page finds its panels scrolled to where a fresh mount would put them. And a browser reload is not a navigation — it rebuilds the whole application and empties the cache; what survives it is what lives outside the page area, namely the address (a ?tree= selection in it included) and the layout the browser keeps for itself. F5 to F8 belong to the Execution page. They drive its transport — F5 starts or resumes, F6 pauses, F7 runs one NC line, F8 runs one machining step — and they are bound only while that page is the one on screen, so on every other screen F5 is the browser's own reload. A key whose button is not available at that moment, or that is pressed with the focus in a text field, is handed back to the browser instead. That matters most for F5: while a run is in progress the start button is unavailable, so the key reloads the page and takes the session with it. What a project change does New, Load, ReLoad and Close Project discard every page the session has built and rebuild it against whatever the project is afterwards — nothing at all, after Close Project. That is what stops a screen showing values from a project that is not open any more, and it is also why in-page state that was never saved does not survive one. What decides a rebuild is the path changing, not the action. A plain Save never rebuilds. Save As back to the path already open behaves exactly like Save and rebuilds nothing, while Save As to a different location moves the window onto that path and everything rebuilds. For the same reason, picking the already-open project out of the Load browser rebuilds nothing either — the file is read again on the service, but the screens keep what they were showing. ReLoad is the entry to use for that, and it is the one that always rebuilds. The same rebuild runs once at startup, with nobody having done anything: a browser reaching a service that already has a project open receives that path as its first project change and builds on it. New, Load, ReLoad, Save and Save As run one at a time. A second one started while the first is still running is refused rather than queued, and the refusal arrives as a warning reading Another project operation is in progress. Please try again. Nothing is rebuilt and nothing is lost. Close Project takes no part in that turn-taking and never raises the warning. The footer A 29-pixel strip holding three regions, each independent of the other two. Left — the latest reported line, with the recent ones behind it. The text is the most recent message the application has raised, or Ready before there has been one, and its tooltip carries the full text with whatever caption came with it. The icon in front decodes the severity: a grey information mark for a plain status line, a green tick for a success, an amber triangle for a warning, a red mark for a failure. The clock button beside it opens Recent messages — newest first, capped at a hundred, each row repeating its severity as a coloured strip down the left edge and carrying the time it arrived. That list belongs to this browser and this session: Clear empties it, a reload empties it, and it is written down nowhere. Middle — the session strip. It is drawn only while a run has produced something, and the space is simply empty the rest of the time. A glyph leads each line — a locator mark on a cursor tick, the message's own severity mark otherwise — and an anchor follows it in a monospaced prefix wherever the entry carries one: a cursor line carries Sn and the sentence index it sits on, a message line the anchor the message itself supplies. Hovering opens the recent activity behind it; clicking pins that list open. Right — the background zone. It appears only while a project file operation is in flight, names the operation and the path it is working on, and vanishes when the operation ends. Switching the language re-resolves the interface at once and without navigating: the menus, the page title in the bar and the browser tab title all change. The two message regions do not follow. Each line in the recent list and in the session strip keeps the language it was raised in, so a footer read after a language switch is a mixture by design. The connection badge The badge on the menu bar belongs to the Execution page alone; the other canvases carry their own badge inside their panel. It aggregates that page's rendering connection with the service connections behind its panels, and reads a green connected only while every connection in the set is up — orange while any of them is (re)connecting, and red only once none is connecting and one is still down. The set is not fixed. The rendering connection is always folded in on that page, but a service connection joins only while something is actually using it — an open panel, or the frame itself. One that nothing is consuming is left out rather than forced to connect. ExecutionStatus has a consumer for the whole session and is therefore always in the set; the rest come and go, which is why opening and collapsing panels changes what the badge reports. A green badge means every connection in use is healthy rather than every connection that exists. Only the two problem states carry a tooltip — when everything is connected there is nothing to explain and none appears. The tooltip lists one row per connection, Rendering, Shell, NcDiag and the rest, and those names are identifiers rather than interface text: in a translated session only the state beside each name changes language. The buttons that hide those panels' columns are remembered per page. The two tree pages each keep their own column choices, while the dock widths and the list of unfolded tree nodes are single settings both of them share — widening the dock on Execution widens it on General Setup too. See Also Basics — the rest of what is true on every screen Signing In — what puts the sign-out button on this bar in the first place Projects — the Project menu, and what each of its entries does Finding Your Way — the Page menu and the screens behind it Preferences — the Preference menu, and the settings that are not in it Messages and Logs — the surfaces the footer summarises, and the log behind Show Log Starting and Stepping — the transport those F5–F8 keys drive, and the connection the bar's badge reports on Watching the Run — the two columns the quick-toggles show and hide"
  },
  "manual/index.html": {
    "href": "manual/index.html",
    "title": "Manual | HiAPI-C# 2025",
    "summary": "Manual How to operate the HiNC web application: what is true on every screen, the equipment a simulation runs against, the run itself, and the supporting screens beside it. This section is reference knowledge looked up on demand — it describes the application as it is, screen by screen, rather than carrying a job from end to end. Ordered as a job goes: learn the frame, build the setup, run it, and reach for a utility when the job needs one. For a first end-to-end run rather than a reference, start with Basic Machining Simulation. Chapters Basics — The sign-in gate and what is true behind it: the window frame, the project the rest of the application is configured against, the ways one screen leads to another, the preferences, and the surfaces that report what the service is doing Setup — The machine tool, spindle, fixture, workpiece and controller a simulation runs against, where each is placed relative to the machine, and the tool house and coolant around them Running a Simulation — The command list a run executes, playing it, watching it, reading a single step, and diagnosing what went wrong Utilities — The supporting screens the Page menu lists below its first separator: the server's file explorer, the mechanism builder, and the legacy controller settings See Also Technique — the durable knowledge behind what these screens compute App Anatomy — the same screens broken down component by component, with the source behind each Workflows — end-to-end task guides that put these chapters together"
  },
  "manual/run/a-mission-that-resumes.html": {
    "href": "manual/run/a-mission-that-resumes.html",
    "title": "A Mission That Resumes | HiAPI-C# 2025",
    "summary": "A Mission That Resumes A mission written as one Script runs, and tells you nothing. The same run written as commands reads as values, switches a row at a time, and — with two Record Meshed Geometry entries around the program — restarts from where the last run got to instead of from the stock. This page is the layout that gets you all three. It is a recommendation, not a rule: every command is placeable anywhere, and Building a Mission is the mechanics. The shape # Command Category Why it is there 1 Physics Setup the run's switches, above everything they govern 2 Machining Resolution Setup must precede the first record — see below 3 Collision Detection Setup 4 Script Program only what no command covers 5 Record Meshed Geometry Output Cache/<stage>-init.wct — the stock, meshed once; drop this row where the stock is already a recorded mesh 6 Program File Program the stage 7 Record Meshed Geometry Output Cache/<stage>-done.wct — the result of the stage; the next stage's stock 8 Post-Execution Output what the run writes out Every entry keeps its own checkbox, so any of them can be switched off without being deleted and without its settings being lost. Why commands rather than one script A script sets the same values, and that is the whole of its advantage. Against it: A row states its value. Machining Resolution [0.125 mm], Physics [On], Program File [NC/facing.ptp] — the mission is legible without opening anything. A checkbox replaces commenting-out. A commented line is invisible in the tree and survives into the saved project as text nobody reads. A cleared checkbox greys the row and says so. The fields are typed. A resolution is a number field with a unit, not a line that has to compile. The order is the run. Moving a setting above or below a program is a drag, not an edit. Leave in the Script only what no command covers, and title it for what it is. Resolution before the first record Machining Resolution has to sit above the first Record Meshed Geometry entry. The record writes the workpiece as a meshed geometry, and the mesh is built at whatever resolution is in force when it runs. Put the resolution command below it and the cached mesh is built at the previous value — which the next run then reads back, silently, as if it were the one you asked for. The same holds for anything else that changes what the geometry is: the Setup commands go first. What Read On First Or Write does Record Meshed Geometry has four actions, and the fourth is the one that makes a mission resumable: Action What it does No Action nothing; the entry is a placeholder Read always loads the file into the session Write always writes the session's geometry to the file Read On First Or Write reads the file if it exists and no machining step has been produced yet this run; otherwise writes The condition is a property of the run, not of the entry — there is no per-entry counter. It is also about steps, not about cutting: a pass that only positions the tool still produces steps, so a program that removed no material still counts as having played, and the next record writes rather than reads. Only a program that produced no steps at all — no tool selected, no motion, or a file that was not found — leaves the run in its opening state. So in the layout above: First run. Neither file exists. Entry 5 writes the meshed stock; the program plays; entry 7 writes the result. Every run after. Entry 5 finds its file and nothing has played, so it reads — the stock is not re-meshed. The program plays, so by entry 7 something has played, and it writes the fresh result. Re-running one stage. Clear the checkbox on the stages you do not want. The first record entry that is still ticked becomes the first thing to run, so it reads its cache, and the run picks up from there. Clearing a stage clears everything in it, including its record. A stage is a checkbox around a list, and a cleared one is skipped whole — so in a chain where the cache a stage resumes from is the previous stage's end-of-stage record, clearing that previous stage removes the very entry that would have loaded it. The run then starts from the stock, quietly and without an error. Either leave the earlier stages ticked and clear only the Program File rows inside them, or clear them but keep the one stage whose end-of-stage record you are resuming from, with its own programs cleared. The rule is simply that the record you are resuming from has to be reachable: every checkbox above it stays ticked. That last line is the point of the layout. The cost of getting back to the middle of a long job is one file read. The stage-0 cache goes stale, silently This is the price of the layout, and it is worth stating on its own. The record above the program caches the stock, meshed. From the second run onward that cache is what the run starts from — so changing the workpiece geometry, its initial resolution, or the Machining Resolution has no effect until the cache is cleared. Nothing warns you: the run simply reproduces the previous one. After changing any of those three, Reset the stage-0 record (or delete its file) before reading anything into the result. Give a stage a stage-0 record only when the stock costs real time to mesh — a large mesh or a solid the kernel has to build. Where a stage's stock is itself a recorded mesh, as it is for the second operation in a chained pair, a stage-0 record buys no time at all and freezes the chain: the upstream stage can be re-run all it likes and this one keeps reading the copy it took the first time. There, the previous stage's own end-of-stage file is already the cache, and the stage needs no record above its program. Resuming, then cutting finer A record freezes the workpiece as meshed at the width in force when it ran. Reading one back does not pin the rest of the run to that width: put a finer Machining Resolution below the record and above the next program, and that program's removal is built at the finer width. Measured on a roughing stage recorded at 0.5 mm — read back, then cut at 0.0625 mm — the cut ran at 0.0625 mm and took 779 s where the same program at 0.5 mm took 27 s, for five times the mesh's own memory. The request binds; the record is not a ceiling, and at this end of the ladder it is not free either. What reading back cannot do is add detail that was never stored. Surfaces inherited from the record keep the width they were recorded at; only what the later program cuts is meshed finer. That is normally exactly right — the roughed surface is about to be cut away, and the finish surface is the one the fine mesh is for. So record each stage at the width that stage needs — with one exception: the stage the finishing pass reads from. Everything the finishing tool does not touch keeps that record's width, and that includes the surface the finish is measured against. Choose that one record's width against the finish, then, rather than against the roughing stage it happens to belong to. The earlier stages have no such constraint. Roughing at the finishing width to be safe buys nothing and costs the whole roughing run at the finishing price. This is a different thing from the stage-0 trap above, which is about the record above a program caching the stock: there the frozen mesh is what the run starts from, so the resolution really is stuck until the file is cleared. One record per stage A mission with several Program File entries gets a record after each, plus the stage-0 record where that one earns its place. Name each file after the stage it ends, not after the program that wrote it, so the file that a stage reads is the one named for the stage before it. Do not split one control file into several Program File entries to get finer stages. A program's modal state — units, plane, work offset, absolute or incremental — is established in its header and carried forward; cutting it in half hands the second half to a runner that never saw the header. The stage boundary is a file boundary. What stays in a Script Two things belong there and little else: Process-wide settings with no command of their own. MillingCycleDivisionNum is the standing example: it is process-wide, it survives a runtime reset and a project switch, and a training script that raised it leaks into every project loaded afterwards. Pinning it in the mission is a guard, not a setting. Genuinely one-off session work — see the Script section of The Other Commands. Anything with a command belongs in the command. A script line that duplicates a command's default is worse than nothing: it reads as a decision when it is a leftover. The cache is a by-product Cache/ holds rebuildable artifacts, which is why the record command defaults there. A meshed workpiece is large — hundreds of megabytes at a fine resolution is ordinary — and it is derived entirely from the stock geometry, the resolution and the programs above it. Keep it out of version control, and delete it whenever you want the run rebuilt from the stock: the record command's own Reset clears the file it points at. See Also Building a Mission — adding, ordering, ticking and grouping the entries The Other Commands — what each command kind holds Playing a Program — the two commands that put NC code into a run Starting and Stepping — the transport that plays the list Projects — what a project folder holds"
  },
  "manual/run/building-a-mission.html": {
    "href": "manual/run/building-a-mission.html",
    "title": "Building a Mission | HiAPI-C# 2025",
    "summary": "Building a Mission A mission is the list of commands a run executes, in order. Nothing plays until there is one, and what plays is exactly what the list says — including which entries are ticked and which are not. Where it is The Execution page at /execution, Mission branch of the Control Tree; /mission lands on the same place. This is the page the application opens on. The branch root is the list editor: it is where the list is assembled and rearranged. A command's own settings are edited one level in, on that command's node. Add a command Add Command opens a search-first picker. Type to narrow it: the search matches a command's display name, its internal kind key and the aliases it declares, and an alias matches both by its English key and by its word in the interface language. Arrow keys walk the results and Enter takes the highlighted one. Results are grouped by category. Thirteen kinds ship: Category Commands Setup Machining Resolution, Machining Motion Resolution, Collision Detection, Pause on Failure, Physics Program Program File, NC Code, Script Optimization NC Optimization Config Output Post-Execution, Record Meshed Geometry, Export Meshed Geometry (STL) Flow List What you pick is appended to the end of the list you added it to, and the selection stays on the list rather than jumping into the new command. Nothing is pinned to a position: the order is entirely yours, and every command is placeable anywhere. Add Command is disabled until a project is open. With nothing open the list reads No project loaded; with a project and an empty mission it reads No commands yet and names the button. The set on offer is served by the application rather than built into the interface, so a command kind can appear in this dialog before this manual has a page for it. The picker over the demo mission, at /execution?tree=execution/mission with Add Command pressed. The five category headings are the grouping in the table above, the search box at the top is what narrows them, and the first result is highlighted ready for Enter. Read a row Each row shows the command's kind followed by the detail that identifies it, in brackets. Where you can name a command that detail is the title you typed, so a row still says what it is after it has been named: List [Roughing], NC Code [Face check]. Where you cannot, the command brackets what it holds instead — Program File [NC/facing.ptp], Machining Resolution [0.25 mm], Collision Detection [On] — so a mission is readable without opening anything. Beside the label sit four buttons — up, down, duplicate and delete. Up and down are disabled at the ends of the list. Delete asks first, in a dialog naming the command. Duplicate is a deep copy: a group copies with everything inside it, and the copy lands directly after the original. Clicking a row anywhere but on a button selects that command's node and opens its editor. Tick what runs The checkbox is on the tree item, not in the row, and it is the only thing that decides whether a command runs. Clearing it greys the row and the tree node; the editor stays open and fully editable. Clearing the box on a group greys the whole group, and the run skips the group together with everything nested inside it. Leaving a command in place with its box cleared is how you skip a step without losing its settings, which is what you want while you narrow down a problem. Group with a list List is an ordinary command in the Flow category, and adding one grows a sub-tree: its children are its own entries, edited by the same list editor one level down. That nests to any depth, so a mission can be grouped by operation rather than left flat. A list carries an optional title, entered on its own node above the embedded editor. The row reads List while the title is empty and List [title] once it says something; a title of nothing but spaces counts as unset. The Mission root is the one list with no title field — it reads Mission. The demo mission at /execution?tree=execution/mission: three groups and four loose entries. The tree above shows List [Setup] opened, with the three settings commands inside it bracketing their values; the editor below shows the same seven entries as rows. The greyed Script row is an entry left in place with its checkbox cleared — part of the mission, and not run. Reorder, and move in and out Up and down move an entry within its own list and never change which list owns it. Dragging does more, and where you drop decides which: Drop it on What happens Another row Reorder within this list. A row splits at its midline into before and after. The middle band of a List row Move the entry into that list. The row's outer quarters still reorder around it. The drop-out zone below a nested list's entries Move the entry out, landing directly after the list it came from. The drop-out zone belongs to a nested list's editor and appears only while a row inside it is being dragged. Moving a list into itself, or into one of its own groups, is refused. Dragging serves rearrangement only — dropping text or files on the list does nothing. To bring several programs in at once, use one Program File command's picker and select them together; see Playing a Program. Edit one command Select a command's node. Its editor opens below a control bar carrying the same up, down, duplicate and delete operations the row has, and a note while the command is switched off. A command with one job — Program File, NC Code, Script — puts its whole editor on that one node. A command with several cards spreads them: the general settings stay on the command node and each remaining card becomes a child node beneath it, so a long command is read by walking down the tree rather than by scrolling one panel. Where a card had its own Enable switch, that switch is the child node's own checkbox. Which commands do that, and what each card holds, is The Other Commands. See Also Running a Simulation — the rest of running a job Playing a Program — the two commands that put NC code into a run The Other Commands — what the rest of the command kinds are for A Mission That Resumes — a layout that reads as values and restarts mid-job Starting and Stepping — the transport that plays the list built here Mission Root Panel — the component behind this branch: the list editor, the picker and the three drag landings List Command Panel — the component behind a group: what nesting costs, and what a disabled list skips"
  },
  "manual/run/index.html": {
    "href": "manual/run/index.html",
    "title": "Running a Simulation | HiAPI-C# 2025",
    "summary": "Running a Simulation Everything that happens after the equipment is set up: writing the list of commands a run executes, playing it, watching it, and reading what it did. The Execution page at /execution is where all of it happens — it is also where the application opens. Ordered as a run goes: build the list, play it, watch it, read it, and diagnose it. Pages Building a Mission — The command list a run executes, and the checkbox on each command that decides whether it runs Playing a Program — The two commands that put NC code into a run, and which to use when The Other Commands — The settings, optimizer and output kinds, and the script command: what each is for and where in the list it belongs Starting and Stepping — The transport controls, the F5–F8 keys, and why one line is not one step Watching the Run — The canvas, and the three charts that show the whole mission at once Inspecting a Step — The Step Info column: the sentence, the step, the engagement and the per-revolution charts The Program Branch — The files a run read, the passes it made over each and what every line produced When Something Goes Wrong — Which of the four message lists answers which question, why a row is not an occurrence, and three things that look like faults and are not See Also Setup — the equipment a run needs before any of this Basics — the window, the project and the messages every screen shares"
  },
  "manual/run/inspecting-a-step.html": {
    "href": "manual/run/inspecting-a-step.html",
    "title": "Inspecting a Step | HiAPI-C# 2025",
    "summary": "Inspecting a Step Once a strip chart has told you where, the Step Info column tells you what. Every panel in it is a view of the one selected step — except the panel at the top, which deliberately is not, and the reason for that exception is worth knowing before you read the column. Where it is The Execution page at /execution, rightmost column, switched on and off from the quick-toggles on the menu bar. Most of it stays empty until a step is selected, and selecting one is a click on a strip chart or on the tool path in the 3D canvas. Sentence Syntax, and why it sits outside The top panel is the odd one out, and it is placed outside the step group on purpose: a line of NC need not produce a machining step at all. A tool change, a coordinate selection or a comment is a sentence with no motion under it, so a panel that reads sentences cannot be a member of a group keyed on steps. It shows the sentence's own text and the reading the interpreter made of it, with a badge naming the file, the line and the sentence, and a button that copies the parsed form. Its two empty messages say different things, and the difference matters: No sentence selected — nothing is picked yet. This line has no executed SyntaxPiece — a line is picked, and it did not run in this session. That is an answer, not a gap: the line was skipped, or it belongs to a pass the run never reached, or the session has been reset since. The sentence it follows comes from two directions: selecting a step brings its sentence here, and so does clicking a line in a Program file panel. That is the bridge between reading the program and reading the run. The rest of the column Below the group bar every panel is a view of the same selected step. Panel What it shows Step Properties The step's values, for the fields you have chosen CWE The cutter–workpiece engagement — what the cutter was actually touching Sim Cutting Force Cycle Simulated cutting force through one spindle revolution Sim Spindle Moment Cycle Simulated spindle moment through the same revolution Sensor Cutting Force Cycle The same force as measured by a dynamometer, against time Sensor Spindle Moment Cycle The same moment as measured, against time The group bar above them carries the step number as a badge, or No step selected. That badge is the only place the step index is shown — Step Properties leaves that row out rather than repeat it, which is why the list you configure and the list you see differ by one row. Step Properties shows short names. Hovering a name gives the full one, and the unit follows the value. A field with nothing in it reads -. CWE is a footprint, not a solid. It is a small 3D view of its own, drawing the contact contours the step left behind rather than the volume it swept, because contours are what a step stores. It has its own view controls and a contour-grid toggle, and it reads No cut in this step for a step that removed nothing — a rapid, or a move in air. Two scales, and the join between them The strip charts beside this column and the cycle charts inside it are the same measurements at two scales: the strip charts span the whole mission, the cycle charts span one revolution of one step. Changing the selection on a strip chart re-reads every cycle chart, so scrubbing the mission scrubs the detail with it. The two simulated charts plot against spindle angle in degrees; the two sensor charts plot against time in seconds, because measured data arrives on a clock rather than on a phase. Both sensor charts need measurement data attached to the project; with none, they read No data for step while the simulated pair beside them is full. Each cycle chart's header carries a value boundary — Auto, or a fixed ± bound that pins the scale so two steps can be compared without the axis moving under you — and a reload. The two spindle moment charts carry one more: a Line / Dartboard switch, where Dartboard replots the same cycle as a locus in the plane instead of three channels against the cycle parameter. Clicking a point in a cycle chart marks that point for its whole group. The two simulated charts share one mark in spindle angle; the two sensor charts share another in seconds. The mark survives a switch between Line and Dartboard and a change of selected step. It also reaches the CWE panel: the cutter in that view rotates to the angle you clicked, so “the force peaked here” and “this is what the cutter was touching there” become one picture rather than two. The column with the demo mission paused and a step selected: Sentence Syntax at the top, the step badge on the bar below it, then Step Properties, CWE and the two simulated cycle charts. The two sensor charts are folded away at the bottom — this project carries no measured data, so nothing is lost by leaving them shut. Choosing what Step Properties shows Step Properties does not show everything a step carries — it shows what you asked for, out of a much longer list. The small button on that panel's header opens the chooser, beside the list it configures. Candidates are on the left, grouped into categories; a category header ticks or unticks the whole group, and Add Selected moves what you ticked across. Anything already displayed is greyed with a tick beside it, so the left side never offers you a duplicate. The displayed list is on the right, in the order it will appear: drag a row, or use its up and down buttons, and remove one row at a time or Clear the lot. Reset empties the list entirely. There is no Save button, and that is not an omission. Every add, removal and reorder is written as you make it, and the header reports the write — so the way to undo an experiment is to put the rows back, not to close the dialog. The chooser open over the column, at /execution. The counts in its header are this account's displayed list against everything the run can offer; the green ticks down the candidate side are the rows already on the right. See Also Running a Simulation — the rest of running a job Watching the Run — the mission-wide charts whose selection fills this column Starting and Stepping — stepping the run to land on the step you want to read The Program Branch — the file panels whose line clicks steer the Sentence Syntax panel Selected-Step Info Panel — the component behind Step Properties, and where its values come from Cycle-Line Charts — the components behind the four cycle charts, and the shared cursor mark Step Present Dialog — the component behind the chooser: its categories, its labels and how it persists"
  },
  "manual/run/playing-a-program.html": {
    "href": "manual/run/playing-a-program.html",
    "title": "Playing a Program | HiAPI-C# 2025",
    "summary": "Playing a Program Two commands put a program into a mission, and the difference between them is where the program lives rather than what it does: Program File references a file on disk, NC Code carries the text inside the project. Where they are The Execution page's Mission branch. Both sit in the Program category of Add Command, and both are placed like any other command — see Building a Mission. Which one to use Program File — the program stays a file, and the project stores the path. Editing the file changes what plays next time, so this is what a CAM system's output belongs in. NC Code — the program text is written into the project itself. Nothing outside is referenced, so the project travels complete. Use it for a short probe, a hand-written test, or anything you want to keep with the project rather than beside it. They do not necessarily feed the same reader. NC Code is always brand NC text. Program File plays brand NC, NX-CL or CSV, and which one it uses is a setting on the command. Program File Point it at a program Type the path, or press Browse. Both forms are accepted: a path relative to the project folder, which is what browsing produces, or an absolute path on the server. Browse opens the server's file explorer on the project folder and offers no other root, so anything picked there is project-relative by construction. A program that lives outside the project folder is reached by typing its absolute path into the field instead. The dialog filters in four groups rather than one: Group Extensions NC Files .nc, .anc, .tap, .eia, .mpf, .spf, .cnc, .ptp, .h — the common brand extensions, not all of them CL Files .cl, .cls, .clsf CSV Files .csv All Files everything, and the backstop for a brand extension the first group does not name The picker takes more than one file. The first goes on the command you opened it from; every further pick becomes a new Program File command placed directly after it, in the order you picked them, inside the same list — including inside a group. That is the quick way to bring a folder of CAM output into a mission. Choose the reader Play As decides which reader plays the file: Choice What plays it Auto (by extension) Picked from the extension: .cl, .cls and .clsf play as CL, .csv as CSV, and every other extension as brand NC Brand NC The controller brand's own reader CL (CLSF) The NX-CL reader CSV The CSV reader Auto is the default and is right almost always. Pin one of the other three when the extension would route the file to the wrong reader — a CL file saved as .txt, say. For brand NC, which brand is not this command's business: it is the controller set on the project, and what its words mean is NC Dialects. Read the banner Once the field holds a path, a banner below it reports what the server can see: Found — a green banner with the file's size, its modified time and its line count, and a Preview button that shows the first 100 lines read-only. Not found — an orange banner saying so, and no Preview button. Typing saves the path as you type; the banner refreshes when you leave the field or press Enter. An orange banner is worth trusting: it means the path does not resolve on the machine that will play it, which is not always the machine you are typing on. The first Program File in the demo mission's Roughing group, at /execution?tree=execution/mission/2/0. The path field carries a project-relative path, Play As reads Auto, and the green banner below reports the file's size, modified time and line count with Preview beside it. The row and the tree label both read Program File followed by the path, which is how a mission of several programs stays readable. NC Code Name it Title is optional in the sense that the field may be cleared, but it is not decoration: it is the program name the run reports under, and it is the detail the mission row brackets. A new command arrives with NC Code already in the field; rename it and both the log and the row follow. Write it The editor is a plain monospace area — no line numbers and no syntax highlighting, because this is NC text, not a program in a language the application parses while you type. Line and character counts sit below it and follow what you type. Two buttons act on the whole text, and both are disabled while it is empty: Trim Blank Lines — trims every line and drops the ones left empty. Clear — empties the text, after asking. Typing saves on its own, shortly after you stop; the two buttons save at once. Nothing is checked while you type. The text is stored exactly as written, and a mistake in it surfaces when the mission plays it — in NC Diagnostics, see When Something Goes Wrong. The demo mission's short hand-written pass, at /execution?tree=execution/mission/4. The title above the editor is what the row brackets, and the line and character counts below it are the whole of the feedback this editor gives. After it has played Every program a session read appears under the Program branch, with the passes that went over it and the marks the run left on each line. That is where you see what happened to a line, as opposed to what the mission asked for — see The Program Branch. See Also Running a Simulation — the rest of running a job Building a Mission — the list these two commands go into The Program Branch — what the run recorded against each line The Other Commands — the rest of the command kinds, including the script that drives a session without NC NcFileCommand Panel — the component behind Program File: its fields, its picker and the endpoints behind the banner A Mission That Resumes — the layout these two commands sit in when the run has to be restartable NcCodeCommand Panel — the component behind NC Code: its editor, its stats row and how it saves"
  },
  "manual/run/running-a-simulation.html": {
    "href": "manual/run/running-a-simulation.html",
    "title": "Starting and Stepping | HiAPI-C# 2025",
    "summary": "Starting and Stepping Six buttons and four keys drive a run. What each of them does is short to say; which of them you can press at a given moment is the part worth learning, because the availability of a button is what tells you where the run actually is. Where it is The Execution page at /execution. The transport sits along the top of the editor panel in the left dock, and it is mounted for the Execution root and every node beneath it — so it stays reachable while you are editing a Mission command one level in. There is exactly one of it on the page, and it is the thing that binds F5 to F8. The six controls Control Key What it does Start / Resume F5 Starts the run, or resumes a paused one Pause F6 Holds the run where it is Run one NC line F7 Advances by one line of the program Run one machining step F8 Advances by one machining step Stop — Ends the run Reset — Unwinds the session back to the start Start and Resume are the same button, not two: it reads Start from the beginning and Resume once the run is paused. The two single-advance buttons share one icon and are told apart by a small letter in the corner — L for a line, S for a step. Stop and Reset carry no key. Reset unwinds in the background: the button shows a spinner while it works and the rest of the application stays usable. One line is not one step The two single-advance buttons exist because the two units do not line up. One line of program can produce many machining steps — a long move at a fine machining resolution is dozens of them — while another line produces none at all, because a tool change or a coordinate selection is a sentence with no motion under it. So advancing by one line and advancing by one step land in different places. Use Run one NC line when you are following the program: it stops where the next line begins, which is where the program text you are reading changes. Use Run one machining step when you are following the cut: it stops at the next thing the machine did, which is the unit the Step Info column and the strip charts are keyed on. Stepping by step through a single long move is how you watch one cut develop; stepping by line skips straight past it. What you can press, and when The whole bar is dead until two things are true: a project is open, and the page's 3D canvas has connected to the service. The second one is easy to miss — the connection is what binds the run engine to this page, so a canvas that has dropped its connection leaves every transport button greyed even though the project is plainly loaded. The connection badge on the menu bar is where you check that. With both in place, availability follows the run state: Control Available while the run is Start / Resume ready, or paused Pause running Run one NC line / Run one machining step ready, or paused Stop running, paused, or finished Reset any time a project is open Nothing steps a moving run. Both single-advance buttons are unavailable while the run is going, so the way to step through something you are already watching is to pause first and then step. That is the single most useful thing in the table: the buttons are not refusing you, they are telling you the run has not stopped yet. The bar at rest, with the demo project open and nothing run yet, at /execution. Start, the two single-advance buttons and Reset are live; Pause and Stop are greyed, because there is no run to hold or to end — and the two single-advance buttons carry the L and the S that tell them apart. The badge on the Execution tree item reads ready, and the block on the canvas is uncut. Reading the run state The state rides the Execution item in the Control Tree as a coloured badge — ready, running, paused, finished — so it is readable from wherever you are in the tree rather than only from the transport. The footer along the bottom of the window carries the session's own messages beside it. The same page with the mission paused part way through. The badge now reads paused in orange, Pause has gone grey, and Stop has joined the live ones — so the bar alone tells you a run is open and held. On the canvas the tool path the run has laid down so far is now drawn over the block, and the tabs under it are counting what the run has reported: this mission trips the collision check, which is what the red line in the footer and the number on Step Diagnostics are saying. The keys, and where they stop F5 to F8 are bound only while the Execution page is the one on screen. On every other page F5 is the browser's own reload, and the same is true here in two cases: when the button a key drives is unavailable at that moment, and when the focus is inside a text field. Warning That exception bites hardest on F5 during a run. Start is unavailable while the run is going, so the key falls through to the browser, the page reloads, and the session goes with it. Pause with F6 first. See Also Running a Simulation — the rest of running a job Building a Mission — the command list this transport plays Watching the Run — the canvas and the charts that fill while this plays Inspecting a Step — the column that reads whichever step you stopped on When Something Goes Wrong — what to read when the run does not do what you expected The Application Window — the menu bar's connection badge, and the footer this page's state is reported in A Mission That Resumes — how to lay the mission out so a stopped run restarts from where it got to Execution Tool Bar — the component behind these buttons: the enable rules, the status feed and the key bindings"
  },
  "manual/run/the-other-commands.html": {
    "href": "manual/run/the-other-commands.html",
    "title": "The Other Commands | HiAPI-C# 2025",
    "summary": "The Other Commands Beyond putting a program into a run, a mission can change the session's settings part-way through, steer the optimizer, write out what the run produced, and drive the session from a script. Where they are The Execution page's Mission branch, all from the same Add Command. The Program category's other two commands are on Playing a Program, and the Flow category's one command is on Building a Mission. Settings, one per command The Setup category holds five commands, each carrying one setting: Command What it sets Default Machining Resolution the meshing resolution of material removal, in mm 0.125 mm Machining Motion Resolution how a motion is sampled into steps Feed Per Cycle Collision Detection whether collisions are detected on Pause on Failure whether the run stops at a failure off Physics whether physics is simulated on, where the advanced-physics licence is held Each takes effect from its own position in the list onward. A program above one plays under whatever was in force before it; programs below it play under the new value, until something further down changes the session again. That is the reason these are commands rather than project-wide settings, and it is worth using: put a coarse machining resolution above the roughing programs and a fine one above the finishing programs, and one run does both at the resolution each deserves. Four of the five are a single field or checkbox. Machining Motion Resolution has more to say and carries its own editor: a type — Feed Per Cycle, Feed Per Tooth or Fixed — and, for Fixed, a linear resolution in mm and a rotary one in degrees. Note General Config is not on the menu, and it is not missing. It was one command carrying all five of these settings at once, and the five above replace it. A project that still stores one loads as those five commands in its place — preceded by a Record Meshed Geometry command where the bundle also read a meshed geometry file — and saving from then on writes the five. There is nothing to add and nothing to look for. The optimizer, as a step NC Optimization Config is the Optimization category's one command, and it exists so the optimizer's settings sit at a point in the run rather than over all of it. Everything played below it optimizes under those values, and a second one further down re-points them mid-mission. Its own node carries four switches — Enable Optimization, Enable Feedrate Optimization, Enable Depth Splition and Enable Interpolation — and the values live on five child nodes beneath it: Child node What is on it Distances the extended pre- and post-distances, in mm Feedrate the feedrate floor and ceiling, the rapid feed, the feed-per-tooth bounds and the assignment ratio Motion Dynamics maximum acceleration and jerk Force & Safety the preferred cutting force and the yielding, thermal-yield, spindle-torque and spindle-power safety factors Compensation the forward, side and depth compensation switches None of the five child nodes carries a checkbox of its own. The command's own checkbox is the only one, and like every command's it decides whether the mission runs this command — not whether the optimizer is on, which is the first switch on its panel. The command takes no title: its row always reads NC Optimization Config. What each quantity means, and why an optimized result can look wrong, is NC Optimization. The demo mission's optimizer command, at /execution?tree=execution/mission/1, sitting above the two program groups it governs. The four switches are on the command's own panel; the five value nodes are indented under it in the tree. Writing out what the run produced The Output category holds three commands: Post-Execution, Record Meshed Geometry and Export Meshed Geometry (STL). Post-Execution's name says what it consumes, not where it goes. It is an ordinary entry in the list, not an end-of-run hook, and everything it writes is derived from what the session has played above it. Put it after two programs and it covers both; put a second one halfway down the list and it writes an interim snapshot of the same accumulating run. Its placement is the whole question. Five outputs hang off it, each a child node whose own checkbox switches that output on: Output What it writes Default template Step Files Output the step-series data of what has played Output/[NcName].step.csv Shot Files Output time-sampled series at a period you set Output/[NcName].shot.csv Optimization Output the optimized programs Output/Opt-[NcName] CL → NC Writeback brand NC re-synthesized from what was played Output/[NcName].nc Geometry Difference Detection a comparison of the workpiece geometry at a radius you set — [NcName] in a template is replaced by the source program's name. Three things to know before switching them on: Two of the five are visible only while Show Physics Options is on in the Preference menu — Shot Files Output and Optimization Output. See Preferences. The shot file's time resolution is a sampling period, not the machining resolution, and it sets the accuracy ceiling of that data. A fine period makes a large file: a six-cut program writes about 13 MB at the default 1 ms and about 128 MB at 0.1 ms. The CL → NC writeback needs the CL played on an XYZABC chain, so the Program File command that plays it goes above this command. It re-serializes every control file the session played, so an NC play is written back too, and the converted files appear on the Program branch as their own nodes — see The Program Branch. Every field stays editable whether or not its checkbox is ticked: the checkbox decides what runs, not what can be prepared. The outputs are written in an order of the command's own — shot files, step files, optimization, the writeback, then the geometry difference — which is not the order the tree lists them in, and which matters only if you are reading their timestamps. The demo mission's Post-Execution command with Step Files Output selected, at /execution?tree=execution/mission/5/step-files. Each output is a child node with its own checkbox — that tick is what switches the output on — and the template field for the selected one sits in the panel below. Keeping the workpiece between runs The Output category's other two commands both take the workpiece as it stands at their own point in the list. Record Meshed Geometry stores it in the application's mesh format so a later run can pick it back up; Export Meshed Geometry (STL) writes an STL for something outside the application to read. Record Meshed Geometry carries a path — Cache/Workpiece.wct by default, because a recorded mesh is a rebuildable by-product of a run rather than a project asset — and one of four actions: Action What it does No Action nothing; the entry is a placeholder Read always loads the file into the session Write always writes the session's geometry to the file Read On First Or Write reads the file if it exists and nothing has played yet this session; otherwise writes The condition on the fourth is what makes the command usable more than once in one mission: the first such entry reads, and every one below a program writes. Building a mission around that is A Mission That Resumes. Writing builds the mesh, at the resolution in force where the command sits — so a Machining Resolution command belongs above it. A missing file is not an error: writing it is what a run does. Reset on the command's panel deletes the file it points at, so the next run records afresh. Export Meshed Geometry (STL) takes a path — Output/MeshedGeom.stl by default, since an export is something you asked for rather than a cache — and a resolution in millimetres; leave it at 0 for the default. It also builds the mesh, so the same placement rule applies. Driving the session from a script Script is the Program category's third command: C# evaluated against the running session, for anything the other command kinds do not cover. Where the script returns a sequence of actions, that sequence is played as part of the run. The editor completes against the very API the run will compile the script with, so what it offers is what the run accepts, and a member's signature and summary show beside the suggestion. Picking a method inserts the call with each argument as a stop, so Tab walks the parameters. There is no Save button. Typing saves shortly after you stop, and the pill beside the title reports where the text is: Idle, Dirty, Staging…, Staged, or Error with the reason in its tooltip. Staged means the service is holding the script, not that the project has been saved — save the project to keep it. Two prompts guard the edges, and neither is a yes/no question, so each has three buttons: Unsaved Changes, when you select another node while a save is still pending — Save & switch flushes it first, Discard drops it, Cancel leaves the selection where it is. Script changed elsewhere, when the command changed underneath you — another tab, or a project reload. Like NC Code, the title is optional and is what the row brackets. The list is not closed What Add Command offers is whatever the application knows about, not a menu built into the interface. A kind with no editor of its own is served by a generic one built from the settings that kind declares — which is how Machining Resolution, Collision Detection, Pause on Failure and Physics are edited. So a command kind can be addable, and fully editable, before this manual has a page for it. See Also Running a Simulation — the rest of running a job Building a Mission — the list these commands go into A Mission That Resumes — the layout these commands fall into, and what it buys Playing a Program — the two commands that put NC code into a run PreSettingCommand Panel — the component behind General Config, and what a stored bundle expands into NC Optimization Option Panel — the component behind NC Optimization Config, field by field PostExecutionCommand Panel — the component behind Post-Execution: its five sections and what each writes Script Command Panel — the component behind Script: its editor, its completion and its save states"
  },
  "manual/run/the-program-branch.html": {
    "href": "manual/run/the-program-branch.html",
    "title": "The Program Branch | HiAPI-C# 2025",
    "summary": "The Program Branch What the run actually read, line by line, as opposed to what the mission asked for. The Execution page's Control Tree carries two branches: Mission above, Program below, at Control-Tree path execution/program. Program is read-only — every node on it is either a file the mission points at or a pass a run made over one — and the transport bar stays pinned above its panels, so a run can be started, stepped and reset without leaving the branch. Before anything runs The branch is not empty before a run. The service seeds it from the mission: one node per distinct NC file a Program File command names, and one per NC Code command, taken in the order the mission lists them and reaching into nested groups. Those nodes are placeholders — a file the run has not opened yet — and the branch panel says so, badging itself not run yet beside the file count. Three things decide what is seeded, and each of them is visible in the screenshot below: A disabled command seeds nothing. The mission's greyed Program File entry names an NC file that never reaches the branch, and nothing beneath a disabled group reaches it either. Two commands naming one file seed one node. Paths are compared with case and slash direction ignored, so a file played twice appears once. An NC Code command is seeded under its own title, not under a file name, because it has no file — its text lives in the mission. The branch marks it (inline). The Program branch at /execution?tree=execution/program, on a project that has not been played. The disabled Program File entry in Mission has no node under Program; the enabled NC Code command has one, under its title. After a run Playing the mission fills the same nodes in and adds any file the run reached that the mission did not name — a subprogram call nests its callee under the caller. The panel's badge changes from not run yet to run data, and a file the run made more than one pass over takes a × and a count in its tree label. The same deep link once the run has finished. circle.ptp ×2 is one node holding two passes, because two Program File commands named the same file. Important The branch is rebuilt when the run changes state — starting, finishing, being reset — and not while it is playing. During a long run the nodes on screen are the ones the last transition left there, so a file the run has since opened may not be listed yet. Pausing brings it up to date. Reading one file Selecting a node opens the file as the run saw it: the path it was read from, a selector for the passes made over it, and the text with what each line produced beside it. One file node at /execution?tree=execution/program/0, with the canvas column switched off so the line viewer has the width. The pass selector names the pass and why it was entered. The pass selector carries one entry per pass, labelled with how that pass was entered — the first arrival at the top of the file, a re-entry when the mission came back to it, or the call that reached it from another file. The step range beside a line is what that line produced. A line with no range beside it ran and produced no motion: G and M words that set state, and the tape marks, all execute without cutting anything. A line missing from the marks altogether did not run in that pass. That is the difference the branch exists to show, and it is per pass — the same line can be greyed in one pass and marked in the next. Follow keeps the viewer on the line the run is executing; with it off the view stays where it was put. What the branch does not hold The writeback files are not inside the file nodes. Converting a played program back to NC makes its own node at the top of the branch, beside the file nodes rather than under them, and clicking a line on either side jumps to its twin on the other. That conversion is the CL-to-NC writeback, so a mission that plays brand NC produces none, and the branch shows only source files. Node addresses are positions, not files. A node is execution/program followed by its index, so a deep link into the branch survives only as long as the branch has the same shape. Link to the branch, not into it. A skipped line is not only recorded here. A line suppressed by block skip is also announced in the NC Diagnostics list while the run is playing — see When Something Goes Wrong. See Also Running a Simulation — the rest of running a job Playing a Program — the two commands that put the sources here When Something Goes Wrong — reading this branch as part of a diagnosis Inspecting a Step — the Sentence Syntax panel that a line click on one of these file panels steers"
  },
  "manual/run/watching-the-run.html": {
    "href": "manual/run/watching-the-run.html",
    "title": "Watching the Run | HiAPI-C# 2025",
    "summary": "Watching the Run A run shows itself two ways at once, and they answer different questions. The canvas shows what is happening now. The strip charts show the whole mission as one picture, so they are where you find out where the interesting part is. Use the charts to choose a moment; use the canvas and the Step Info column to look at it. Where it is The Execution page at /execution, in the two middle columns: the 3D canvas with the Session Messages panel beneath it, and the Strip Charts column beside it. Both columns are switched on and off from the quick-toggles on the menu bar, and every panel inside them folds to its own header. The canvas What the canvas draws is a choice, not a fixed set. It opens showing the workpiece, the fixture, the dimension bar and the tool path. The machine and the tool are not drawn until you ask for them — which is usually what you want, because a five-axis machine at home position fills the frame and hides the cut you came to watch. The panel header carries the generic camera control — a View menu of seven presets: Isometric, Front, Back, Right, Left, Top and Bottom — and beside it the four that belong to a run: Control What it does Tool Path Shows or hides the tool path through the whole program Path Points Adds the per-position dot markers along it. Editable only while Tool Path is on Scene ▾ Which elements are drawn, in three groups Meshed Geom ▾ The workpiece's rendering-cache budget, and the ideal-versus-actual difference display The Scene menu groups its checkboxes the way the renderer groups them: Solid — Machine, Tool, Workpiece, Fixture; Coordinate — Program Zero, ISO Coordinate, and Heidenhain Coordinate on a Heidenhain project only; Display Aids — Dimension Bar, Color Scale Bar. The tool path is deliberately not in this menu: its own button owns it, and Path Points hangs off that. Under Meshed Geom sit two rows, each opening a panel of its own: Graphic Cache, the memory budget for the workpiece's rendering cache, and Diff Visual Radius, which displays the difference between the ideal geometry and the actual one. The second carries a badge reading None or Diff, so the menu answers “did this run leave a difference?” without your opening the row. Collapsing the canvas does not disconnect it. The panel keeps it mounted and simply stops it drawing, so re-expanding is instant rather than a fresh connection. The Scene menu open over the canvas at /execution, with the Strip Charts column beside it. The three groups are the ones listed above, and the ticked boxes are the set the page opens with — Workpiece, Fixture and Dimension Bar — with Machine and Tool unticked. The three strip charts One group bar drives three charts, and each of them plots the whole mission rather than the current moment: Chart What it plots Availability Chart Five ratios: yielding stress, max spindle torque, max spindle power, spindle working temperature, thermal yield Surface Roughness Chart Re-cut depth, program-side cusp, and tip deflection in X / Y / Z, in µm Color Index Time Chart One property you pick, from every step property the run can quantify Each series is drawn as a band between its minimum and its maximum, not as a line through samples: the window is downsampled to the width it has on screen, so what you are reading is the shape of the run — where the spindle is loaded, where surface quality degrades, where thermal limits are approached — rather than individual values. The values themselves are in the legend panel down the side of each chart, which follows the cursor and can be dragged wider. All three carry a Y-axis range editor in their header — Fit to the data, Lock to a minimum and maximum you type, or Symmetric about zero with a bound; locking one is how you compare two parts of a run without the axis moving under you. The Color Index chart adds two more: the property picker, which is a type-to-filter list of every quantifiable step property, and Colors, which edits the colour guide. Colors is worth understanding before you touch it: it drives the colour of the workpiece in the 3D scene and the colour scale bar, not the line in the chart. The group bar Control What it does Range chip The slice of the mission currently shown, against its total step count Cursor readout The x-value under the pointer, shared by all three charts X-axis mode Time (s) or Step index, applied to all three at once Fit view Fits the 3D canvas to the tool path — the one control here that acts on the canvas Stick to live end Keeps the window's right edge pinned to the running end of the mission Reset display range Back to the whole mission, and re-arms stick-to-end Reload Re-fetches all three charts Stick-to-end turns itself off the moment you pan or zoom, because both of those set a definite right edge. That is the behaviour you want while a run is going — you can look at something without being dragged back to the live end — and Reset display range is how you re-arm it. Reading a chart with the pointer The three charts share one window and one selection, so a gesture on any of them moves all three. Gesture What it does Click Selects that step — this is what fills the Step Info column Drag left or right Sweeps a range and zooms to it on release Right-drag or middle-drag Pans Wheel Zooms about the pointer Hover Puts that x-value in the group bar's cursor readout One finger / two fingers Pans / pinch-zooms, on a touch screen A left drag shorter than a few pixels counts as a click, so selecting a step does not need a steady hand. Before anything has run, all three read No mission data. A chart that has data but no physics behind it reads No physics data instead — that is what the Availability chart looks like when the run produced no physics results. The three charts with the demo mission paused part way through and a step selected. The vertical rule crossing all three at the same place is that selection; the range chip on the group bar names the window, the x-axis is in seconds, and each chart's legend stands down its right side with one entry per series — five on each of the first two, one on the Color Index chart, which plots the single property named in its header. See Also Running a Simulation — the rest of running a job Starting and Stepping — the transport that makes these fill Inspecting a Step — the per-step detail a click on these charts opens The Application Window — the column quick-toggles that show and hide these two columns Strip Charts — the components behind this column: the shared window, the pointer contract and the data behind each series Execution Extended RenderingCanvas Tool Bar — the component behind the canvas header's run controls"
  },
  "manual/run/when-something-goes-wrong.html": {
    "href": "manual/run/when-something-goes-wrong.html",
    "title": "When Something Goes Wrong | HiAPI-C# 2025",
    "summary": "When Something Goes Wrong A run that does not do what was expected has usually already said why, somewhere. This page is about which somewhere — the four lists on the Execution page at /execution, the Program branch at Control-Tree path execution/program, and the service's own log. Start with the right list The Session Messages panel, below the canvas, splits the session's messages across four lists, and picking the right one is most of the diagnosis. A tab carries a count only once its list has something in it, so a tab with no number beside its name is a sink nothing has reached. Shell — the session's own account of itself: what started, what finished, what it built, and the verdicts it reaches at the end of a play. A conversion or an optimization reports itself here too, stage by stage and file by file, from its opening row to its closing count. These rows carry no anchor, because there is nothing in the program to anchor them to. This is the list a run that appears to have done nothing is diagnosed from: a play that ends with no step having touched the workpiece is reported here, and the message names the usual causes — an incremental header with no G90 after it, a work offset or program zero that puts the program somewhere else, stock that is not where the program expects it. NC Diagnostics — everything the NC pipeline said while playing, which is not only complaints. It opens each file with the line count it found, and a row about one sentence carries an anchor naming it. This is the list to read when the program did not do what its text says. Step Diagnostics — anchored to a machining step rather than to a position in the text. Most of it is about motion, but not all: an NC-embedded script that fails to compile is reported here too, against the step it was reached from. NC Manipulation — what the writeback found in the program while converting it to NC files or optimizing it: a block whose words it would not rewrite, an edit that matched no piece in the stream, a block the optimizer would not re-interpolate and optimized whole instead, a split arc whose written fragments no longer share one radius. It holds findings and nothing else, so a conversion or an optimization with nothing to complain about leaves this list empty; the run's own account of itself is on Shell. A message about a G word and a message about a move are different problems, and they never share a list. Looking in the wrong one reads as silence. Reading a row The four lists at /execution, with NC Diagnostics selected. Two of the four tabs carry no badge, which is how an empty sink looks. A row carries, left to right, the position it is about, the category, the message's own id, and its text. The position is the anchor: Sn and a number for a sentence, S and a number for a step. Not every row has one — a complaint about the pipeline rather than about a particular sentence has nothing to anchor to, and neither has anything on Shell. The id is worth reading. It is stable across languages and releases, so it is the thing to quote when asking someone else about a message, and the thing to filter on when one message is repeating. The Filter text… box, the Severity and Category lists and Export are described with the rest of the panel in Messages and Logs. Important On the two NC lists, a row is not an occurrence. NC Diagnostics folds across a play and NC Manipulation across one conversion or optimization run; Shell and Step Diagnostics fold nothing, and every report they take becomes a row of its own. Where it applies, the pipeline keeps one entry per distinct message — same id, same wording — and drops every repeat instead of listing it. When the program ends, each message that occurred more than once gets one summary row reading repeated N times in this run, first at the sentence it was first seen on. So a diagnostic raised on forty different sentences leaves two rows for that program: the first occurrence, and the summary. Two consequences are worth holding on to. The count is only in that summary sentence — the multiplier badge that marks consecutive identical messages is a different mechanism and does not appear on these. And the summary row's anchor is the last occurrence while its text names the first, so jumping from it lands at the end of the run of repeats, not at the beginning. Everything between the two rows has no anchor at all: to find those positions, fix the first one and play again. Then the run's own record The Program branch holds what the run did to each line — the passes it made and the marks each one left. A line that was expected to cut and was not marked was not executed in that pass. See The Program Branch. The two records answer different questions and are worth reading together: NC Diagnostics says what the pipeline thought of a sentence while it was playing, the Program branch says what that sentence produced. Then the service log Show Log on the menu bar opens the log the service is writing for the current day, with a Download for sending it to someone else. It holds things the four lists never carry — the exception behind a failure, and the engine's own start-up account of itself — and it is the only one of these surfaces that outlives the session. What it does not hold is the four lists: those are pushed to the browser and are never written to the file, so a message seen in a list is not findable there. The viewer itself is described in Messages and Logs. While an optimization is running An optimization reports itself on Shell, stage by stage. It opens with Start NC optimization. and ends with Total N files optimized. and optimization cache cleared., and between them every stage announces itself as it begins: Computing Optimized Feed by indivisual step.., closed by Optimization Feedrate built. once the per-step feeds are solved, then Constrain feedrate By expaneded segment.., Constrain Feedrate By Acceleration.., Build Compensation.. and Regenerate NC commands.., with one File optimized: row naming each output file as it is finished. Two of those stages count aloud, and they are the only way to tell a slow optimization from a stopped one. While the per-step feeds are being solved, every thousandth step adds another Computing Optimized Feed by indivisual step.. row carrying the source file and line it has reached; while the optimized text is being written, every thousandth line adds a Now optimizing to: row carrying the same two numbers. Shell appends every one of them and folds nothing, so its newest row is where the run has got to: numbers that keep advancing are a run still working, and a list that has stopped growing on a stage whose successor has not been announced is a run that is not. The counting rows are the instrument, not the stage rows. A stage with fewer than a thousand steps to solve, or fewer than a thousand lines to write, announces its start and then says nothing until it ends — so a short program crosses the whole ladder in near-silence, and that silence means nothing on its own. A Stop ends an optimization on a success row. Stop reaches the optimizer between steps and between output files rather than only at the end, and what it leaves on Shell is optimization canceled. followed immediately by Total N files optimized. in success green — even Total 0 files optimized. arrives as a success. The count is of the files the run had opened, so a file the Stop landed part-way through is counted with the rest and is left on disk short. The complete ones are those whose own File optimized: row appeared before the cancel. Three things that look like faults and are not An English message in a translated interface is the safe answer, not a bug. Engine messages arrive with an id and their English text, and the interface substitutes its own translation only when its copy of that message matches the one the engine sent. An engine built against a different message set, or a message the interface has no copy of, leaves the original English in place rather than rendering text that might say something else. The English is the accurate text. An action refused because a run is playing is a guard, not a fault. Switching the NC runner and switching the controller brand are both refused while a program is playing, rather than swapping the parser underneath it; the refusal names the reason and asks for the run to be paused or finished first. It arrives on the action itself — no row is added to any of the four lists, so there is nothing to go looking for afterwards. An empty Step Diagnostics list is not proof that nothing was wrong. Collision detection is off unless the mission turns it on, and the physics-dependent warnings — the cutter geometry checks raised at tool change among them — are not raised at all when physics is off. A quiet list on a run with those switched off says only that nothing was being watched for. If it is a configuration problem rather than a run problem Some failures are the setup answering late. A cutter whose upper beam is shorter than its flute cannot build its thermal shell. The Upper Beam editor flags it while the tool is being edited, and a run that equips that tool reports it again at tool change, in Step Diagnostics — provided physics is on, which is what makes that check run. See Cutter Geometry. See Also Running a Simulation — the rest of running a job Starting and Stepping — the transport, and the run state this page reads The Program Branch — what the run recorded against each line Messages and Logs — the panel these four lists live in, the footer, and the service's log viewer"
  },
  "manual/setup/anchor.html": {
    "href": "manual/setup/anchor.html",
    "title": "Anchor | HiAPI-C# 2025",
    "summary": "Anchor Placing the workpiece, the fixture and the tool relative to the machine. Each of them carries named anchors, and the setup task is to give each geometry the transform that puts its anchor where it belongs — four transforms in all, on two branches of the Control Tree. What an anchor is — a coordinate system rather than a point — and which named buckles hold the scene together is Assembly Anchors. This page is where they are set. Where it is The General Setup page, at /general-setup. The transforms hang from the two branches that own the geometry being placed, each under an Anchor group: Branch Node What it places Fixture Geom To Table equipment/fixture/geom-to-table The fixture geometry onto the machine's table buckle Fixture Geom To Workpiece equipment/fixture/geom-to-workpiece The workpiece buckle — the place the workpiece attaches — relative to the fixture geometry Workpiece Geom To Fixture equipment/workpiece/anchor/geom-to-fixture The workpiece geometry onto that workpiece buckle Workpiece Geom To Program Zero equipment/workpiece/anchor/geom-to-program-zero Program zero, the NC origin, relative to the workpiece geometry The tool is not placed here. It arrives on the spindle through the tool house, and how far it stands out of the holder is part of the tool itself — see Cutter. The order to work in Attach a machine tool first. The table buckle the fixture is placed against belongs to the machine chain, so there is nothing to place against until one is loaded — Machine Tool. Place the fixture on the table with Geom To Table. Place the workpiece on the fixture — Geom To Workpiece on the fixture side, then Geom To Fixture on the workpiece side. A project carrying no fixture skips both: the workpiece is then assembled onto the machine's table buckle directly. Set program zero last, once the workpiece is where it belongs. Which direction to align it, and what to align it against, are Program Zero Alignment. The numbers are on the child node Each of the four nodes is a kind picker and nothing else. Its panel offers one field, Transformer type, and the editor holding the actual numbers is the child node underneath it — which is why a node that looks empty has an expand arrow beside it. Geom To Program Zero selected on a demo project, at /general-setup?tree=equipment/workpiece/anchor/geom-to-program-zero. The panel under the tree carries only Transformer type, reading Static Translation; the node's own child, one level deeper in the tree, is where that translation's values are typed. Seven kinds are offered on all four nodes: Kind Use it for Static Translation A fixed offset. The usual answer for all four. Static Rotation A fixed turn — stock clamped at an angle, a fixture mounted rotated. Static Freeform A fixed transform given as a matrix. General Transform Several transforms composed into one. Dynamic Translation / Dynamic Rotation A value that moves at run time. These are what a machine's own axes carry; a setup placement is not one of them. No Transform No offset at all — the two things coincide. Changing the kind replaces the editor beneath it, so a value typed under one kind does not carry over to another. Checking the result The Scene dropdown above the canvas has an Anchors group that draws what has just been placed: Fixture Geometry Anchor, Workpiece Buckle, Table Buckle, Workpiece Geometry Anchor and Program-Zero Anchor. Turning on the two ends of a transform you have just set is the quickest way to see whether it landed where you meant — a workpiece sitting a plate's thickness below the fixture is obvious as soon as both buckles are drawn. The same dropdown's Solid group has a Machine checkbox, cleared to begin with, which brings the machine chain into the same scene so the assembly can be checked against the table it is supposed to be sitting on. See Also Assembly Anchors — what an anchor is, and the named buckles the scene is assembled at Program Zero Alignment — aligning the program origin once the workpiece is placed Machine Tool — the chain that carries the table and spindle anchors Fixture — the branch carrying the two fixture transforms named above Workpiece — the branch carrying the two workpiece transforms named above, and the rest of the workpiece setup Setup — the rest of the pre-simulation configuration"
  },
  "manual/setup/controller.html": {
    "href": "manual/setup/controller.html",
    "title": "Controller | HiAPI-C# 2025",
    "summary": "Controller The controller is the NC parser a project reads its programs with: a brand, the machine and control settings that brand assumes, and the coordinate, offset and variable tables an NC program addresses. Setting it up is picking the brand first, then filling in the tables that brand grew. Where it is The General Setup page, at /general-setup, reached from the menu bar's Page dropdown. Select the Controller branch of the Control Tree (/general-setup?tree=equipment/controller); it sits after Workpiece, and whichever node you select opens its editor below the tree in the same dock. The branch grows children only with a project open and a controller resolved on it, so a Controller node standing alone is the state before a project is open rather than a fault; a project file naming no controller keeps the Fanuc preset. Once a runner resolves, the root's own panel badges the brand in force and enables an Object Management (⋮) menu, whose Load installs a .Controller, .SoftNcRunner or .xml runner file in place of the whole controller and whose Save As writes the current one out, offered as NcRunner.Controller. Pick the brand first Select Controller Brand (equipment/controller/machine/brand), pick one of Fanuc, Siemens, Heidenhain, Syntec and Mazak, and press Apply brand. Until you do the pick is only staged: Revert drops it, and so does selecting another tree row. Do it before anything else, because it replaces the whole controller rather than one field: The dialect changes. Each brand is a different reader; what its G and M words actually do is NC Dialects. The node set changes. The branch is regrown, so nodes the new brand has no concept of stop existing and its own appear. Machine settings reset to the new preset's defaults. The runner-owned ones — the tool-change position, block-skip layers, subprogram folders and the macro iteration guards — reset on every apply. The travel limits, rapid feedrates, home reference, M-code declarations and native parameters live in the brand's parameter table and reset only where the switch also sweeps that table; Fanuc and Mazak share one, so a switch between those two leaves them where they are. The old brand's own program-data tables are removed — the ones only that brand proxies: Siemens frames, $TC_DP offsets and R parameters, Heidenhain datum presets and shifts. Tool offsets survive every switch, and retained common variables survive among Fanuc, Syntec and Mazak. What is swept does not come back: switching back builds those tables fresh from the new preset's defaults. Carry work-coordinate XYZ (G54…) into the new brand's table, ticked by default, moves the work offsets across — only those, and only for ids the new brand also holds: Fanuc to Siemens keeps G54–G57 and drops the rest. A brand switch and an Object-Management load are both refused while an NC program is playing — see Playing a Program. The Controller Brand leaf on a demo project, at /general-setup?tree=equipment/controller/machine/brand. The machine plane above it is expanded, so the eleven leaves this brand grows are all visible; the panel below carries the Controller brand select reading Fanuc, the carry checkbox ticked, and the Apply brand and Revert buttons that are enabled only while a different brand is staged. The two planes Every other node hangs on one of two group stems, and which one it is on says what it describes; selecting a stem lists its children. Plane Tree id What sits on it Machine / Controller equipment/controller/machine What the machine is wired to do: travel limits, rapid feedrates, the home / G28 reference, the tool-change position, the controller parameters in both a grouped and a native form, the peck clearance, M-code declarations, block-skip layers, subprogram folders and, on Siemens, the indexing position tables Program Data equipment/controller/program-data The tables a program reads and writes: work coordinates (G54…) and tool offsets on every brand, plus the brand's own — Siemens frames, $TC_DP offsets and R parameters, Heidenhain datum presets and shifts, Fanuc-family retained common variables The machine plane's per-axis rows are driven by the machine tool's chain: every brand preset already declares X, Y and Z, and attaching a machine tool adds that chain's own axes beside them. Program data stays with the project, so loading a controller file of the brand already in force leaves those tables as they are. Work Coordinates always lists the plain G54–G59 rows its brand's table holds — Siemens seeds only G54–G57 — and, on Fanuc, Mazak and Syntec, the extended G59.1–G59.9 rows of the brand-neutral table that sits behind the brand table; it shows the G54.1P and G505–G599 rows once a value is non-zero or the Show all toggle is on. Each row carries P0, which writes the machine coordinate the workpiece's program-zero anchor sits at, and M0, which writes machine zero; clicking anywhere in a row also marks that coordinate on the canvas. Aligning program zero onto a row's offset is not on this branch: Align P0 is on the Legacy Controller screen's Coordinate Table tab, which edits a separate controller model — Legacy Controller. A table that is not there A node the active brand has no concept of is never created rather than shown and disabled — Frames on Fanuc, Retained Common Variables on Siemens, Block Skip / Delete on Heidenhain — and a ?tree= link naming one does nothing on the wrong brand, so name the brand alongside any id shared. Nor is an id promised to survive a version change — see Finding Your Way. Two further rows may differ from a colleague's tree for an unrelated reason: CSV Controller and CL Controller are separate non-brand controllers, absent until their box in the Preference dropdown is switched on, and which box is on is a per-device setting — see Preferences. Unlike a brand-gated node, though, these two are still reachable by link: a ?tree=equipment/controller-csv or ?tree=equipment/controller-cl mints the node and selects it whatever the box says, so a shared bookmark never dead-ends. The Preference menu answers whether you need either of them. Under each of the two checkboxes it reads This project plays CSV / This project plays CL, or Not used by this project, worked out from what the open project actually plays — the kinds its mission commands name, the play verbs its scripts call, and, for CL, a machine chain that can only be driven from CL. Neither node is a setup task in its own right: both are childless leaves with no Object Management, because a CSV or CL pipeline is not loaded, pasted or saved as a file the way a brand controller is. Switching a box on reveals the pipeline's settings; leaving it off on a project that plays neither costs nothing. See Also NC Dialects — what each brand's G and M vocabulary actually does, once the brand is picked Legacy Controller — the superseded screen that still owns Align P0 and the two switches this branch has no editor for Machine Tool — the chain whose axes fill the per-axis rows on the machine plane Program Zero Alignment — the other half of a work offset: where program zero sits on the workpiece Setup — the rest of the pre-simulation configuration"
  },
  "manual/setup/coolant.html": {
    "href": "manual/setup/coolant.html",
    "title": "Coolant | HiAPI-C# 2025",
    "summary": "Coolant Two thermal settings sit beside each other in the equipment tree: how the cutting zone is cooled, and how warm the shop is around it. Both feed the milling-temperature model, so they move computed temperatures and everything downstream of them — and setting them needs no heat-transfer numbers at all, because the cooling types ship as ready-made files. Where it is The General Setup page, at /general-setup, reached from the menu bar's Page dropdown. Background (/general-setup?tree=equipment/background) and Coolant (/general-setup?tree=equipment/coolant) are two leaves of the Control Tree, sitting together between Spindle Capability and Fixture. Both are inert until a project is open: the fields are disabled and the panel says so. The Coolant leaf selected on a demo project. The panel under the tree opens with the file row — the Select dropdown, the path field reading No coolant file (saved inline), and Save As… — then the read-only Name and Note of whatever file is loaded, and then the condition's own values. Neither leaf puts anything in the middle column. Pick a cooling type The three standard cooling types ship as ready-made .CoolantHeatCondition files, so picking one is the cooling-type selection — exactly the way a workpiece material file is picked. Select the Coolant leaf. Open the Select dropdown at the left of the file row and choose Browse Resource…. It opens the file picker in the shipped library's own coolant folder, so the three files below are what it lists. Browse… above it opens the same picker without that jump, which is how a condition you saved yourself is reached. Pick the file that matches the machine. Shipped file Pick it when StandardForcedAir The machine only blows air at the cutter — no liquid coolant. StandardWaterSolubleCoolant Water-based emulsion coolant, the common flood coolant. StandardOilBasedCoolant Neat-oil cutting fluid: better lubrication, noticeably less heat removal than water-based. Loading a file fills the read-only Name and Note and every value below them, and reports the name it loaded. A project nobody has touched here is not neutral. Every project carries a coolant condition from the moment it exists, and it starts on the water-soluble numbers — 25 °C, a flood baseline of 1000 W/(m²·K), a mist ratio of 0.5 and 50 W/(m²·K) with the coolant off. The read-only Name is blank, because no file has been picked, and that blank is the only sign that nobody chose these values. A dry-cutting machine left alone therefore simulates as though it were flooded with water-soluble coolant, and its computed temperatures come out low. The four values They are visible whether or not a file is loaded, and editing one tunes this project's copy rather than the file it came from. Each carries the app's own working range as a hint: Field What it is Range the panel suggests Coolant Temperature (°C) The temperature of the coolant as it arrives at the cut — Flood Convection Coefficient (W/(m²·K)) Heat removal with the coolant on Forced air 10–500; typical liquid coolant 1000–10000 Mist / Flood Ratio Mist heat removal relative to flood Typically 0.4–0.8 Off (Air) Convection Coefficient (W/(m²·K)) Heat removal with the coolant off Natural air 5–25; forced air inside an enclosure about 50 Negative temperatures are accepted, for cryogenic coolant; the three convection coefficients cannot go below zero. Which of the three coefficients is in force at any moment is not decided here — the NC program's own M07 / M08 / M09 decide it, step by step. That, and what the numbers do to the simulation, are Coolant Model. Keeping a tuned condition Save As… writes the current values out as a .CoolantHeatCondition file in the project folder and starts tracking it, so the project saves a reference to the file instead of a copy of the values. It offers a name taken from the loaded condition; a file picked from the shipped library loses its .default marker on the way, because that marker means shipped and a file you saved is yours. The result is loadable into the next project through the same Select dropdown — which is the point of saving one: a shop with its own measured coolant performance describes it once. Background temperature The Background leaf carries a single field, Background Temperature in °C: the surrounding temperature the thermal model works against. It defaults to 25 °C, it belongs to the project exactly as the coolant condition does, and it is read by the same milling-temperature model and by the feed optimizer, so it is not a display setting. Set it to the shop's real ambient. There is no file to load and nothing else to configure: one number, applied to the whole project. See Also Coolant Model — the coefficients, the M-code that selects one, the shipped presets and the file format Background / Coolant Page — the Control-Tree editor for these values, field by field Setup — the rest of the pre-simulation configuration"
  },
  "manual/setup/cutter.html": {
    "href": "manual/setup/cutter.html",
    "title": "Cutter | HiAPI-C# 2025",
    "summary": "Cutter A tool is one entry in the project's tool house, identified by its T-number, and it is the whole assembly the spindle turns: a cutter, the holder it sits in, how far it stands out, and the sensor settings a smart holder needs. All of it is edited on the Tool House page, one tool at a time and one aspect per tab. What each quantity means, and how to choose between the two ways of expressing a cutting envelope, is Cutter Geometry. This page is where they are entered. Where it is The Tool House page, at /tool-house, reached from the menu bar's Page dropdown. Three columns: the tool house and its tool list on the left, the selected tool's tabs in the middle, and a canvas drawing that tool on the right. Selecting a different tool keeps the tab you were on, so a walk down the list stays on the same aspect of each tool. Tool 1 of a fifteen-tool demo house with the Cutter tab open, at /tool-house/1/cutter/profile. The tool list carries one row per tool — its number badge and its note, or the derived abstract note where no note has been typed. The tab strip above the editor is the tool's five tabs; below the cutter's own identity fields is a second strip of section tabs, and Flute Profile is the one selected, showing a Column APT profile with its diameter, length of cut and round radius. The tool house is a file of its own The list on the left is the project's tool house, and the Object Management (⋮) button beside New Tool manages the whole house rather than one tool — its file extension is .MachiningToolHouse. That is how a set of tools is reused: Save As writes the house out, and Load on another project installs it in place of whatever that project had. A shop that runs the same twenty tools across every job describes them once. New Tool stays disabled until the project has a tool house at all; a project without one shows an empty-state block naming that button and the .MachiningToolHouse extension instead of the tool count. Creating, duplicating and deleting a tool There is no dialog to fill in first — a new tool arrives with default values and is then set up in the tabs. Press New Tool. The tool takes the next number: one past the largest already in the house, or 1 in an empty one. Open the General tab to give it its identity. Tool ID is the T-number, and committing a change there renames the tool. Note is yours to write; the read-only Abstract Note beneath it is derived from the cutter you give the tool in the next step, and carries a one-click copy button. Duplicate and Delete are icon buttons on the same tab. A duplicate is inserted at the first free number past both the tool it was copied from and the largest in the house, so it never lands on top of an existing tool. A tool number cannot be repeated. Renaming a tool onto a number the house already holds is refused as a conflict rather than overwriting anything, so the way to swap two numbers is to move one of them out of the way first. Tool 1's General tab, at /tool-house/1. The Abstract Note below the editable note is derived from the cutter the tool carries rather than typed, which is why a tool with no note of its own still reads as something recognisable in the list on the left. Giving it a cutter The Cutter tab chooses what kind of cutter the tool carries — Milling Cutter, Freeform Remover, or none — and holds the fields every cutter has: Shank Mass, Hone Radius and Relief Angle. Assigning a milling cutter grows a second strip of section tabs beneath them, and that is where the description proper is entered: Section tab What it holds Material The flute, shank and coating materials. It is there only while the Show Physics Options preference is on, and when it is there it is the first tab in the strip — so on a device with that preference off the strip has four tabs and opens on Flute Profile instead. See Preferences, which also covers why flipping that preference does not change a strip already on screen. Flute Profile The cutting-edge envelope, as one of the five APT types: General, Ball, Column, Cone and Taper. Flute Contours The fluting: how many flutes, and each flute's side and bottom contour. Upper Beam The shank above the flute. Optimization The per-cutter limits the optimizer respects. Holding it, and how far it stands out Three more tabs carry the rest of the tool. Holder picks the holder kind — none, a Cylindroid holder, or a freeform one — and, for a cylindroid holder, grows Geometry and Resolution sub-tabs: the holder's Z-against-radius profile, and how finely it is meshed. Clamping is two numbers that are really one. Exposed Cutter Height is how far the cutter stands out; Preserved Distance is the gap between the top of the flute and the spindle nose. They differ by the flute height, so editing either one moves the other, and the panel says so. Tool 1's Clamping tab, at /tool-house/1/clamping. The two fields read 28 mm and 8 mm, and the line beneath them states the relation the server keeps between them. Int. Holder is the smart holder's Observation Location: which anchor the sensor reading is referenced to — none, the tool tip, the holder anchor or the spindle buckle — then the height above that anchor and the radius of the observation ring. What those settings mean is Smart Tool Holder. Two kinds this screen cannot draw the numbers for The Freeform Remover cutter and the freeform holder geometry can be selected here, but this page carries no editor for either. Picking one leaves whatever the tool already holds untouched — nothing is cleared — and shows a note naming where that shape can be edited instead. The same is true of the custom spinning profile: the Flute Profile tab offers the five APT types and nothing else. See Also Cutter Geometry — what every quantity on these tabs means, and when to prefer an extended cylinder over an explicit shank profile Smart Tool Holder — the sensor settings behind the Int. Holder tab Project Data Checklist — what to collect about a tool before creating it Milling Physics — the models every quantity entered here feeds Setup — the rest of the pre-simulation configuration"
  },
  "manual/setup/fixture.html": {
    "href": "manual/setup/fixture.html",
    "title": "Fixture | HiAPI-C# 2025",
    "summary": "Fixture The fixture is what clamps the workpiece onto the machine table. Setting one up is three things: having a fixture on the project at all, giving it a geometry, and placing that geometry between the table and the workpiece. Where it is The General Setup page, at /general-setup, reached from the menu bar's Page dropdown. Select the Fixture branch of the Control Tree (/general-setup?tree=equipment/fixture); it sits with the other equipment items, between Coolant and Workpiece. The selected node's editor opens below the tree in the same dock, and the canvas beside them draws the fixture with the rest of the scene. The branch root selected on a demo project, at /general-setup?tree=equipment/fixture. The panel under the tree is a summary rather than an editor: the Object Management (⋮) button, a Geometry type badge naming the kind in the slot — here TransformationGeom — and the caption saying that the geometry and the two anchor transformers are edited through the child items. Both of those children, Geometry and Anchor, carry expand arrows of their own. The fixture a project carries A new project is created with a fixture already on it, its geometry slot pre-filled with a TransformationGeom, so the branch is normally populated the moment a project is open. A project may also legitimately carry no fixture: the root then has no children under it, the Object Management button is greyed out, and the caption reads No fixture available. Open or create a project first. That is a valid setup rather than a broken one — with no fixture the workpiece is assembled onto the machine directly, anchored on its table buckle, one of the four named anchors the scene is assembled at (Assembly Anchors); the two transforms below then play no part. The root panel's Object Management button is the fixture's file surface, available only once the project has a fixture. Load installs a .Fixture or .xml file picked from the server in place of the current one — re-attaching the table and workpiece buckles, rebuilding the branch and confirming with a Fixture replaced notice. Save As writes the current fixture out, offered as Fixture.xml in the project directory; Copy / Paste carry it as XML; XML Mode edits that XML directly, its Apply installing the result exactly as a Load does. Giving it a geometry Select Geometry (equipment/fixture/geometry). Its own panel is the kind picker alone, labelled Geometry type, with None (unset) to clear the slot; the picked kind's editor opens as the node beneath it, and the root panel badges whichever kind is in the slot. A fixture geometry must be able to produce an STL, so the voxel meshed-geometry kind offered on the Workpiece branch is absent. Kind Pick it for Box3d A plate, a block, a vice body — anything box-shaped. Cylindroid A solid of revolution given as Z–R pairs: a round chuck, a spacer. StlFile A mesh exported from CAD, for a fixture worth drawing accurately. TransformationGeom Another geometry with a transform in front of it — what a new project starts with. GeomCombination Several of the above assembled into one fixture. Placing it Two transform nodes hang from the branch's Anchor group, each a kind picker labelled Transformer type over the picked kind's editor. Node What it sets Geom To Workpiece (equipment/fixture/geom-to-workpiece) Where the workpiece attaches — the workpiece buckle — relative to the fixture geometry. Geom To Table (equipment/fixture/geom-to-table) Pins the fixture geometry onto the machine's table buckle. What an anchor is, and the order to fill these in, are Anchor. To check the result, the Scene dropdown in the toolbar above the canvas carries Fixture Rendering Mode and the Fixture Geometry Anchor, Workpiece Buckle and Table Buckle overlays. See Also Anchor — what the two transform nodes above are for, and the order to place them in Workpiece — the part this fixture holds, and its own geometry and material Machine Tool — the chain carrying the table buckle the fixture is pinned to Program Zero Alignment — the alignment that moves this fixture's Geom To Table transform when program zero is aligned onto a work offset Setup — the rest of the pre-simulation configuration"
  },
  "manual/setup/index.html": {
    "href": "manual/setup/index.html",
    "title": "Setup | HiAPI-C# 2025",
    "summary": "Setup Pre-simulation configuration: the physical entities and components you configure before running a simulation. Once set, these form the fixed environment of the simulation. Tip New to building a project? Start with the Project Data Checklist — the list of data to collect from the machine owner before any of the components below can be configured. It is a workflow rather than a setup task, so it lives with the other end-to-end guides. Ordered as the General Setup page builds its equipment, with the placement tasks, the tool house and the environment after it. Equipment Machine Tool — Build a virtual machine tool's chain, and attach one to a project Spindle Capability — What the spindle delivers: power, torque, thermal ceiling and gear shift Fixture — What holds the workpiece on the table, its geometry, and the two transforms that place it Workpiece — The stock and the finished shape, where they sit, how finely they are meshed, and what they are made of Controller — The brand your NC programs are read with, and the tables that brand grew Placing It All Anchor — Place the workpiece, fixture and tool relative to the machine Program Zero Alignment — Put the program origin where the NC code expects it, once the workpiece is placed Cutting Tools Cutter — Create a tool, give it a cutting geometry and a holder, and reuse a whole tool house across projects Environment Coolant — Pick how the cutting zone is cooled, and set the ambient temperature it works against Which NC vocabulary a controller brand honours is not a setup task and no longer lives here — it is NC Dialects. Neither is what a cutter's quantities mean: the body types, the two ways a cutting envelope is expressed, the upper beam and the angles are Cutter Geometry, and the smart holder's sensor settings are Smart Tool Holder. See Also Technique — the models behind these settings: milling physics, NC dialects, machine capability NC Dialects — what each controller brand's code actually does, brand by brand Basics — the window, the project and the screens these tasks are performed in Running a Simulation — what the equipment configured here is then used for Utilities — the screens beside these tasks: browsing a project's files, assembling a machine chain, and the settings the legacy controller screen still owns"
  },
  "manual/setup/machine-tool.html": {
    "href": "manual/setup/machine-tool.html",
    "title": "Building Virtual Machine Tools | HiAPI-C# 2025",
    "summary": "Building Virtual Machine Tools A project's machine tool is the kinematic chain between the machine table and the tool spindle: the anchors that stand for the machine's components, and the branches that carry the motion between them. A chain is authored once and saved as a file; attaching that file to a project is a separate step, and one chain serves every project that runs on that machine. Where it is The General Setup page, at /general-setup, reached from the menu bar's Page dropdown. Select the Machine Tool branch of the Control Tree (/general-setup?tree=equipment/machine-tool), the first of the equipment items. The branch is a leaf: the structure of a chain belongs to the Mechanism Builder, so this panel carries no editors for it — only the identity of whichever chain is attached. The branch selected on a demo project, at /general-setup?tree=equipment/machine-tool. The panel under the tree is the whole of it: the Object Management (⋮) button, a type badge reading GeneralXyzabcMachineTool, and the Name: and File: lines naming the chain in force and the file it came from. The middle column reads The selected item has no expanded content. — this branch brings nothing to it — and the canvas is drawing the stock on its fixture. Note The equipment canvas does not draw the machine until you ask it to. The Scene dropdown above the canvas carries a Solid group whose Machine checkbox starts cleared, so a chain that loaded perfectly still leaves that canvas showing only the fixture and the workpiece. Tick it to bring the machine into the same scene — or open the /machine-tool route below, whose canvas draws the chain on its own. Attaching a chain to a project A chain file is not a project's machine until it is loaded onto one. The branch root's Object Management (⋮) menu is where a chain arrives and leaves: Entry What it does Load Picks a .MachineTool or .mt file from the project or the administrator directory and installs it as the project's chain New ClMillingDevice Attaches a CL-driven blank device instead — the one chain type that needs no file, because it has nothing to configure Save As Writes the attached chain back out as a file Copy / Paste Carry the chain between projects as XML XML Shows the attached chain as XML and installs the result of an edit Every chain type other than the CL-driven device arrives by Load, Paste or XML. Installing one re-attaches the fixture and workpiece buckles and rebuilds the branch, so the rest of the equipment follows the new machine without being touched. Tip The shipped machines are one folder deeper than this picker opens. This menu's picker offers the project folder and the administrator directory as its two roots, and the shipped resource library is the Resource folder inside that administrator directory — so a shipped chain is reached by opening Resource, then MachineTool. The /machine-tool route's own picker lists that library as a root of its own and opens straight into it, which is the shorter way to the same files; its Load installs onto the project exactly as this one does. A Load from a file also re-points what the project saves. A chain picked from inside the project folder is remembered as a path relative to that folder, and one picked from the shipped resource library relative to the resource root — which is what keeps a project save from writing over a shared resource file. New ClMillingDevice clears that reference instead, so the fresh chain is saved inside the project rather than over the file the previous one came from. Paste and an XML apply leave the reference exactly as it was. Checking what is attached The /machine-tool route is a screen of its own for the same chain: the identity beside a canvas that draws it. It carries no Page-menu entry and is reached by typing the URL. Its fields show the chain rather than edit it — the name and the note are read-only there — but the folder button beside them is a working Load, greyed out only until a project is open. The route on the same demo project, at /machine-tool. The header names the file the chain came from and repeats its name; the Identity card below carries the read-only name, the empty note and the type chip; the GUI / XML toggle at the right swaps that card for the chain's XML; and the Display panel draws the five-axis chain the file describes. Building the chain Structure is assembled in the Mechanism Builder and saved with its Save As Machine Tool entry. That save checks none of this: a mechanism whose end anchors are mis-cased or missing is written out without a word, and the mistake surfaces only later, on the screen where the file is loaded onto a project. What that page cannot tell you is what to call things: the chain reads its own topology by keyword, so the names below are not labels but the mechanism by which the machine works at all. Name the motion axes on the branches. A linear axis is a branch named X, Y or Z; a rotary axis is a branch named A, B or C. Use each keyword at most once — a machine without a given axis simply has no branch carrying that keyword. Give each axis branch a matching transformer. A branch named X, Y or Z must carry a Dynamic Translation, and one named A, B or C a Dynamic Rotation. The keyword and the transformer kind are read together: a branch correctly named but left on a static transformer contributes no axis, and the machine ends up with one fewer than it looks like it has. Name the anchors that hold the chain together. O is the ground anchor, base the machine base, t the tool-end anchor that tools connect to, and w the worktable-end anchor that fixtures and workpieces connect to. The machine needs exactly one t and one w. The two are checked one at a time and the worktable end goes first, so a chain missing both is refused naming only w; t is named on the next attempt, once w is in place. A second refusal after a rename is the next keyword, not a new fault. Give the anchors shapes. Optional, and driven from the builder's Geometry card. Save the topology as a machine tool file, then attach it to a project as above. Important Every keyword is matched exactly as written. The motion axes are upper-case X, Y, Z, A, B, C; the ground anchor is upper-case O; and the base and the two end anchors are lower-case base, t and w. A name differing only in letter case names nothing at all. A mis-cased axis is silent — that axis is simply absent — while an end anchor that is missing or mis-cased stops the file loading, with a message naming the keyword it wanted: This kinematic chain has no worktable-end anchor named ‘w’. When the mechanism carries that same letter in the other case, the message adds the rename — The mechanism carries ‘W’, which differs only in letter case; the keyword is matched exactly, so rename it to ‘w’. — and when the anchor is simply absent, or named something else entirely, the first sentence stands alone. Branch direction is free: the motion, the axis keywords and the default collision pairs all read a branch the same way round. Pointing every branch away from the ground anchor is a readability convention — it makes the structure read outwards, ground → base → motion axes → the t and w end anchors. The names also decide what can collide with what. A machine file asking for its collision pairs to be generated is answered by walking the chain twice, from O to t and from O to w. That walk is also where the two end anchors are checked, so such a file — the form Save As Machine Tool writes — is refused by the Load itself. A file that lists its collision pairs explicitly instead is read without the check and arrives intact; it is refused one step further on, when the chain is installed onto the project and its kinematics are rebuilt, with the same message reported against the install rather than the load. Everything named on the way becomes a collidable component; the four structural keywords are dropped from both walks, the tool holder, cutter shank and cutter flute are added to the tool side and the fixture and workpiece to the table side, and every pair across the two sides is generated except workpiece against cutter flute — that one is the cut, not a collision. Where the numbers come from The most convenient approach is to assemble the machine in CAD, position the moving elements at the machine origin — the position at which every machine coordinate reads zero, generally the home position — and then: Export the main components as individual STL files from that one coordinate system, and set each into its anchor. Measure, in the same CAD coordinate system, the tool-end anchor, the worktable-end anchor and a point on each rotary axis' pivot, and enter those coordinates into the topology. Expect the axis directions from the base to the worktable end to come out negative. That is relative motion rather than a mistake: moving the table one way moves the tool the other way through the chain. Keep the meshes coarse. A machine carrying too much mesh is slower to open and slower to check for collisions, so export the components at the resolution a picture of the machine needs rather than at the resolution CAD produced them at. Example: a small five-axis vertical milling machine A worked example, complete with its STLs: B1.zip. The machine it describes: And the topology those anchors and branches form: Laying a machine on its side A horizontal machine is built exactly like a vertical one and then laid down: Create the topology from the machine's own axis coordinates. On the branch between the ground anchor and the machine base, set a rotation of 180 degrees about a normalized axis direction of (0, 1, 1). A machine tool file can also carry this same connectivity as a short bracket notation for hand-editing the XML — the grammar is Machine Chain Code. See Also Mechanism Builder — how to drive the editor the steps above are performed in Project Data Checklist — what to collect from the machine owner before building this Anchor — placing the fixture, workpiece and tool onto the chain built here Machine Chain Code — the bracket notation for the structure built here, and what it cannot express Fixture — what the table buckle built here then carries Spindle Capability — what this machine's spindle delivers, which the chain itself does not describe Controller — the brand whose per-axis rows this chain's axes fill Setup — the rest of the pre-simulation configuration"
  },
  "manual/setup/program-zero-alignment.html": {
    "href": "manual/setup/program-zero-alignment.html",
    "title": "Program Zero Alignment | HiAPI-C# 2025",
    "summary": "Program Zero Alignment Program zero is the point an NC program treats as X0 Y0 Z0. The machine finds it by adding a work offset — G54, G55 and the rest — to machine zero, so a simulation only cuts where the real machine cuts if the program zero on the model and the work offset in the controller agree. Making them agree is this task, and it runs in one of two directions depending on why the simulation is being built. Which direction to align You are Align Because Planning a job from an NC file, before the part is set up on the machine the work offset onto program zero The workpiece and fixture can sit wherever is convenient; the offset has probably not been measured yet, and the model does not have to match a real table Reproducing a cut from a controller log, a machine-coordinate feed, or a job already running program zero onto the work offset The recorded data is in absolute machine coordinates, so the part has to sit where it really sits, or collisions, overcut and engagement will not match what happened Both directions need the workpiece already placed on the fixture and the fixture on the table — that is Anchor, and it comes first. Where program zero sits on the workpiece Geom To Program Zero (/general-setup?tree=equipment/workpiece/anchor/geom-to-program-zero) holds the offset from the workpiece geometry to program zero. Set it to whatever point the NC program was written around: for most milling programs that is a corner or the centre of the stock's top face. Nothing else on this page makes sense until that point is where the programmer put it. Planning: write the offset from where the workpiece is The Controller branch's Work Coordinates leaf (/general-setup?tree=equipment/controller/program-data/work-coordinates) holds the table the run resolves G54 against, one row per coordinate id. Place the workpiece and fixture wherever the scene is convenient to work in. Select the Work Coordinates leaf and find the row the program uses — G54 for most programs. Press P0 in that row. It writes the machine coordinate the workpiece's program-zero anchor is currently sitting at into the row, which is exactly the number the machine's operator would key in after touching off. M0 beside it writes machine zero instead, which is how a row is returned to no offset at all. The leaf on a demo project, at /general-setup?tree=equipment/controller/program-data/work-coordinates. The grey line above the table names where this brand keeps the offsets — on Fanuc, its own parameter table — and the rows below it are the coordinate ids that brand holds, with only G54 carrying a value here. The panel is narrow, so the row actions sit off the right edge; the same three are shown in full on the Legacy Controller screen below. P0 has something to write only once the scene is assembled. It works out where the program-zero anchor is by walking the machine chain to it, so a project with no machine tool attached, or a workpiece that has not been placed, gives it nothing to compute and it reports that it could not get the machine position at program zero rather than writing a wrong number. The row's values can also be typed in directly when the offset is already known from the machine. Clicking anywhere in a row marks that coordinate on the canvas, so the offset can be seen rather than only read. Reproducing a real cut: move the workpiece onto the offset Going the other way — leaving the offset alone and moving the part to meet it — is Align P0, and it is on the Legacy Controller screen's Coordinate Table tab (/controller/coordinate-table), not on the Controller branch. It moves the workpiece and fixture together, by changing where the fixture sits on the machine table, until program zero lands on the offset the row holds. The toast reports the translation it assigned. The tab on a demo project. Each row carries P0 and M0 — the same two writes the branch's leaf offers — and ALIGN P0 beside them, which is the one control that moves the part instead of writing a number. Undo Align and Redo Align in the header step back and forth through the alignments this screen has recorded; Show on Display turns the coordinate marker in the viewer on and off, and the checkbox at the left of each row picks which coordinate it marks. Align P0 needs a workpiece, a fixture and a machine tool on the project; without all three it writes nothing and says so. Driving the screen itself — the tab strip, the alignment history and what it does and does not survive — is Legacy Controller. Warning Align P0 reads a different table from the one the run uses. The offsets on the Legacy Controller screen and the offsets on the Controller branch's Work Coordinates leaf are two separate stores: typing a value into one does not change the other, and nothing keeps them in step. A run resolves its work offsets through the branch's table, while Align P0 takes its target from the legacy screen's. So before aligning, check that the row you are about to press ALIGN P0 on holds the same offset as the branch's row of the same name — otherwise the part is moved onto a number the program will never use. A project built with both tables filled in agrees only because it was written that way. Checking that it worked A wrong alignment — a wrong offset, or a workpiece at the wrong height — shows up as overcut, collision or nocut, and it shows up early: usually within the first hundred or so NC lines. Check it cheaply before committing to a full run. Set a coarse Initial Resolution on the workpiece's Mesh item — around an eighth of the cutter diameter is enough to see gross errors, and it runs quickly. That is Workpiece. Run, and watch the opening Z plunge. This is where a wrong offset shows first. Tip If the tool plunges far deeper than the programmed depth and the holder gouges the stock, the work offset's Z is almost certainly wrong — the workpiece is modelled higher or lower than it really sits. One false positive is worth knowing: a roughing cut with a spiral entrance into tough material can legitimately exceed the modelled cutting conditions while the setup is perfectly correct. It is uncommon, and early overcut, collision or nocut usually does mean the alignment is wrong. When the planned offset is not the real one In the reproducing direction, the offset aligned to must be the offset the machine was actually using, not the one the job was planned with. Operators re-zero between setups — after a manual tool change, after re-cutting stock — so a planned G54 and the real one can differ by an amount that cannot be assumed in advance. When the data comes from a controller log, derive the offset from the log's own machine coordinates rather than trusting the plan: an invariant that survives an operator's edits — a known cutting depth, the span of a feature — mapped onto the recorded coordinates recovers the real offset on those axes. Axes the operator may have shifted with nothing to key on are not recoverable this way. A wrong Z is the one that bites hardest, because it places the workpiece away from its true height and the tool over- or under-plunges from the first block. A placement convention that makes this easier The three transforms that hold the assembly together can be put anywhere, but a block-on-plate setup is easiest to reason about when each sits at the middle of the face it meets: Transform A good default Fixture's Geom To Workpiece The top centre of the fixture geometry Workpiece's Geom To Fixture The bottom centre of the workpiece geometry Workpiece's Geom To Program Zero The top centre of the workpiece geometry, or whichever top point the program was written around Align P0 does not depend on this convention — it works out the fixture's placement from the assembly as it stands, whatever the transforms hold — but a scene built this way is far easier to check by eye. See Also Anchor — placing the workpiece, fixture and tool relative to the machine, which comes before this Assembly Anchors — the named buckle anchors this alignment resolves against Workpiece — the branch carrying the Geom To Program Zero transform this task sets, and the Mesh resolution the check above uses Fixture — the transform Align P0 rewrites when it moves the part onto an offset Controller — the branch whose work-offset table a run resolves against Legacy Controller — the screen Align P0 lives on, and its alignment history NC Dialects — how each brand's code names the work offset this alignment is expressed against Project Data Checklist — the collection step this alignment closes Workflow: Basic Machining Simulation — driving a simulation from an NC file or a controller log Workflow: Milling Force Parameter Training — milling force training, which depends on a correct setup Setup — the rest of the pre-simulation configuration"
  },
  "manual/setup/spindle-capability.html": {
    "href": "manual/setup/spindle-capability.html",
    "title": "Spindle Capability | HiAPI-C# 2025",
    "summary": "Spindle Capability Describing the machine's spindle: how much power and torque it delivers at each speed, for how long, and how hot it may get. You fill it in from the machine builder's spindle data sheet, and every spindle number a run reports is measured against it. What the curves mean physically is Spindle Capability; this page is where you enter them. Where it is The General Setup page, at /general-setup, reached from the menu bar's Page dropdown. Select the Spindle Capability branch of the Control Tree (/general-setup?tree=equipment/spindle) — the equipment item straight after Machine Tool. The tree and the selected node's editor share the left dock; this branch also fills the page's middle content column with a power and a torque chart, which stay mounted as you walk its six nodes. Until a project is open the branch is inert: the root reports No spindle capability attached to this project. and points at the Object Management (⋮) menu's Load, and each child shows No spindle capability attached. Load one on the Spindle Capability item. in place of its fields. The selection rides in the address bar as the ?tree= value the paths below quote; what those ids do and do not promise across versions is Finding Your Way. What each child asks for The root node carries the ⋮ menu first, then the Name and the Note; the five children carry the values, and each edit lands on the project's equipment as you make it. Node What to enter Thermal / Energy .../thermal Energy Efficiency, the output / input power ratio between 0 and 1; and the Working Temperature Upper Boundary in °C, the housing temperature the spindle is rated to work up to. Gear Shift .../gear-shift Whether the spindle has a gear-shift mechanism (L/H), and the Gear Shift Spindle Speed in rpm at which it changes range. Leaving the box clear states a single-range spindle; the speed field stays disabled. Dry-Run Coefficients .../dry-run The Friction Power Coefficient (mW/rpm) and the Windage Power Coefficient (pW/rpm³), the spindle's dry-run idle power — the two terms and where each dominates are Spindle Capability. Power Contours .../power One kW-against-rpm curve per duty rating. Torque Contours .../torque The same curves, in Nm. Entering a contour Select Power Contours or Torque Contours. Add asks for a workable duration in minutes, pre-filled with 60 — clear the field for the continuous curve — and starts the new curve as a copy of the selected one. Pick the curve to edit in the Contour selector, which names each by its duration and the unlimited one Continuous; its pencil button re-opens that duration, its delete button removes the curve, and a chip click on the chart selects one just as the selector does. The table below is the curve itself: one row per spindle speed and value, an insert button that clones a row, a double-click that removes one, and a chart that redraws on every edit. The delete button beside the pencil removes the whole selected curve. It is disabled while only one curve is left, so an axis that has curves cannot be emptied from here. Power Contours selected on a demo project, at /general-setup?tree=equipment/spindle/power. The tree shows the branch's five children; the middle column carries the pair of charts, which stay put as you walk between those children; and the panel under the tree is the editor for one curve — Power contours (2) with its Add button, the Contour selector reading 360 min, and the four rows of that curve. The chart legends carry one chip per curve, 360 min and Cont., and a click on a chip moves the editor to that curve. Where the numbers come from The machine's or spindle's spec sheet, as the speed–power–torque diagram with the duty ratings printed on it; which printed rating becomes which curve is Spindle Capability, which shows the mapping against a real datasheet chart. The default energy efficiency of 0.4 is the conversion HiNC's power figures were validated at, in Spindle Power Evaluation; what to ask the machine owner for is Project Data Checklist. The two dry-run coefficients are the ones a datasheet almost never prints. Their defaults — 4.82 mW/rpm of friction and 90 pW/rpm³ of windage — are estimated from published measurements of comparable spindles rather than measured on yours, and they are a reasonable place to leave the field unless you have run the spindle empty and measured its idle draw. Leaving the branch alone is a choice rather than a blank: a project never given a capability carries a stand-in — the TMV-720A-STD-8000RPM spindle, the same curves as one of the three shipped files, so its name is what the root node shows: 15-minute, 60-minute and continuous curves on each axis, topping out at 8000 rpm, with 0.4 efficiency and a 65 °C ceiling. That is fine for light cuts in small or soft stock. Near the machine's limit it is the wrong envelope, and everything measured against it inherits the error — the spindle torque, power and temperature ratios the run charts, and the feed the optimizer assigns under the spindle safety factors, which are Machine Condition and Safety Factors. Loading and saving The root node's ⋮ menu is the branch's whole file surface. The capability is stored in the project, so one already carrying the right spindle needs no file at all; Copy, Paste and XML Mode move it as XML, and an XML Apply installs exactly as a Load does. Load browses the server for a .SpindleCapability or .xml file — the project or administrator directory, the latter carrying the shipped resource library where three ready-made capabilities are installed. It replaces the capability outright; the branch and the charts reload onto the new one. Save As writes the current capability out, offered as SpindleCapability.xml in the project folder: how a spindle you have tuned becomes reusable in the next project. See Also Spindle Capability — what these curves mean, and how the run's spindle ratios and temperature come out of them Project Data Checklist — the data to collect from the machine owner before filling this branch in Machine Tool — the machine whose spindle this describes Setup — the rest of the pre-simulation configuration"
  },
  "manual/setup/workpiece.html": {
    "href": "manual/setup/workpiece.html",
    "title": "Workpiece | HiAPI-C# 2025",
    "summary": "Workpiece The workpiece is the stock the machine cuts. Setting it up means giving it the shape it starts as and the shape it should end as, placing it in the machine, choosing how finely it is meshed, and saying what it is made of. Where it is The General Setup page, at /general-setup, reached from the menu bar's Page dropdown. Select the Workpiece branch of the Control Tree (/general-setup?tree=equipment/workpiece). Whichever node you select opens its editor below the tree in the same dock, and the canvas beside them draws the workpiece in the shared equipment scene. A project carries its workpiece with it, so there is nothing to load: the branch root has no load or save button, and every part of the workpiece is edited through one of its child items. Those children appear once a project with a workpiece is open; until then the root shows a summary and a caption asking for a project to be opened or created first — see Projects. Attaching it to the machine is the anchor task below. The branch with the root selected, at /general-setup?tree=equipment/workpiece. The root itself has no editor — the caption in the middle column says so — while the canvas draws the stock sitting on its fixture, with the workpiece's two anchors labelled at the corner they are placed on. The two shapes Selecting Raw Geometry or Target Geometry opens the same Geometry type kind picker the fixture's geometry slot carries — see Fixture — over a different list of kinds for each slot. Slot What it is Kinds offered Raw Geometry equipment/workpiece/raw-geometry The stock as it arrives, before the first cut. This is what the run removes material from. Box3d, Cylindroid, StlFile, TransformationGeom, GeomCombination, MeshedGeomFile Target Geometry equipment/workpiece/target-geometry The finished part. The cut result is compared against it when a geometry difference is run after the program. Box3d, Cylindroid, StlFile, TransformationGeom MeshedGeomFile is a shape already meshed into a voxel cube-tree, stored as a .wct file. The target must produce a surface mesh to be compared against, so that kind is not offered there. A new project has a workpiece but no raw geometry. Creating one leaves the Raw Geometry slot empty, so picking a kind there is the first thing this branch needs — until it is done there is nothing for a run to remove material from. The Target Geometry slot is optional: it is what a geometry comparison after the run measures against, and a run without one still cuts. Where it sits Anchor (equipment/workpiece/anchor) holds the two transforms that place the workpiece. Geom To Fixture (.../anchor/geom-to-fixture) puts the workpiece geometry on the fixture's workpiece buckle — one of the four named assembly anchors the scene is built on — or, on a project carrying no fixture, straight onto the machine's table buckle. Geom To Program Zero (.../anchor/geom-to-program-zero) places the program zero, the NC origin, relative to that geometry. Setting them is Anchor; which direction to align program zero in — and why that depends on planning a new job versus reproducing a recorded one — is Program Zero Alignment. Mesh and material Mesh (equipment/workpiece/runtime) carries one field, Initial Resolution in mm, chosen from a fixed powers-of-two ladder running from 0.0009765625 to 16. The panel's hint is that a smaller resolution means a finer voxel grid and a slower run; what the number actually is and how to pick it are Mesh Resolution. It seeds the run's machining resolution when the project is opened. Important Keep the stored value on that ladder. The dropdown only offers ladder values, but a project arriving from an older generation, a script or a migration can carry something else — 0.4 mm is the one seen most often. Such a value is not a compromise between two rungs: the run rounds it to the next finer rung and uses that, so 0.4 mm builds the same 0.25 mm mesh at the same cost while the project reads as though it were coarser. Set it to the width it actually builds. The number then means what it says, here and in the Machining Resolution mission row that mirrors it. Material (equipment/workpiece/material) holds two references to pre-prepared files. Each is a file row whose Select dropdown offers Browse Resource… and nothing else — unlike the coolant row beside it, these two do not offer a plain Browse…, so the picker always opens in the shipped resource library, already in that resource's own folder. Loading one fills the read-only Name and Note below it. Workpiece Material selected on a demo project, at /general-setup?tree=equipment/workpiece/material/workpiece-material. The file row holds the material the project already carries, and the Name below it reads the name out of that file while the Note is empty — both are read-only, because they belong to the file rather than to the project. Workpiece Material (.../material/workpiece-material) — a .WorkpieceMaterial file: the physical properties the cutting-force physics reads. Cutting Parameter (.../material/cutting-parameter) — an .mp file: the milling-force coefficients for that material. One file serves the whole run, whichever cutters it uses. See Also Anchor — the two transforms above, and the order to place the machine, fixture and workpiece in Program Zero Alignment — which way to align the program origin once the workpiece is placed Fixture — what holds this workpiece on the table, and the buckle its Geom To Fixture transform lands on Mesh Resolution — how to choose the Initial Resolution, and the thin wall a coarse mesh loses entirely Milling Force Parameter Training — where a cutting-parameter file comes from when no shipped one fits Setup — the rest of the pre-simulation configuration"
  },
  "manual/utilities/file-explorer.html": {
    "href": "manual/utilities/file-explorer.html",
    "title": "File Explorer | HiAPI-C# 2025",
    "summary": "File Explorer Working with the files a project is built from, on the server rather than on your own machine. The File Explorer lists what is there, opens text files in an editor beside the listing, and uploads, downloads, renames, copies and deletes them. Where it is Its own page, reached from the menu bar's Page → File Explorer, at /util/file-explorer. It needs no project loaded. The same browser also runs inside every file dialog the application opens — the Project menu's entries, the Object Management buttons on the Control Tree, and the Mechanism Builder's Load and Save As actions — so learning it here is learning all of those. Only the page has the editor beside the listing; a dialog opens with that panel hidden and adds a bar for confirming the pick. The three roots The root selector at the left of the toolbar picks which tree is shown. There are three: Root What it holds Admin The server's working area. Projects and the shared resource library both live under it. Project The folder of the currently-loaded project. Listed only while a project is open. Resource The shipped library — controllers, cutter and workpiece materials, machine tools, spindle capabilities — in a folder named Resource under Admin. Everything the browser reports is named relative to the chosen root. Absolute server paths are not shown and are not sent to the browser, so a path copied out of this page names a location inside a root rather than a place on a disk. At /util/file-explorer/Resource/MachineTool/Table-B1.default, with the pointer resting on one row. The action strip appears only on the row under the pointer, and it is laid over the size and modified columns so nothing on the row moves as it appears. Finding a file Three ways in, and they agree with each other: Expand the tree. A folder lists its contents the first time it is opened, so a large tree costs nothing until it is walked into. Type the path. The path box in the toolbar takes a path relative to the selected root; Enter goes there. The arrow beside it goes up one level. Use the address. The location is mirrored into the page address as /util/file-explorer/<Root>/<path>, so a folder can be bookmarked or pasted to someone else. Browsing rewrites the address, and editing the address drives the browser. The breadcrumb above the listing goes back up in one click, and the sort control in the toolbar sets the order — by name, size, modified time or type, ascending or descending, with folders kept first or not. Reading and editing a file Clicking a text file loads it into the editor on the right; the bar above the editor names the root and the path, and the language selector beside it picks the syntax highlighting. That selector is set from the file's extension when the file opens — a project, machine tool, mechanism, material or milling-parameter file all arrive as XML — and can be changed for the file in hand. At /util/file-explorer/Resource/MachineTool/Table-B1.default, after clicking the mechanism file. The pencil button at the right of the toolbar hides and shows this panel; a file clicked while it is hidden opens nothing, so a double-click is the gesture that opens a file either way. Edits are not saved until Save is pressed, and the file's name carries a red mark while there are unsaved edits. Ticking Auto Save instead writes shortly after typing stops and disables the button; switching files, closing the panel or leaving the page flushes a pending write first. With Auto Save off, those same three actions ask before discarding unsaved edits. Binary files do not open here. A click on one reports that it is binary rather than filling the editor with bytes, and an .stl file opens a 3D preview in the editor's place instead — closing the preview brings back whatever text was underneath, unsaved edits included. Renaming and moving Rename on the row's action strip edits that entry's name. Because the name is written back as a path relative to the folder it is in, the same action moves files: Tip Moving by renaming Renaming file1.txt to Folder/file1.txt moves the file into Folder. Renaming file1.txt inside Folder to ../file1.txt moves it out to the folder above. Parent folders that do not exist yet are created. A move that would land outside the root is refused, and so is one whose destination already exists. A rename cannot move a file from one root to another. To do that, download from one and upload to the other. The other row actions Download saves the file to your own machine. On a folder it becomes Download as ZIP, which packs the folder on the server and sends the archive. Extract ZIP, offered on .zip rows only, unpacks the archive beside itself into a folder named after it. Duplicate copies the entry next to itself under the first free -Copy-00 … -Copy-19 name, and reports that all twenty are taken rather than overwriting one. Delete needs a double-click to confirm. On a folder it removes the folder and everything under it, and it will not delete a root. Upload, in the toolbar, sends one file from your own machine into the folder being shown, and overwrites a file of the same name that is already there. New Folder and New File beside it create empty ones; creating a file that already exists fails rather than emptying it. See Also File Explorer Page — the component this page describes: its toolbar, its picker mode, the roots it exposes and the endpoints behind each action Mechanism Builder — the other Page-menu utility, whose Load and both Save As actions open this browser as a picker Utilities — the other screens the Page menu lists beside this one Projects — what the Project root holds, and which of those files a Save As copies"
  },
  "manual/utilities/index.html": {
    "href": "manual/utilities/index.html",
    "title": "Utilities | HiAPI-C# 2025",
    "summary": "Utilities The supporting screens the Page menu lists below its first separator, rather than the three that carry a job from the tool house to a finished run: browsing the files a project is built from, assembling a mechanism outside the equipment tree, and the controller screen that still owns a handful of settings on its own. Two of the three open with no project loaded, which is what makes them supporting screens rather than steps. Ordered as the Page menu lists them. Pages File Explorer — Finding, reading, editing and moving the server's files, and the editor beside the listing Mechanism Builder — Building a mechanism out of anchors and branches, and writing it out as a machine tool file Legacy Controller — The three settings that have no editor anywhere else, and which face to edit for everything else See Also Setup — the equipment these files are loaded into Basics — the window and the Page menu that reach these screens"
  },
  "manual/utilities/legacy-controller.html": {
    "href": "manual/utilities/legacy-controller.html",
    "title": "Legacy Controller | HiAPI-C# 2025",
    "summary": "Legacy Controller The Legacy Controller screen owns three settings that have no editor anywhere else in the application. It edits a different controller model from the General Setup page's Controller branch, and neither screen sees the other's edits: those three are edited here, and everything else on the branch. Where it is Its own page, reached from the menu bar's Page → Legacy-Controller, at /controller/:tab?. It is not a Control-Tree branch; nothing in a tree reaches it. The left pane is a strip of seven tabs, each addressable as the last URL segment: Coordinate Table (coordinate-table, which a bare /controller opens), Datum Preset, Datum Shift, Offset Table, Machine, Brand and Config; the two datum tab buttons are shown only while the brand reads Heidenhain. The right pane is a 3D view, described under What the right pane draws below. Which face to edit Controller setup for a project belongs on the General Setup page's Controller branch — Controller. The brand, the stroke limits, the rapid feedrate, the tool-change time, the tool offset table, the work coordinates and the Heidenhain datum tables all have an editor there as well, and apart from one shared project flag — Set ideal offset dependent on tool house, which this screen's Offset Table tab and the branch's Tool Offsets leaf both write — the two screens edit different models. A value changed on one is not the value the other shows. Align program zero onto a work offset Align P0 is on the Coordinate Table tab and nowhere else. The branch's Work Coordinates leaf carries P0 and M0 on every row too; the alignment is this screen's. Which direction an alignment runs — the work offset moved onto program zero, or program zero moved onto the offset as this button does — and where program zero sits on the workpiece in the first place, are both Program Zero Alignment. Find the row holding the work offset program zero should sit at. Ticking the table's selection column is not part of this — that only moves the viewer's coordinate marker onto the row, and that marker is not drawn until Show on Display in the tab's toolbar is on. It ships off, so on an untouched project the selection column appears to do nothing. Press Align P0 in that row. It does not write the coordinate — it moves the workpiece and fixture together so that program zero lands on the offset the row already holds. The toast names the translation it assigned. It needs a workpiece, a fixture and a machine tool on the project — Setup — and without them nothing is written and the button says so. Undo Align and Redo Align, in the tab's toolbar, step back and forward through the alignments this screen has recorded. That history belongs to the screen rather than to the project: it holds 32 steps, survives a walk to another page and back, and is cleared when the project changes or the browser reloads the page. Each step restores the whole transform from a snapshot taken earlier, so if the fixture's placement was changed on another screen in between, an undo replaces that change rather than merging with it. At /controller/coordinate-table. Align P0 is a row action — every offset from G54 to G59.9 has its own, and there is no single button for the table. The tab strip shows five buttons here rather than seven because this project's brand is not Heidenhain; the two datum tabs appear only under that brand, though their addresses stay valid under any of them. The two switches nothing else carries Tab Setting What it is for Config Enable Shortest Rotary Path Takes each rotary axis of a block to the equivalent angle nearest the previous block's, so an axis turns the short way round instead of unwinding a whole turn. It arrives on. Under Heidenhain the same normalisation runs whatever the box reads, so clearing it changes nothing there. Brand Master-axis character Which rotary axis — A, B or C — the Heidenhain PLANE … SEQ orientations are resolved against; what that dialect's words do is NC Dialects. The card holding it is present only while the brand reads Heidenhain. Both commit on the click. If the master-axis write is refused a toast says so, but the select goes on showing the character that was picked, so a reload is what shows which one actually took — and a reloaded A settles nothing, because the Brand tab also falls back to A, silently, when the read itself fails. At /controller/config. The whole tab is that one switch. The master-axis select is not beside it — it is on the Brand tab and, as the table above says, only while the brand reads Heidenhain, which is why it is absent here. What the right pane draws The 3D view beside the tabs draws the same scene as the Execution page, and its Scene dropdown writes the same switches — so what is ticked here is ticked there. It offers three groups: the machine tool, the cutter, the workpiece and the fixture; the program-zero and work-offset markers, the Heidenhain one appearing only under that brand; and the dimension bar and colour scale bar. Of those, only the workpiece, the fixture and the dimension bar arrive on. The machine tool and the cutter arrive off, and so do the coordinate markers — the work-offset one is exactly what Show on Display turns on for this screen's table. A freshly loaded project therefore opens this pane with little or nothing in it, and that is the shipped state rather than a failure to draw. See Also Utilities — the other screens the Page menu lists beside this one Mechanism Builder — another of the supporting screens the Page menu lists, for assembling a machine chain Controller — the branch that owns controller setup for a project, and every setting this screen does not exclusively hold Program Zero Alignment — which direction an alignment runs, where program zero sits on the workpiece, and why this screen's table is not the one a run reads Legacy Controller Page — the component behind this page: its seven tabs, the model it edits and the one it does not"
  },
  "manual/utilities/mech-builder.html": {
    "href": "manual/utilities/mech-builder.html",
    "title": "Mechanism Builder | HiAPI-C# 2025",
    "summary": "Mechanism Builder Building a mechanism: anchors joined by branches, each branch carrying the transform between its two ends, and each anchor optionally carrying a shape. It is where a virtual machine tool's topology is assembled and then written out as a file a project can load. Where it is Its own page, reached from the menu bar's Page → Mechanism Builder, at /util/mech-builder. Nothing on it belongs to a project, so it opens and edits with no project loaded, as the File Explorer beside it does. The mechanism is held by the server rather than by the page — more than the page keep-alive The Application Window grants every screen, because there is one mechanism per server rather than one per browser: a second person editing at the same time is editing the same one. Three fixed, equal-width columns, none of them draggable: the File menu, the Add Anchor button and the graph of anchors and branches on the left, where clicking a node, or the label on an edge, selects it; the editor for whatever is selected in the middle, headed Anchor or Branch; and Display, the 3D view of the mechanism, on the right, which redraws as the mechanism changes. At /util/mech-builder, with an anchor picked in the graph. The open file's path sits under the File menu; the header of the middle column carries Extend and the delete button; and the Geometry card here holds a TransformationGeom, so its own inner geometry — an STL file — and its own inner transformer are edited underneath it. What the anchors and branches must be called — the motion-axis and end-anchor keywords, which way branches must point, and how to take the numbers off a CAD assembly — is Building Virtual Machine Tools; this page is only how to drive the editor. Starting, loading and saving File menu entry What it does New Discards the mechanism on screen and starts an empty one holding a single root anchor. Load… Opens the server file picker — File Explorer's browser in picker mode, over the roots that page lists — filtered to *.GeneralMechanism and *.xml. The server reads the file where it sits and remembers its folder. ReLoad Re-reads the file you last loaded, dropping the edits made since. Disabled until a file has been loaded. Save As General Mechanism Writes the mechanism as a .GeneralMechanism XML where you pick, and re-points ReLoad at it. Save As Machine Tool Wraps the same mechanism as a machine tool and writes a .MachineTool XML. ReLoad goes on pointing at the mechanism file, because a machine tool is a different file type. There is no plain Save that overwrites what you opened: both writes are Save As and both ask where the result goes. Under the File menu the left column shows the open file's relative path, or (unsaved) while the mechanism has no file yet — after New, until the first Save As. Note Load's file-type filter does not list the extension the shipped mechanisms use. The picker opens filtered to *.GeneralMechanism and *.xml, while the mechanism beside each shipped machine tool under the Resource root is named .general-mech. Switch the picker's file-type selector to All Files (*.*) to see it. The filter hides those files; it does not refuse them, and one picked that way loads normally. Note Save As Machine Tool does not check the end-anchor keywords. The write succeeds and reports the file saved whatever the anchors are called, including a mechanism whose tool-end and worktable-end anchors are mis-cased or missing altogether. A file written here asks for its collision pairs to be generated, and generating them needs those two anchors by their exact names, so such a file is refused the first time anything reads it — on the General Setup page's Machine Tool branch, not here, and with a message naming the keyword it wanted. Get the names right before saving; they are in Building Virtual Machine Tools. A .MachineTool written here is not a project's chain until it is loaded onto one, on the General Setup page's Machine Tool branch — see Building Virtual Machine Tools. Growing the chain Click an anchor in the graph to select it. The root carries a Root badge and is the one anchor that cannot be deleted. Press Extend in its header. That creates a new anchor and the branch reaching it from the selected one, then selects the new anchor — the normal way a chain grows. Add Anchor, beside the File menu, is for a loose anchor instead: it creates one connected to nothing, which you join up afterwards with the Add Branch picker on an anchor's Identity card. That picker offers every anchor except the selected one and those already joined to it in either direction. Name each anchor as you make it. New ones arrive as NewAnchor-001, NewAnchor-002 and so on, so type the real name into Name on the Identity card; it commits a moment after you stop typing. A branch carries a Name field of its own in the same place. Deleting an anchor or a branch is a double-click on the red delete button in its header. Geometry on an anchor Geometry is optional and belongs to one anchor at a time. Select the anchor and tick Geometry on the Geometry card; a badge beside the checkbox names the shape currently held, and un-ticking the box removes it. Five kinds can be built here — Box3d, Cylindroid, StlFile, TransformationGeom and GeomCombination — and TransformationGeom carries its own inner geometry and inner transformer, so a shape can be offset from the anchor it hangs on. Display color, above the shape editor, is written into the mechanism file itself, so everyone who opens that file sees the same colour; until you set one the badge reads auto and the view uses a stable colour of its own, which the reset button beside the swatch returns to. The branch transformer Click the label on a branch's edge — the transformer type, or the branch's name and type — to select the branch. Its Identity card names the two anchors it joins in order, the one the branch starts from and then the one it reaches, with an arrow between them; that order is the branch's direction. Below that, the Transformer card picks between seven kinds, in the order the picker lists them: Static Translation, Static Rotation, Static Freeform, Dynamic Translation, Dynamic Rotation, General Transform and No Transform — which is what every new branch starts on. Pick a kind and its fields appear underneath; the choice takes effect at once, so the right-hand view shows the joint as you edit it. The two dynamic kinds are the ones whose value varies at runtime — a machine's moving axes are branches carrying those. At /util/mech-builder, with a branch picked. A Dynamic Rotation carries the axis it turns about and the pivot it turns around; the angle is the value a run varies, so the number shown here is the resting one. The sentence under the fields names the same three parts. See Also File Explorer — the server-side browser behind this page's Load and Save As dialogs, and the roots they offer Utilities — the other screens the Page menu lists beside this one Legacy Controller — the other supporting screen in the Page menu, for the three settings nothing else edits Building Virtual Machine Tools — the naming keywords, branch direction and CAD practice a machine chain built here must follow, and where the saved file is attached to a project Mechanism Builder Page — the component behind this page: its cards, its file IO and how edits reach the canvas"
  },
  "product/about.html": {
    "href": "product/about.html",
    "title": "About Us | HiAPI-C# 2025",
    "summary": "About Us Super High Technology Co., Ltd. was founded in March 2016 by Dr. Ko-Jen Mei, who holds a Ph.D. in Mechanical Engineering from National Cheng Kung University. Virtual machine tool technology will enhance machining capabilities and efficiency while reducing machining risks and operator barriers. We are dedicated to virtual machine tool and CNC machining technology. Contact Information Phone: (+886) 6-3127517 Email: service@superhightech.com.tw Address: 9F.-11, No. 3, Ln. 60, Zhongyi St., Yongkang Dist., Tainan City 710012, Taiwan (R.O.C.) Website: superhightech.com.tw"
  },
  "product/index.html": {
    "href": "product/index.html",
    "title": "Product | HiAPI-C# 2025",
    "summary": "Product Product information, licensing, activation, and management. For the short buyer-facing tour — what HiNC is for, the function menu, and the headline results — see the HiNC product page. That page and this site divide the work deliberately: it carries the framing, this site carries the reference depth, and neither reprints the other. Information About — About Tech Coordinate and contact information System Requirements — Supported operating systems, and what a high-resolution simulation actually needs from CPU, memory, GPU and disk License Terms — HiNC user terms Getting Started Windows Activation — Activate HiNC on Windows License Update — One-click installer, or update the dongle from a browser Multi-Station Setup — Run multiple HiNC stations on one machine Delegated Authorization — Delegate authorization via a sentinel host Tutorial Videos — Video tutorials Managing the files a project is built from is an application task rather than product information; it is File Explorer under the Manual."
  },
  "product/license/index.html": {
    "href": "product/license/index.html",
    "title": "HiNC User Terms | HiAPI-C# 2025",
    "summary": "HiNC User Terms Party A: Super High Technology Co., Ltd. Party B: User WHEREAS Party A authorizes Party B to use one set of HiNC software module, this document is hereby established, and Party B has read and agreed to the following user terms: Article 1. Subject Matter HiNC software module (hereinafter referred to as “the Module”), content and authorization period as specified in the specification sheet provided by Party A. Article 2. Intellectual Property Protection and Confidentiality Obligations The structure, organization, and code of the Module are valuable trade secrets and confidential information owned by Party A. The intellectual property rights of the Module and all related materials provided by Party A belong to Party A. The Module is for Party B's internal use only. Party B agrees to use the Module in accordance with the user terms. Party B shall not rent, lease, authorize, transfer, or sell the software, provide the Module to third parties, nor modify, translate, reverse engineer, decompile, or decode the software program. Derivative software developed by Party B, its derivative intellectual property and income belong to Party B. Article 3. Software Assurance Limitations The Module is provided “as is”, and any other express or implied representations, descriptions, or warranties are not included in the assurance. Party A and its distributors shall not be liable for any special, direct, indirect, or other damages caused by other events. All results and performance arising from the use of the Module shall be borne entirely by Party B. Article 4. Information Collection Party B agrees to provide the Module's usage count, usage time, and partial hardware information to Party A. When Party B's authorized computer is connected to the Internet, Party B agrees that the information listed in Item 1 of this Article will be transmitted by the Module to Party A via network transmission. All recorded and transmitted information is limited to use for Party A's authorization verification and software protection purposes and will not be disclosed to third parties or used by third parties. Article 5. Agreement to Terms When Party B installs Party A's software, the system will display the terms and conditions of the “User Terms”. Party B must accept the terms and conditions of the “User Terms” to use the software product. If you do not agree to the terms and conditions of the “User Terms”, please do not install, copy, use, access, or execute the software product, and immediately submit a written return notice to your point of purchase. By exercising the rights granted in the “User Terms”, Party B agrees to comply with its terms and conditions. Article 6. Breach of Contract If the user violates all or part of these User Terms, Party A has the right to make its own judgment and take measures it deems appropriate, including terminating the contract between Party A and the user, immediately suspending the user's use of the Module or other services of Party A, and does not exclude taking legal action against such users. Article 7. Partial Invalidity When part of these User Terms is deemed invalid by law, other terms shall continue to be valid. (Below blank) Party A: Super High Technology Co., Ltd. Representative: Ko-Jen Mei, Responsible Person Unified Business No.: 24921337 Address: 9F.-11, No. 3, Ln. 60, Zhongyi St., Yongkang Dist., Tainan City 710012, Taiwan (R.O.C.) Date: January 27, 2020"
  },
  "product/startup/delegate-auth.html": {
    "href": "product/startup/delegate-auth.html",
    "title": "Delegated Authorization for Multi-Host Deployment | HiAPI-C# 2025",
    "summary": "Delegated Authorization for Multi-Host Deployment If multi-host licensing is enabled, one machine acts as the license server and the others are authorized clients. Both sides have to be configured, and every machine involved needs the Sentinel Run-time Environment installed. The quickest way to get the Sentinel Run-time Environment onto each machine is the one-click installer on the license activation page — it installs the run-time and updates that machine's license in one step. Contact us for the server-side and client-side configuration guides. The license server may be blocked by the Windows firewall. You can allow it through as shown below: When using a red license dongle, the Sentinel Run-time Environment is required for standalone operation as well, not only for multi-host setups."
  },
  "product/startup/license-update.html": {
    "href": "product/startup/license-update.html",
    "title": "Updating Your License | HiAPI-C# 2025",
    "summary": "Updating Your License Your HiNC license lives inside the USB dongle (Sentinel key) plugged into your computer. When a license is renewed, extended, or has modules added, the new entitlement has to be written into that dongle. Everything you need is on one page: https://superhightech.com.tw:20443/license/ The page is available in English and 繁體中文. Use the switch at the top right, or open the address with ?lang=en or ?lang=zh-Hant. Before you start, plug the USB dongle into the computer you are going to work on, and make sure that computer can reach the internet. The one-click installer This is the way to do it unless you have a reason not to. Download the installer from the top of the activation page and double-click it. Windows asks whether to allow it to make changes — choose Yes. From there it runs on its own: it checks whether this computer has the Sentinel driver, and installs it if not; it finds the USB dongle; it fetches your license update and writes it into the dongle; it reports, line by line, what it did. There is nothing to configure, no folder to prepare, and no command to type. When it says the update is complete, you are done. Keys on the computer that are not HiNC keys are recognized and skipped, so seeing one listed as skipped is normal. If it reports that no key was found, plug the dongle in and press the button in the window to run it again. Updating from the browser instead The activation page can also do the update itself, with nothing to download. This route needs the browser's permission to reach the Sentinel service running on your own computer, which some company networks and browser settings block — that is the only reason the installer above exists. Press Start online update. If the browser asks for permission to access the local network, choose Allow. Wait for License update complete. If the page reports that no update is waiting, your license is already up to date. If it reports that it cannot reach the Sentinel service on your computer, use the one-click installer, or Manual update below. Manual update The manual route depends on nothing at all — no permission, and no access from the browser to your machine — so it always works. Open Manual update on the page and follow the three steps: Press Open Sentinel admin page, click Sentinel Keys on the left, find the row for your key, and press C2V to download the .c2v file. If that row has no C2V button: Configuration → Basic Settings → tick “Generate C2V file for HASP key” → Submit, then go back to the Sentinel Keys page. Back on the activation page, choose the .c2v file and press Generate license file. A .v2c file is downloaded. Tick the reissue box only when you are recovering — after a reinstall, on a replacement computer, or after an update that failed to apply. In the Sentinel admin page, click Update/Attach → choose the .v2c file → Apply File. Once it reports success, return to the activation page and press I have applied it successfully, so the update is closed on our side as well. Installing the Sentinel run-time on its own The one-click installer already does this for you. Install the run-time by hand only when you need it without a license update — for example when preparing a machine ahead of time. The activation page offers the plain Thales installer at the bottom, behind a download password: hi Move the installer into a folder of its own before running it, and run it with administrator rights, allowing the system permission prompt. The installer also applies any .v2c file sitting in the same folder. If you run it from a downloads folder that already holds license files, it ends with V2C Error: key to be updated not found — that message is about one of those old files, not about the installation. The driver still installed correctly; a folder of its own avoids the message entirely. The Sentinel run-time is required for the browser route in every case. With a red dongle it is also required for normal standalone operation, and for multi-host delegated authorization it is required on every machine involved. If it still fails Contact your usual service contact. Include your key number and the messages shown on the page or in the installer window — they name the exact step that failed, and the installer window has a Copy messages button for exactly that."
  },
  "product/startup/multi-station.html": {
    "href": "product/startup/multi-station.html",
    "title": "Single-Machine Multi-Station | HiAPI-C# 2025",
    "summary": "Single-Machine Multi-Station If multi-process licensing is enabled, you can use different appsettings.<profile-name>.json files to serve multiple processes. Each process can run a different project simultaneously. The following fields must be unique across all appsettings.<profile-name>.json files on the same host: Endpoints DatabasePort CacheDbId Run the following command to launch a specific profile: dotnet run HiNcServer.dll --environment <profile-name> Important The Users entries in the examples below carry placeholder passwords. Set your own before putting a station into service. Configuration Examples appsettings.Sub-1.json appsettings.Sub-2.json"
  },
  "product/startup/tutorial.html": {
    "href": "product/startup/tutorial.html",
    "title": "Tutorial Videos | HiAPI-C# 2025",
    "summary": "Tutorial Videos Building Machine Structures and Tools https://superhightech.com.tw/download2/機構建構器建立虛擬機床.mp4 https://superhightech.com.tw/download2/建立臥式機床.mp4 https://superhightech.com.tw/download2/刀具建立-銑削與刀把.mp4 Project Setup and Execution https://superhightech.com.tw/download2/範例專案設置說明.mp4 https://superhightech.com.tw/download2/範例專案仿真說明.mp4 https://superhightech.com.tw/download2/建立專案.mp4 Sample Project Download https://superhightech-gitea.webredirect.org/HiNC-Deploy/DemoStandardPath/archive/master.zip"
  },
  "product/startup/windows.html": {
    "href": "product/startup/windows.html",
    "title": "Getting Started with HiNC | HiAPI-C# 2025",
    "summary": "Getting Started with HiNC This section covers how to set up and launch the HiNC system in different environments, including basic installation on Windows, single-machine multi-station configuration, multi-host authorization setup, and tutorial videos. License Update Single-Machine Multi-Station Configuration Multi-Host Delegated Authorization Tutorial Videos Launching HiNC on Windows Download and extract the HiNC installation package from the official website: https://superhightech-gitea.webredirect.org/HiNC-Deploy/HiNC-Manager-Win/archive/master.zip Plug in the HiNC license dongle and run HiNC-loop-with-update.bat from the extracted folder. This script downloads or updates the HiNC software into the HiNC subfolder each time it runs. After the first run, a HiNC subfolder will be created. Except for appsettings, all other file changes within the HiNC folder will be overwritten after an update. If non-system modifications exist in the HiNC folder, the download or update may fail. In that case, manually delete the entire HiNC folder and run HiNC-loop-with-update.bat again. Demo video If the default download mirror is too slow, you can first use HiNC-update-gitcode.bat to download from the gitcode mirror, then run HiNC-loop-with-update.bat. Inside the HiNC subfolder you will find the appsettings.json file, which is used to configure HiNC settings such as the web address, user credentials, etc. The following explains the default values. HiNC does not check for license updates on startup. The LicenseManager section below is used by the standalone license tool; the shipped HiNC server does not read it, so leave Command as DoNothing. \"LicenseManager\": { //Available Command: \"DoNothing\",\"AutoLicenseUpdate\",\"GetC2V\",\"GenV2C\",\"ApplyV2C\",\"WriteInfo\" \"Command\": \"DoNothing\" } The appsettings.json file creates ../HiNC-Root by default as the storage location for data and projects. If HiNC repeatedly shows long error messages on startup, the operating system may be outdated or not recently updated. Please install Microsoft Visual C++. Open a web browser and navigate to the default URL: http://localhost:4330 Sign in with the administrator account issued for your installation. Important A fresh installation ships with a fixed default administrator password. Change it at first sign-in — a station left on the factory default is reachable by anyone who can open its URL."
  },
  "product/system-requirements.html": {
    "href": "product/system-requirements.html",
    "title": "System Requirements | HiAPI-C# 2025",
    "summary": "System Requirements Operating System: Windows 10 or later Ubuntu 22.04 LTS CPU Architecture: x64 (ARM not yet supported) Browser: Chrome 115, Edge 115, Firefox 115 or Safari 16, or any later version. The web interface is built to that language level, and an older browser cannot run it. The 3D view is rendered on the server and arrives as a stream of images, so the browser itself needs no graphics capability Runtime: none to install. Both the web service and the Windows desktop application are published self-contained, so they carry the runtime they need. A .NET project that references the HiAPI packages directly is the one case that needs a runtime installed, and it must be .NET 10.0 — every published package targets it, and an earlier runtime cannot load them at all Memory (RAM): Minimum: 8GB RAM (suitable for low-resolution models) Recommended: 128GB RAM or higher (for large and detailed models) Graphics: OpenGL 3.3 compatible graphics card or integrated graphics Most computers manufactured within the last 15 years meet this requirement Performance Guidelines for High-Resolution Simulation Based on internal testing and practical experience: CPU Considerations High clock speed is prioritized over multiple cores Single-thread performance is more important than multi-core parallelization For small NC programs: 16GB RAM is workable Graphics and GPU GPU is used only for 3D rendering/visualization, not for computation acceleration A working OpenGL context is required even if nobody looks at the 3D view: the rendering engine is initialised at startup, and the software will not start without one Cloud deployment is supported, but choose an instance that has a GPU with its graphics driver installed. Instances with no GPU, or with a GPU whose driver is missing, are the usual cause of a failed start Storage Performance SSD (Solid State Drive) recommended for optimal simulation efficiency Traditional HDD may cause significant performance degradation."
  },
  "release-note/index.html": {
    "href": "release-note/index.html",
    "title": "Release Note | HiAPI-C# 2025",
    "summary": "Release Note HiNc Packages 3.2 At a glance 3.2 is largely one piece of work: the NC interpreter that reads a controller program is now composed from configurable parts rather than written into one class, and most of this release is the brand coverage that made possible. A Siemens or Heidenhain program that 3.1.175 could not interpret past its first computed coordinate or subprogram call now replays end to end. Control-language coverage. The figure is how far our own verification has reached on that dialect — it is not the share of the language that is implemented, and it is not a guarantee for a program we have not seen: Control language Verification reached Cutter location (NX CLSF / APT source) ~90% Fanuc ~80% Siemens SINUMERIK ~60% Heidenhain (klartext and DIN/ISO) ~40% Syntec and Mazak run on the Fanuc-family vocabulary; their brand-specific syntax has not been worked through and they are not covered by the figures above. The per-construct picture — including what is recognized and deliberately not simulated — is in the brand support matrix. Failures say what went wrong. The class of defect this release spent most effort on is the silent one: a Siemens tool offset with no table row that resolved to zero and machined a whole program one tool length low, a G68 rotation that did nothing while reporting itself active, a tilted plane the machine could not reach. Each of those is now a named, searchable diagnostic rather than a plausible-looking wrong result — see the diagnostic id table. Simulation is faster and holds a bigger program. Physics moved into the native kernel (a paired play: 59.3 s / 16.1 GB allocated → 40.6 s / 3.4 GB), building the topology of a large STL is linear rather than quadratic in triangle count, and a long program no longer degrades as it plays. Figures and their conditions are under Performance and footprint. The application product moves to the web API. The web service is the application the product line is built on, and its source is the same HiNC-2025-webservice sample we publish — what you read there is what the product runs. A Windows desktop client ships alongside it on the same packages, and no new feature work targets it. The Blazor front end builds against the same 3.2 packages but is not published as a product. Important Adoption status. This drop is published for review. Verification is still in progress across most areas, and the coverage figures above are the honest state of it. Do not put 3.2 NC optimization into production. It is not finished on this line. Work that depends on optimization should stay on the 3.1 line, which is serviced as 3.1.175.<patch>. The Blazor front end tracks the 3.2 packages, so it is not a way to stay on the 3.1 behaviour. What changed This one entry covers everything since 3.1.175. The 3.1 line is closed at the 3.1.175 package set and is serviced only as 3.1.175.<patch>; master moved all ten packages onto the 3.2 line on 2026-08-24 and restarted their build counters. So a 3.2 build number starts low, the two counters are not comparable, and the gap between the last 3.1 number a feed served and the first 3.2 one is expected rather than a missing upload. The versions in between were never published as a release set, which is why they are merged here rather than listed separately. Each package's build counter advances on its own, so no single number is common to all ten; a set is named by its HiNc package version — see The package line. Everything below therefore lands at once on a caller moving a 3.1.175 reference to 3.2. See Upgrading from 3.1.175 to 3.2 for the full detail — the summary here is the shape of the upgrade, not the whole of it. Breaking changes In the order they will bite. Full table with replacements on the upgrade page. Registration: XFactory.Generators becomes a ConcurrentDictionary (a caller declaring the old type breaks at compile time), and LocalProjectService.Reg() must still be called once at startup before any project XML is deserialized Messages: MixedProgress0, MultiTagMessage and MultiTagMessageUtil are removed; every message parameter is retyped from IProgress<object> to IProgress<IMessage>; Category.General is deleted and NcDiagnostic.Text renames to Notification Session lifetime: LocalProjectService.SessionShell is null outside a session and ShellProgress is recreated per session — hold no long-lived reference; MachiningSession takes an injected IMachiningService, and IMachiningService replaces PlayerCancellationToken / PausePlayer with one PacePlayer Play verbs: PlayNcFile / RunNcFile gain an NcKind kind = NcKind.Auto parameter and dispatch by extension; the old narrow verbs become PlayBrandNcFile / RunBrandNcFile. The “Control” vocabulary retires with them (IControlRunner → INcRunner, RunControlLines → RunNcLines, ControlKind → NcKind) Hard renames, no shim: runtime geom → meshed geom across WorkpieceService; IContourTray / UniformContourTray / FreeContourTray → IFluting / UniformFluting / FreeFluting and MillingCutter.FluteContourTray → Fluting; HiNc's Hi.Common.ResourceUtil → ResourceLayout (it was shadowing HiGeom's same-named type); the native topo-STL wrappers move to Hi.Geom.Topo; ITimeGetter → ITimecoded; ClStrip.DrawingRefreshing → DrawingRefreshed; SoftNcRunner.NcDependencyList → PipelineNcDependencyList Removals: CsvRunner0 and EnableSoftCsvRunner, RawCsvRunner, IndexedSentence, SimpleSessionCommand, LsStl; the GUI-layer types MachiningProjectDisplayee, IsoCoordinateEntryDisplayee, HeidenhainCoordinateEntryDisplayee, UserConfig, UserService and PlayerDivConfig; the managed physics kernel types FluteZData, MillingForceUtil.RuntimePack / LayerPack / AnglePack and MillingPhysicsBrief.YieldStressMinHeight_mm; CultureUtil.SupportedCultureNames and SetCurrentCulture(string); eight gl* P/Invoke declarations that had no backing export; and PostExecutionCommand's meshed-geometry output pair (use RecordMeshedGeomCommand / ExportMeshedGeomToStlCommand instead) Shapes: MachiningToolHouse derives from Dictionary<int, IMachiningTool>; MachiningStep.ActualTimecode / ActualDateTime become get-only views onto the new ActualTime; PreSettingCommand becomes a legacy bundle that expands on load into five single-setting commands and is never written back; ToPresentDto wire keys change Defaults: EnableSoftNcRunner is true — SoftNc is the NC engine and HardNcRunner is the opt-out fallback; EnableNativeMillingPhysics is true and a shipping build throws if you set it false; YieldingStressRatio reports NaN instead of 0 when it cannot be evaluated, so a caller reading 0 as “no constraint” must add a NaN branch New licence feature NcComposition (id 22) gates registering a non-built-in unit into a SoftNcRunner pipeline and executing an NC-embedded C# script. Degradation is silent and functional — the unit is skipped with one Composition--NotLicensed — so an unlicensed installation produces a different simulation, not an error Packaging: x64 only; the shipped machine-tool packages are renamed and now carry the .default marker (MachineTool/Table-B1.default, MachineTool/CT-350.default), so a project that refers to one by its earlier path must be repointed; HiNcServer pins request localization to English and HiNcRcl drops the inert HiNC:DisplayEngine:FontFile key Some results change without any code change — the pivot-transform anchor, a G68 rotation that was a silent no-op, blank lines resetting G90/G91, Heidenhain absolute arc centres, five-axis IK about 1000× tighter, and MC-linear moves stepping by euclidean tip travel. They are listed with their symptoms under Results that change on upgrade. New in this release Siemens SINUMERIK programs replay end to end — real .mpf / .spf files rather than an ISO subset: modal vocabulary and T=\"name\" tool calls, an expression evaluator over R-parameters and $-system variables, programmable frames and $P_UIFR, TRAORI RTCP and CYCLE800 swivel, subprogram and MCALL cycle calls, full control flow with iteration watchdogs, the AC() / IC() / DC() per-word coordinate functions and the coded-position family Heidenhain plays both dialects on one preset — klartext motion, datums, tool calls, arcs and cycles; Q-parameter evaluation with FN 9–12 conditional jumps; the PLANE / FUNCTION TCPM / M128 tilt and RTCP stack; subprogram and CALL PGM calls; post-processed spellings written without separators; and the DIN/ISO dialect with its absolute I / J / K arc centres Fanuc Custom Macro B and polar interpolation — #var expressions, IF / GOTO / WHILE, M98 / M99 subprograms and G65 / G66 macro calls; G12.1 / G13.1 polar coordinate interpolation with G41 / G42 compensation on the hypothetical plane SoftNcRunner is the default NC pipeline. See NC Parsing Engine for its architecture and the per-brand support matrix NC optimization runs on that pipeline — not finished on this line, see Adoption status above — regenerating text as anchored token edits over the verbatim source block, so lines the optimizer does not touch round-trip byte-identically. Output follows the source's decimal digits and is written back in the source file's encoding, so a GBK or Big5 program keeps its comments Cutter-location files drive a real machine chain, not only a ClMillingDevice, and a played CL program converts to Fanuc NC through ConvertClToNcFiles Milling physics moved into the native kernel — engagement, force and the sequential thermal chain — with the tool's scalar physics frozen once per session into MillingToolPhysicsPack, which also makes force waveforms reproducible between two plays of the same program Session commands declare themselves through CommandCatalogAttribute and CommandFieldAttribute, so a generic editor renders them without a hand-written form; the HTTP surface answers a no-session or no-project call with 409 and an ApiActionResult envelope carrying the call's notifications Diagnostics carry a template and its arguments, so a front end can re-render a notification in its own language, and repeats fold into one per-run summary instead of one message per block Shipped resources carry a .default marker distinguishing system territory from user files, and HiNc-Resource ships the five brand controller presets and three coolant presets so those load browsers start populated A parser configuration is a file, and it is shareable. NcRunnerSuit bundles a runner with its per-case data as one loadable unit, and per-case data now travels as proxy placeholders that resolve against the owning project — so one controller configuration is no longer welded to the job it was first built for A long program no longer degrades as it plays. A dead equality guard made the session append an NC-optimization option entry for every played act instead of only at change points, and reading the last one walked the whole map — together, quadratic. On a 2.35-million-line Siemens program the per-100,000-line rate now stays flat instead of climbing from 73 s to about 11 minutes. It applied to every runner, including sessions doing no optimization at all Performance and footprint, measured — physics in the native kernel takes a paired play from 59.3 s / 16.1 GB allocated to 40.6 s / 3.4 GB; building the topology of a large STL is linear instead of quadratic in triangle count (18.7× at 300k triangles, and it was 99.6% of the load); re-triangulating after a cut is about 2.2× faster; and a long program no longer exhausts client memory (session retention on a 25,000-block play: 406 MB → 142 MB). Every figure with its conditions — including the two things that cost more on purpose — is under Performance and footprint Stability and data integrity — the native crashes from disposing a display or geometry object still in use, the intermittent “No cut / No data for step” on freshly-simulated steps, the project-file race between a Load and a Save, and non-reproducible milling-force waveforms are all fixed; large geometry now builds its display topology off-thread instead of freezing the UI HiNc Packages Version 3.1.175 WorkpieceService file IO now takes relative paths and resolves them against a base-directory Func<string> injected by LocalProjectService — the runtime-geometry write/read no longer requires the caller to pre-combine an absolute path. WorkpieceService.ReadRuntimeGeom (now ReadMeshedGeom) now returns whether the source file existed (the not-found notice moves to the calling shell) Rename runtime-geometry mesh-export methods to the Export* convention (STL/OBJ/PLY are foreign interchange formats, not native writes): WriteRuntimeGeomToStl/Obj/Ply → ExportRuntimeGeomToStl / ExportRuntimeGeomToObj / ExportRuntimeGeomToPly; the session command WriteRuntimeGeomToStlCommand → ExportRuntimeGeomToStlCommand (now ExportMeshedGeomToStlCommand) keeps the old <WriteRuntimeGeomToStlCommand> element name as a back-compat alias so existing projects still load HiNc Packages Version 3.1.173 Improve Mrr_mm3ds precision: the material-removal-rate now sums each cut contour's signed area-vector (fan triangulation, skipping non-finite triangles) projected on the feed direction, replacing the per-contour bounding-box area that over-estimated the cut cross-section Add AlignWorkpieceProgramZeroToIso script command: resolves a G54/G55/… entry from the project ISO coordinate table and places workpiece + fixture so the program zero coincides with that machine coordinate (topology math delegated to the new AlignWorkpieceProgramZeroToIso extension) Drop gRPC plumbing from the HiNc package: remove Hi.Grpcs.* ClStrip/Player service runners and protos, MachiningProjectGrpcServer, MonitoringPlayer, and UniversalNcMonitorClient; fold CsvRunnerConfig back into CsvRunner0 (gRPC services now ship in HiNcRcl and a downstream RCL package) HiNc Packages Version 3.1.172 Replace implicit XFactory registration (private static <ClassName>() constructors + _ = X.XName wake-up touches) with explicit public static void Reg(XFactory factory = null) methods across ~270 classes. XFactory becomes an instance class with a process-wide Default singleton; Generators is renamed from Regs and now an instance property; the delegate type is renamed XGeneratorDelegate from GenByXElementDelegate. Composite types chain X.Reg(factory) on dependents in place of the old wake-up touches; multi-name (legacy alias) registrations keep the current XName first and group aliases under a //legacy aliases comment. Entry points (web service, win-desktop, test fixtures) must call Reg once at startup before any project XML is deserialized — registration no longer happens by accident when the type is first touched. See XML IO. HiNc Packages Version 3.1.171 Rename RuntimeApi → SessionShell (the runtime entry point exposed to scripting); IShellCommand → ISessionCommand and RuntimeController → SessionShellController; the Hi.ShellCommands namespace moves to Hi.SessionCommands, and every command implementer's Run() parameter renames scriptApi → sessionShell Tri-state milling-physics contract: MachiningStep physics getters converge on a tri-state result, non-null MillingPhysicsBrief on no-cut steps under EnablePhysics; silently skip thermal physics on null FluteMaterial / WorkpieceMaterial; lazy first-equip warning; align relief-face null-sentinel across NoCut + producer (in NcOpt and forces) Rename IMachiningStepHost → IMachiningService (drops the ICsScriptApi seam) Fixes: rotary IK round-trip anchored to pre-FK interpolated angle; ForceAccelShot.ReadRows skips blank lines HiNc Packages Version 3.1.167 Introduce SoftNcRunner as a pluggable NC parser/runner replacing the legacy HardNcRunner, opt-in at the time via EnableSoftNcRunner. It became the default pipeline in 3.2 — see NC Parsing Engine Extend coolant model to CoolantMode Flood/Mist/Off and refactor CoolantHeatCondition / MillingTemperatureUtil for multi-mode coolant Bind session events to MachiningSession lifetime: SessionStepBuilt, SessionStepSelected, SessionSyntaxPieceRan, SessionSourcedActEntry (legacy aliases kept as [Obsolete]); add RegisterWriteSyntaxPieces / RegisterWriteSyntaxPiecesWithActs for syntax-piece debug tracing Add ProjectApiVersion carrier through XFactory deserialization for project-XML version negotiation; resolve Workpiece through a lazy Func getter in WorkpieceService HiNc Packages Version 3.1.162 Refactor message management into three independent categories: Diagnostic (IProgress<object>), UI Notification (MessageBoardUtil), App Log (ILogger); remove MessageUtil class entirely and remove ExceptionUtil.ShowException / ExceptionUtil.OnShown (see Message Management) Thread IProgress<object> through XFactory deserialization chain and MachiningProject loading; remove GenMode enum entirely (see XML IO) Add ActionProgress<T>.FromLogger to bridge IProgress<object> APIs to ILogger Rename ShowIfCatched → CatchExceptions with explicit Action<Exception> handler; remove RoutineBlocker0 Extract WorkpieceService from Workpiece for runtime geometry operations Update ISO coordinate rendering for 3+2 axis machines: coordinate position now uses IsoCoordinateEntryDisplayee with full machining chain anchor instead of table-buckle-only anchor Rename SessionMessageHost → SessionProgress on both ShellProgress and ShellProgress (SessionShell.SessionMessageHost is kept as [Obsolete]) Remove obsolete HiLog logging utility and DynamicMachiningProjectDisplayee0 HiNc Packages Version 3.1.160 Fix NC optimization R-format arc interpolation with negative R values (follow-up to v158 R-format arc fix) Fix cubetree construction defect when a triangle edge passes through a wire corner Mech Builder: geometry (STL) file picker for anchored transformation now offers Project directory in addition to Resource directory. Rename XML IO utilities: XmlSourceAndFile<T> → FileRefSource<T>, CombineAsSubDirectory → GetResourceDirectory, MakeXmlSourceWithRebaseFile → MakeXmlSourceToFileRef HiNc Packages Version 3.1.158 Fix G53.1 tool height compensation behavior: replace NcEnv.SetToolHeightCompensationOnFeatureNormal configuration with automatic detection via NC flag state Make EnableIntegerShrinkOnPositionCommand configurable via project settings (previously hard-coded by CNC brand, now defaults to false with XML IO support) Fix NC optimization splitting R-format arcs (G02/G03 with R parameter) by converting to IJK format, since R sign meaning does not apply correctly to individual fragments Fix step.csv reading crash on null or malformed values Fix XML IO sub-base directory not applied in some project file operations Improve CSV actual time parsing to support DateTime format in addition to TimeSpan (see Workflow: Basic Machining Simulation) Fix CSV title parsing to trim surrounding quotes HiNc Packages Version 3.1.156 Fix G68 coordinate rotation transformation for non-origin rotation centers Fix NC optimization arc/circle offset when splitting arc fragments across multiple lines Fix optimization rotation code jumping at ±180° cycle boundary by applying cyclic angle comparison Fix RTCP on unmatched tool offset Fix blocking issue when time-mapping file not found Fix FlagsText always null after NC parser refactoring HiNc Packages Version 3.1.150 Add cubetree geometry defect scanning (ScanRuntimeGeomInfDefect) and clearing (ClearDefectDisplayee) for detecting and visualizing geometry anomalies in workpieces (see Workflow: Geometry Validation) Upgrade internal fraction representation to float128 precision for improved cubetree geometry accuracy and numerical stability Refactor messaging system from IMessageHost to standard IProgress<T> pattern; ShellProgress (formerly SessionMessageHost) now implements IProgress<T>, and all messaging methods renamed from Add* to Report* (e.g., AddProgress → MultiTagMessageUtil.ReportProgress) Fix cubetree initialization crash Improve postprocess precision by applying sin–cos parameterization instead of direct angle-based formulation for rotary axis numerical solving in XyzabcSolver Add asynchronous anchor solid preparation on project load for improved startup performance HiNc Packages Version 3.1.144 Enhance Siemens Sinumerik support: Siemens CYCLE800 coordinate transform and reset Siemens MCALL CYCLE81() drilling cycle parsing Siemens TRAORI/TRAFOOF/SUPA flag parsing Fix Siemens TRAFOOF plain rotation coordinate transform issue Fix Siemens coordinate transform for successive file running Fix relief face collision floating-point precision issue Replace MongoDB with SQLite for local step data storage (significant package size reduction) Add machining and motion resolution dynamic adjustment functions HiNc Packages Version 3.1.106 Rename mapping API for clearer naming: ReadCsvByTimeInterpolation → MapSingleByCsvFile (one-to-one mapping) MapByActualTime → MapSeriesByCsvFile (one-to-many mapping) Rename CSV column prefix Spindle to Holder for sensor data mapping Unify CSV column tags to MappingUtil for consistent data mapping Fix ChartRange manipulation to be time-based instead of step-based for more accurate time chart display Tune thread priority for machining parallel processing to improve UI responsiveness during simulation Various code cleanup and improvements HiNc Packages Version 3.1.102 Separate resource files (Resource, wwwroot, Doc) to HiNc-Resource nuget package for smaller package size Add ScaledFeedPerCycle function for scaled feed-per-cycle machining motion resolution Upgrade target framework to .NET 10.0 Various code cleanup and improvements HiNc Packages Version 3.1.100 Refactor project architecture: split runtime functions from MachiningProject to LocalProjectService for better separation of concerns Improve MillingTraining module with separate lead and result parameter templates for more accurate cutting parameter training Separate C++ library for code protection Add UTF-8 file path support for runtime geometry IO operations Improve CsvRunner0 with enhanced time mapping pattern Various architecture improvements and bug fixes HiNc Packages Version 3.1.91 Add NcOptimizationEmbeddedLogMode to control embedded log detail level (None/SimpleLog/FullLog) (see Embedded Log Comments). Fix bug of NcOptProc duplicated feedrate assignment HiNc Packages Version 3.1.90 Rename optimization log API EnableIndividualStepAdjustmentLog Fix crash from workpiece displaying with specific mechanical topology setting Improve .flatproc.log output to maintain step order during parallel computation Various stability improvements and bug fixes HiNc Packages Version 3.1.86 Re-build NcOptProc with stricter optimization logics Add optimization logging features (see Optimization Logs): .flatproc.log file output for optimization process analysis Embedded log comments in optimized NC file marking source lines with (src) suffix Fix cutting depth and width accuracy by bounding-box method with workpiece surface Fix collision check error during concurrent changing collidable object Various stability improvements and bug fixes HiNc Packages Version 3.1.84 Optimize memory usage by shrinking map-size of clStripPos Fix design pattern of cutting parameter training module (MillingTraining) Add LoadCuttingParaByFile function to load cutting parameters from file Improve CsvRunner0 actual time parsing: automatically calculate step duration from actual time when duration is not provided Enhance message handling in SessionShell by unifying ShellProgress usage Improve optimization performance with better task scheduling Various performance improvements and bug fixes HiNc Packages Version 3.1.75 Add actual time tracking functionality (ActualTimecode) Various stability improvements and bug fixes HiNc Packages Version 3.1.74 Rename class MillingCutterOptLimit to MillingCutterOptOption Add physics simulation function for relief face collision detection (ReliefFaceCollidingSpeed_mmds, IsReliefFaceCollided) and optimization (EnableLimitByReliefAngle) Add UpdateNcOptOption function to step processing Fix step ordering bug from concurrent processing Fix ClStrip shrinking to zero issue"
  },
  "release-note/upgrading-to-3.2/brand-nc-language-coverage.html": {
    "href": "release-note/upgrading-to-3.2/brand-nc-language-coverage.html",
    "title": "Brand NC language coverage | HiAPI-C# 2025",
    "summary": "Brand NC language coverage The SoftNc pipeline is the default NC engine, and this is where most of the release went. Siemens SINUMERIK Real .mpf / .spf programs replay end to end, not an ISO subset. At 3.1.175 a program that declared its tool as T=\"NAME\", shifted with SUPA, computed with R-parameters, called L-subprograms or looped with WHILE was not interpreted past that point. Modal vocabulary — SUPA / G153 suppress all frames for one block; T=\"NAME\" string tool calls with D cutting-edge offsets resolved through SiemensToolOffsetTable ($TC_DP lengths and radius plus additive wear); G70 / G71 units; path smoothing (G60x / G64x, FNORM / SOFT / FFWON / COMP* / UPATH, CYCLE832); MSG() and STOPRE; CR= and TURN= arcs. Tail comments became quote-aware, so a ; inside MSG(\"A;B\") no longer truncates the block, and the preset stops misreading L and G74 as Fanuc-family codes. Evaluation — SiemensExpressionParser feeds the shared expression engine, so Z=R63+150 and X=SIN(R10)*20 drive motion. SiemensRParameterTable holds R0–R999 as per-case project data, DEF REAL/INT declarations lower into assignments, and $P_UIFR[n,axis,TR] binds both ways to SiemensFrameTable. Any other $-variable is recorded with an unsupported note rather than dropped. Five axis — SiemensProgrammableFrameSyntax simulates TRANS / ATRANS / ROT / AROT (with RPL=) into the tilt-transform chain in Sinumerik RPY order; SiemensTraoriSyntax makes TRAORI a real RTCP mode, the sibling of ISO G43.4, with TRAFOOF handing the offset back; SiemensCycle800TiltSyntax decodes CYCLE800's MODE bits for all four swivel modes. ROTS / SCALE / MIRROR are recognized and reported, not simulated. Calls — L-prefixed and named subprogram calls resolve against SubProgramFolderConfig ({name}.SPF, then .MPF, then the bare name) and inline with their P repetition count; M17 / RET pop a frame; REPEAT re-runs a labelled slice; MCALL CYCLE81/82/83/85 maps onto the shared canned-cycle machinery; PROC headers and labels are claimed whole. Control flow — GOTOF / GOTOB, IF / ELSE / ENDIF, and WHILE / FOR / REPEAT-UNTIL / LOOP. Runaway programs are bounded rather than hanging the session: SiemensGotoIterationDependency caps jumps per (file, label) and SiemensLoopIterationDependency caps iterations per (file, loop-entry line); over the cap the construct warns and falls through. Per-word coordinate functions — AC() / IC() / DC() / ACP() / ACN(), including on I / J / K circle centres. G90 C=IC(360/17) is one incremental index inside an absolute program. Direction resolution lives in McAbcCyclicPathSyntax: ACP() takes the [anchor, anchor+360) window, ACN() the (anchor-360, anchor] window, DC() the shortest swing, with the exact 180° tie going negative. Coded positions — CAC / CIC / CDC / CACP / CACN take a 1-based indexing position number rather than a coordinate, resolved against IIndexingPositionConfig, implemented by SiemensMachineDataTable from the real machine data (the MD30500 axis assignment, the MD10910 / MD10930 position tables, the equidistant MD30501–30503 definition). G74 / G75 fixed-point return is claimed as a whole block, so its dummy axis values no longer mint a rapid to the coordinates written in the block and its F never reaches the modal feedrate. OEM auxiliary M-codes — the preset declares M12 / M13 / M22 / M23 and M330 / M331 note-only, so each occurrence voices DeclaredMCode--UnmodeledEffects instead of an unknown-code warning, without inventing simulated effects. A machine's own table overrides a declaration when the real effects are known. Heidenhain Both dialects play on one preset, HeidenhainNcRunner. Klartext motion and setup — the L statement and its axis words, FMAX, M91 as a one-shot machine-coordinate move, TOOL CALL wired to tool change and spindle speed with the table height and DL. Datum handling follows TNC semantics: CYCL DEF 247 sets the preset and CYCL DEF 7 is an additive shift on top of it, composing as separate transform-chain entries instead of replacing each other, resolved against HeidenhainDatumTable. Arcs (CC pole plus C statement, DR- = CW, closed arc = full circle), RL / RR / R0 radius compensation, the M126 / M127 rotary-wrap state, M140 MB retract, and CYCL DEF 32 TOLERANCE. A C block never states its own centre: each in-plane component comes from the CC block's own axis word, else from the previous CC section's same axis, else from the arc's own start point. A bare CC is the one spelling that states all of them at once — it takes the last programmed position, read at the CC block, and replaces the modal centre rather than inheriting it. A centre that lands on the arc's own start point leaves the block with no radius, so it warns Arc-CircleCenter--OnStartPoint and is degraded to a linear move to the endpoint. Q-parameters — HeidenhainExpressionParser lexes Q / QR / QL / QS, the DIV keyword of FN 4 and the prefix SQRT of FN 5, so FQ1 reaches the feedrate, L X+Q2 reaches the program XYZ and TOOL CALL SQ3 reaches the spindle speed. HeidenhainQParameterTable holds Q0–Q99 free and QR0–QR499 permanent parameters as per-case project data. Unimplemented opcodes (FN 14 / 16 / 18…) are claimed and reported rather than half-read, so an FN 18 SYSREAD target stays vacant instead of taking a fabricated value. FN 9–12 conditional jumps execute, with a (file, label)-keyed iteration cap. Tilt and RTCP — PLANE (SPATIAL fully composed with SEQ / COORD ROT / TABLE ROT and STAY / MOVE / TURN positioning; VECTOR structurally captured; EULER / POINTS / RELATIV / AXIAL / PROJECTED consumed and warned with the previous tilt retained, so a PLANE AXIAL B+45 B word can never be mistaken for a rotary axis command), FUNCTION TCPM, and real M128 / M129 tool-centre-point control. Cycles and calls — CYCL DEF 2xx bodies with their Q parameters mirrored into the block assignments, cycles 200 / 232 / 251 / 252 / 253 mapped onto the shared G81 / G82 / G83 slots, CYCL CALL / CYCL CALL POS / M99 / M89 splitting call-once from modal firing, CALL LBL inlining up to LBL 0, CALL LBL n REP m as a section repeat, and CALL PGM resolved by file name. The multi-line tilde continuation form is joined at segmentation (JoinTildeContinuations, on by default). Post-processed spellings — some post-processors write a whole klartext body with no separators at all, which used to yield zero motion. Glued line shapes (LX-26.3Y+43.1, FMAXM03M08, …R0FMAX) and the detached feed spelling (F 20000) now parse, with M140, M128 and PLANE MOVE widening their own F capture so a retract or feed-limit value cannot leak into the modal feedrate. BLK FORM is recorded as a brand-neutral stock declaration without replacing the project workpiece setup, and the klartext STOP word joins M00 / M01. DIN/ISO dialect — % tape header, N block numbers, T + M06, absolute I / J / K arc centres with the modal pole carried forward, the ISO label family (G98 L<n> definitions and the head-anchored L<n>,<m> call mapping the comma count onto REP), G247 Q339 stamping the same datum preset as CYCL DEF 247, G54 with axis words read as a datum-shift declaration, and G70 / G71. Fanuc and ISO common Polar coordinate interpolation — G12.1 / G13.1 on the SoftNc pipeline. Before this a polar section parsed silently wrong: the X word (a diameter) and the C word (a hypothetical Cartesian axis in mm) were consumed as ordinary XYZ and rotary degrees. ProgramRxczSyntax halves X from diameter, resolves G90/G91, writes the polar and derived Cartesian positions and the machine C angle, and classifies motion into polar linear and polar arc — the latter emitting ActMcPolarSpiralContour, which keeps spiral geometry in central polar coordinates and stays continuous across ±180°. G41 / G42 compensation is resolved on the hypothetical plane, a C-axis speed clamp applies, and YA / ZB axis pairs are supported. PolarGCodeCheckSyntax scans for incompatible G codes before the mode syntaxes consume them. Custom Macro B — #var assignment with range-routed stores (#1–#33 local per macro frame, #100–#499 volatile cleared on M02/M30, #500–#999 retained and persisted in the project, #3000–#3999 system-control), boolean and logical operators, IF[..]GOTO n, IF[..]THEN <stmt>, WHILE[..]DO m / END m with a bounded-loop watchdog, and position and tool-offset system variables. M98 P_ L_, M198 external call, M99 return and M99 P{seq} early return; G65 one-shot macro call with A–Z → #1–#26 argument binding, and G66 / G67 modal macro. Cross-brand A shared DwellSyntax consumes G4 and G04 with the dialect held on the instance: Fanuc-family X / U seconds, P milliseconds, S spindle revolutions; the Siemens instance reads F seconds and S revolutions. Capturing the G04 spelling fixes a real defect — the un-captured spelling fell through to the flag and axis syntaxes, where a Fanuc G04 X0.5 dwell time became a ghost X motion word. Machine-declared M-codes — IMCodeDeclarationConfig and MCodeEffects let a machine state what its own OEM codes do (composite spindle+coolant codes, a tool-change trigger, turret T-word semantics), and MCodeExpansionSyntax expands a declared code into the canonical ISO flags the shared consumers already understand. Custom spindle M-codes drive the spindle direction through a machine-level ISpindleControlConfig; ISO M03 / M04 / M05 remain the built-in fallback. An S greater than zero with no direction ever issued assumes clockwise and emits SpindleDirection--AssumedCw, so the physics gate no longer silently produces zero mechanics for a whole file. Tool changes synthesize their axis travel. ToolChangeMotionSyntax overlays the per-axis tooling position from IToolingMcConfig onto the current pose (a NaN or missing axis stays put) and stamps a one-item rapid compound motion, and ToolChangeSemantic moves behind CompoundMotionSemantic so the tooling step lands at the tooling point. Programs that retract on their own overlay to a zero-length move and emit nothing extra. Per-brand pivot gates. PivotTransformationSyntax reverts to the ISO/Fanuc vocabulary (G43.4 plus the G68.x family), SiemensPivotTransformationSyntax gates TRAORI / CYCLE800, and HeidenhainPivotTransformationSyntax gates the M128 / PLANE vocabulary. All three compose the identical entry through the shared PivotTransformUtil. Exactly one brand gate belongs in a pipeline list — never register two. Controller presets are writable and shipped. A controller resource file is one serialized SoftNcRunner — the whole pipeline that decides how a brand's NC code is interpreted. ControllerPresetWriter serializes the built-in brand presets (CreateBrandPreset, WriteBrandPresetFile, WriteAllBrandPresetFiles) under Resource/Controller/ with the .Controller extension, and HiNc-Resource ships all five so the load browser starts populated. The static brand properties remain the source of truth; the files are regenerable snapshots. Writing needs no XFactory registration — reading one back does, because the loader drops unregistered pipeline entries silently rather than failing the load. Saved pipelines back-fill their system-wired dependencies on load. A project saved before a system-wired dependency existed never self-healed by round-tripping, because re-saving stamped a fresh API version on the same incomplete list. The SoftNcRunner XML constructor now appends the missing ones after the legacy version patches. A runner rehydrated from an older file still keeps the syntax list it was saved with, though — take the regenerated preset, or a fresh NcRunnerSuit built from it, rather than expecting an old file to grow new syntaxes. Machine-coordinate and tilted-plane failures report. G53 and G53.1 record their source G-code on the parsed block and emit Coord-MachCoord--005 / --006 / --007 on paths that used to fail silently. A G68.2 tilted plane the machine cannot reach emits Coord-Tilt--001 / --002, with a tool-axis-only IK retry that avoids a spurious warning on a machine with fewer than three rotary axes. Session-global sentence indexing. SyntaxPiece.SentenceIndex used to be assigned by two independent sequences, so indices collided as soon as a call was inlined mid-stream. The new SentenceIndexCounterDependency supplies every index at one chokepoint, so values are session-globally unique and strictly increasing in execution order, including nested and repeated calls. Inline plays can loop and jump, and playing a file no longer holds it open. Inline NC-code plays stamp their pieces with the command title as a pseudo-path, and every control-flow re-segmentation re-read the host file by that path — the existence check always failed, so loops fell through without looping. RunNc now registers the raw lines on NcLineSourceDependency and LabelScanUtil reads memory first, disk second."
  },
  "release-note/upgrading-to-3.2/breaking-changes.html": {
    "href": "release-note/upgrading-to-3.2/breaking-changes.html",
    "title": "Breaking changes | HiAPI-C# 2025",
    "summary": "Breaking changes In the order they will bite an upgrading host. 1. Registration, before anything else XFactory.Generators changes from a plain Dictionary to a ConcurrentDictionary, so parallel Reg() calls no longer corrupt the registration map. The property is public, so a caller that declares its type explicitly stops compiling. Carried over from 3.1.172 and still the first thing an upgrading host hits: Reg must be called once at startup, before any project XML is deserialized. Registration no longer happens by accident when a type is first touched. See XML IO. 2. The message channel Message reporting is rebuilt on a unified model. Every notification carries a Severity, a Category and a filterable id (SimpleMessage), and arrives on one of three typed sinks: ShellProgress for session-lifecycle messages, StepDiagnosticProgress for step-anchored diagnostics, and NcDiagnosticProgress for NC-parsing diagnostics. MixedProgress0, MultiTagMessage and MultiTagMessageUtil are removed. Every message parameter across the API — the XFactory deserialization chain included — is retyped from IProgress<object> to IProgress<IMessage>. Category.General is deleted, MessageUtil becomes id-first {Category}{Severity}, and NcDiagnostic.Text renames to Notification. See Message Management. 3. The session surface LocalProjectService.SessionShell is created by BeginSession() and nulled at EndSession() — it is null outside a session and no longer lazily created. ShellProgress is recreated per session, so hold no long-lived reference to either: subscribe once through OnShellMessageAdded / OnShellMessageCleared, or buffer one call's messages with MessageCollector. MachiningSession takes an injected IMachiningService host in its constructor, and IMachiningService replaces PlayerCancellationToken / PausePlayer with a single PacePlayer property. 4. The play verbs Nc becomes the umbrella term for any playable control program, and BrandNc names the famous-brand controller-code group as a sibling of Cl and Csv. Was Is now PlayNcFile(file) — brand G-code only PlayNcFile(file, NcKind kind = NcKind.Auto) RunNcFile(file) RunNcFile(file, NcKind kind = NcKind.Auto) the narrow brand-only file verbs PlayBrandNcFile / RunBrandNcFile IControlRunner Hi.Numerical.INcRunner RunControlLines RunNcLines ControlKind NcKind IsRunningControlLines / BeginControlRunner IsRunningNcLines / BeginNcRunner the interim PlayControlFile / RunControlFile mirrors removed The same rename applies on LocalProjectService, SessionShellController and MachiningSession. Only .cl / .cls / .clsf / .csv arguments change meaning — DetectByPath treats those as closed extension sets and everything else falls back to brand G-code, so an exotic brand extension can never be misrouted. 5. Renames with no shim Was Is now WorkpieceService.GetRuntimeGeom / ReadRuntimeGeom / WriteRuntimeGeom / SetRuntimeGeom / ResetRuntimeGeom / IsRuntimeGeomInit / ScanRuntimeGeomInfDefect GetOrBuildMeshedGeom / ReadMeshedGeom / WriteMeshedGeom / SetMeshedGeom / ResetMeshedGeom / IsMeshedGeomInit / ScanMeshedGeomInfDefect MachiningEquipmentCollisionIndex.WorkpieceRuntimeGeomGetter WorkpieceMeshedGeomGetter IContourTray / UniformContourTray / FreeContourTray IFluting / UniformFluting / FreeFluting MillingCutter.FluteContourTray Fluting Hi.Common.ResourceUtil (the HiNc one) ResourceLayout NativeTopoStld / NativeTopoStlfr / NativeCarveTopoStl3wfr NativeTopoStl3d / NativeTopoStl3wfr / CarveStl Solid.NativeSmoothTopoStl / Sweptable.NativeTopoStl SmoothTopoStl3d / NativeTopoStl3d ITimeGetter and its Time member Hi.Physics.ITimecoded and Timecode ClStrip.DrawingRefreshing ClStrip.DrawingRefreshed CbtrPickable.CleanLinked* CbtrPickable.CleanAttached* SoftNcRunner.NcDependencyList PipelineNcDependencyList StateActRunner.Feedrate_mmds / Feedrate_mmdmin, ActFeedrate.Feedrate_mmds / Feedrate_mmdmin (and ActRapid), MachineMotionStep.Feedrate_mmds, the MachineMotionStep constructor's feedrate_mmds parameter CommandedClFeedrate_mmds / CommandedClFeedrate_mmdmin, CommandedClFeedrate_mmds / CommandedClFeedrate_mmdmin, CommandedClFeedrate_mmds, commandedClFeedrate_mmds Four notes on that table. The SessionShell script names for meshed geometry keep hidden [Obsolete] aliases so existing player scripts still run; the service-level members do not. WorkpieceService.ResetRuntimeGeom also drops its ClStrip parameter. ClStrip.DrawingRefreshed was renamed because both invocations always fired after the work — the -ing name told subscribers the opposite of when they are called. A subscriber that misses the rename silently detaches. Project and cutter files written before the fluting rename keep loading: each Reg() registers the ContourTray-era XName beside the older aliases, and the cutter element reader tries Fluting, then FluteContourTray, then FluteContourTrackTray. A cutter that nevertheless fails to resolve its fluting machines as a plain bounding shape rather than failing loudly, so verify the load rather than assuming it. The feedrate members were renamed because the value is the controller's commanded feedrate of the CL point – the F word after G94/G95/G93 conversion, or for a rapid the CL path over the act duration – and not the equipped tool's tip feedrate; under RTCP with a tool-length offset that does not describe the equipped tool the two differ. The step now also carries ActualTipFeedrate_mmds (client key ActualTipFeedrate_mmdmin), which the physics reads. The client key Feedrate_mmdmin keeps its historical name. SoftNcRunner.PipelineNcDependencyList is the raw list; machine-config consumers read the resolved view through GetEffectiveNcDependencyList. Legacy <NcDependencyList> XML still loads and migrates. 6. Removals CSV — CsvRunner0, LocalProjectService.EnableSoftCsvRunner, and the earlier RawCsvRunner and CsvRowSemantic. CSV playback has one path, GeneralCsvRunner, and CsvRunner returns the CSV suit's SoftNcRunner directly. Carriers — IndexedSentence (wrap a bare Sentence in your own ISentenceCarrier if you passed one as a sourceCommand), SimpleSessionCommand, HiCbtr's [Obsolete] LsStl. The packed MixedIndex file-line key is replaced by typed FileLineIndex comparison, so file and line positions compare by type rather than through a packed integer. GUI-layer composition — MachiningProjectDisplayee, IsoCoordinateEntryDisplayee, HeidenhainCoordinateEntryDisplayee, UserConfig, UserService, PlayerDivConfig. Construct LocalProjectService with the ILogger-only constructor and copy the displayees from any app project — Hi.Sample.Wpf/Disp/ ships them. They compose only public API (IDisplayee over LocalProjectService), so tailoring them is the point. Managed physics kernel types — the class FluteZData, MillingForceUtil.RuntimePack / LayerPack / AnglePack, the LayerMillingEngagement constructor that built an engagement from a z-to-dz list (the default and BinaryReader constructors stay), and MillingPhysicsBrief.YieldStressMinHeight_mm. Culture declaration — CultureUtil.SupportedCultureNames and CultureUtil.SetCurrentCulture(string), deleted outright with no [Obsolete] shim. What remains is English and SetCurrentCultureEn. A host that enumerated supported cultures must enumerate its own manual or resource folders instead. Dead P/Invoke declarations — eight gl* methods on HiDisp's public GL class (glFenceSync, glGetDoublev, glGetDoublei_v, glGetDoubleIndexedvEXT, glIglooInterfaceSGIX, glPNTrianglesfATI, glPNTrianglesiATI, and the already-commented glDebugMessageCallbackAMD). They had no backing export and threw EntryPointNotFoundException when called. NcFileListCommand — a list of NC files is just a List of Program File commands, so the dedicated type is gone. Loading a project that contains one converts it in place: each <File> entry becomes a single-file NcFileCommand (kind Auto, the same per-file extension dispatch) inside a ListCommand, and re-saving persists the converted form. Post-Execution meshed-geometry output — PostExecutionCommand loses EnableWriteMeshedGeom and MeshedGeomFileTemplate (and their pre-rename …RuntimeGeom… spellings) together with the enable-write-meshed-geom and meshed-geom-file-path routes. A geometry snapshot can be taken at any time-spot, unlike the run-derived outputs that command manages, so the carriers are now the placeable RecordMeshedGeomCommand and ExportMeshedGeomToStlCommand. Loading an old project with the pair enabled emits PostExecution--MeshedGeomOutputRetired, and re-saving drops the elements. Cutter tessellation resolution — mesh resolution is runtime data, not authored cutter data, so the seam that let a live object be “the resolution” is gone: MillingCutter no longer implements IPolarResolution2d and loses LinearResolution_mm / AngleResolution_rad / AngleResolution_deg and UpperBeamPolarResolution2dSource; the Func-based IPolarResolution2dSourceProperty interface is deleted together with the PolarResolution2dSource properties on Solid, AptProfile and CustomSpinningProfile. A Solid now holds the immutable resolution it was built with — pass it to the Solid(IGetStl, PolarResolution2d) constructor — and changing resolution means building a new solid: play paths go through SetShaperStlResolution and SetStrutStlResolution (the runner calls both for you, so the strut/upper-beam mesh follows the runtime value during a play too), holders re-mesh when you assign their PolarResolution2d property, and a fresh cutter's shaper solid is born with DefaultShaperStlResolution while the strut solid is born on the geometry's own default. Cutter files keep loading whether or not they carry the old <LinearResolution_mm> / <AngleResolution_deg> elements; the values in them were only ever the residue of the last play and are ignored, and 3.2 no longer writes them — a 3.1 install needs a support-line build carrying the guarded cutter reader (HiMech 3.1.157.2 / HiNc 3.1.175.5, shipped 2026-08-29) to open a 3.2-saved cutter file. Parameterless profile meshing — IShaperProfile no longer extends IGetStl, and the GetStl() convenience methods on AptProfile, ConstRatioProfile, FluteDependentRatioProfile and CustomSpinningProfile are gone. Profile mesh access is resolution-explicit: pass your value through GenStl(resolution), or state the profile's own default with GenStl(null). Geometry types that serialize as an STL source (Cylindroid, GeomCombination, TransformationGeom, ExtendedCylinder) keep GetStl() as their IGetStl contract; it is documented as, and equivalent to, GenStl(null). Bounds queries never mesh — expanding a bounding box is a rough, quick operation (view fitting), so it no longer triggers STL generation anywhere. TransformationGeom.ExpandToBox3d transforms the geometry's own box corner-wise — a conservative superset of the transformed geometry's true bounds — instead of meshing, and GeomCombination now implements IExpandToBox3d by folding its sources' boxes. A geometry without IExpandToBox3d support contributes nothing to a bounds query; generate the mesh yourself if you need its true extent. MillingCutter's cutter-height bookkeeping likewise reads the profile's ZR contour and the upper beam's box instead of meshing both on every cache clear. 7. Signature and shape changes MachiningToolHouse derives from Dictionary<int, IMachiningTool>: SetToolId takes an int and CreateStickMillingTool returns KeyValuePair<int, MillingTool>. Any (int)entry.Key cast stops compiling. Siemens T=\"name\" string tool calls are unaffected — they still resolve to an int at the semantic layer. ActualTimecode and ActualDateTime become get-only views onto the new optional ActualTime (StepActualTime) — their setters are gone. AccumulatedTime is superseded by EndTimecode, kept as an [Obsolete] alias; step CSVs write the new header and still read the old. PreSettingCommand becomes a legacy bundle. A saved bundle expands on load into MachiningResolutionCommand, MachiningMotionResolutionCommand, CollisionDetectionCommand, PauseOnFailureCommand and PhysicsCommand (plus a Read-mode RecordMeshedGeomCommand), and is never written back. Anything that located the bundle element in a saved .hincproj must look for the split commands. ToPresentDto wire keys change with the obfuscation fix: geometry DTOs use Type / Min / Max / PairZrs / Z / R / SourceFile / FileIndex / LineIndex (Vec3d keeps lowercase x / y / z), transformer DTOs use Trans, Angle_deg, CosTheta / SinTheta, Axis, Pivot, Scale, Rotation, Translation, Step, Stack, Matrix. A front-end reading those payloads must be updated in lockstep. defaultFontFile changes value from \"Font/WCL06.ttf\" to \"(embedded)\". It is a public const, so an assembly compiled against 3.1.175 already carries the old literal and keeps passing it — Init still accepts it — but a rebuild changes what it passes, and no font file is extracted to the working directory any more. 8. Defaults and gates that changed EnableSoftNcRunner defaults to true. The SoftNc pipeline is the NC engine; HardNcRunner is the opt-out fallback for the shrinking set of features still bound to it. EnableNativeMillingPhysics defaults to true, and in a shipping build setting it to false throws InvalidOperationException at the setter — the managed reference implementation lives only in a non-shipping assembly. Code that flipped it off for an A/B comparison now fails at configuration time. YieldingStressRatio and YieldingStressRatio report NaN instead of 0 when no beam section qualifies. A caller treating 0 as “no yielding constraint” — as both feed solvers did — must add a NaN branch or it will pass NaN into downstream queries. New licence feature NcComposition (id 22). Registering any non-built-in processing unit into a SoftNcRunner pipeline, or executing an NC-embedded C# script, requires it. Degradation is silent and functional: external units are skipped for the session with one Composition--NotLicensed naming them, an external segmenter falls back to SingleLineSegmenter, and scripts are skipped with Script--NotLicensed. An unlicensed installation therefore produces a different simulation, not an error. Calling the public API from your own application or session script needs no extra licence; composing the interpretation pipeline does. See NC Parsing Engine. The four SnapshotSyntax entries in the Fanuc preset default to IsEnabled = false, so projects stop serializing enabled debug snapshots. A project saved by an earlier build keeps what it serialized until its pipeline list is refreshed from the current preset. Server side: HiNcServer pins request localization to English, so an Accept-Language: zh-Hant request falls back to en. HiNcRcl removes the HiNC:DisplayEngine:FontFile configuration key, which never had any effect — delete it from appsettings. FontFile remains for a custom font. Localization: HiMech's MachiningStep.zh-Hant / .zh-Hans resx are deleted. Step presentation strings now come from the HiNc-Resource present catalog (catalog.en.json, catalog.zh-Hant.json, catalog.zh-Hans.json) that a host overlays; a host that ships neither loses the localized step labels it used to get for free. Packaging is x64-only: HiDisp drops the win-x86 runtime identifier and its Sentinel payload, HiNc-Resource drops the x86 platform. The shipped machine-tool packages are renamed. They now carry the .default marker and neutral names: MachineTool/Table-B1.default and MachineTool/CT-350.default. The table-type package was renamed outright — its .mt, its .general-mech and its STL headers travel with it — and the duplicated nested STL set inside the CT-350 package is deleted. A project, script or .mt that refers to a shipped machine-tool package by its earlier path must be repointed at the name above."
  },
  "release-note/upgrading-to-3.2/cl-playback.html": {
    "href": "release-note/upgrading-to-3.2/cl-playback.html",
    "title": "Cutter-location (CL) playback and CL-to-NC | HiAPI-C# 2025",
    "summary": "Cutter-location (CL) playback and CL-to-NC Replay an NX CLSF / APT-source toolpath directly. PlayClFile reads MSYS / FROM / GOTO / CIRCLE / RAPID / FEDRAT / SPINDL / COOLNT / TLDATA / LOAD. The parser is the NxClRunner preset — a SoftNcRunner composition — and the project holds a third runner suit ClsfRunnerSuit beside the NC and CSV suits. A TLDATA record creates the tool geometry when the tool house has no matching id. Run-ops are first class: ClRunner, MachiningSession.PlayClFile / RunClFile. See Cutter-Location (CL) Playback. A CL file can now drive a machine-tool chain, not only a ClMillingDevice. When the pipeline's kinematics dependency resolves to a live solver, ClToMcTransformSyntax inverse-solves every CLSF motion endpoint at parse time and expresses the result in the same ProgramToMcTransform vocabulary the NC pipeline uses — a tool-height entry from the active tool, a pivot entry anchored to the workpiece frame, and the solved rotary axes in raw degrees for the cyclic wrap tail-pass — so McLinear and the wrap are reused unchanged. Played onto a ClMillingDevice the same file is still pure cutter-location motion, which is what you want for verifying a CAM toolpath before any post-processor is involved. CL moves resample along the true path. GetClSteps walks IClPath.At for each intermediate step rather than linearly interpolating between the path's begin and end, so a CL arc actually curves and the tool axis rotates along the path instead of through it. ClLinear gained two guards on the same path: the near-parallel begin/end normal case short-circuits instead of falling into a degenerate cross product that yielded a NaN rotation axis, and the interpolation reads its rotation delta through the lazily-built property rather than a still-null backing field. CL tool changes teleport instead of stepping. A stepping change stamps collision detection and volume removal at the chain's current pose, and at CL session start that pose is identity — the tool sitting at program zero inside the workpiece. The CSV pipeline's teleporting semantic is promoted to the shared ToolingTeleportSemantic (the old CsvToolingTeleportSemantic element name is kept as a load-only alias), and the first GOTO after a LOAD / TOOL is forced into a reposition so a new tool never sweeps a cut from the previous operation's endpoint. Convert a played CL program into Fanuc NC files. ConvertClToNcFiles, its HTTP action, and the LocalProjectService / MachiningSession entry points walk the session's final syntax-piece layer, group pieces per source file and write one NC file per source, template-substituting [NcName] (default Output/[NcName].nc). It requires a prior play on a machine chain — a pure-CL device leaves no machine-solved sections to serialize — and reports ConvertClToNc--NoPlay otherwise. Stage-one results are retained in NcConversions as the hook for source↔output cross-navigation. A mission can declare the writeback through EnableConvertClToNcFiles and ClToNcFileTemplate. CL→MC hardening. Tool-offset resolution walked back to the distant LOAD block for every motion (O(N²) on production-scale files) and is now O(1) through a modal active-tool section; the documentary program-to-Pn stamp is stamped once per run rather than walked per motion; the program-zero query no longer deep-clones the whole equipment assembly per motion block; the warned-tool-id set is run-scoped, so the ClToMc--NoToolOffset warning is no longer suppressed on every run after the first; and MachineAxisConfig gains a public Clear() so a machine switch rebuilds the axis table instead of accumulating stale rotary axes."
  },
  "release-note/upgrading-to-3.2/geometry-rendering-and-stability.html": {
    "href": "release-note/upgrading-to-3.2/geometry-rendering-and-stability.html",
    "title": "Geometry, rendering and native stability | HiAPI-C# 2025",
    "summary": "Geometry, rendering and native stability Disposing a display or geometry object still in use no longer crashes the process. A client disconnect, a meshed-geometry reset or an app shutdown could take the process down with an access violation. DispEngine and CubeTree native calls are now gated against a concurrent dispose, and disposals run serialized on a single background chain — IsDisposed reports the state and DisposeBackground enqueues a tree, or a collection of its attachments, onto that chain. Large geometry no longer freezes the UI. Solid builds its display topology off-thread and draws a wire bounding box with a “Loading” mark until it is ready. ClStrip raises a Cleared event after Clear, pairing with the existing PosAdded. A P/Invoke correctness sweep reconciled the managed declarations against the real export table. It fixed a non-existent export (substraction_ExpandToBox3d), two void natives declared as struct returns (a garbage register read), two ToString marshals that made the CLR free foreign memory, and a log-callback delegate nothing rooted against GC — native could call a dead thunk long after the P/Invoke returned. These are the crashes a user reports as “it crashes randomly”. Milled step colours no longer go stale at random. Step colours are baked into the native cube-tree attachment, but the refresh only flagged the strip while the display cache was freed immediately, so a frame landing in that window rebuilt the cache from stale colours and nothing cleaned it again. The service now cleans the cache once more after the re-stamp. A paired fix stops an empty strip display window swallowing a pending recolor indefinitely. The dimension bar reads on any background. It was a single hard-coded near-black stroke left over from the light-host era, invisible once the front end went dark. It is now drawn as a wider dark halo under a white main stroke, with the halo pushed back whole depth steps rather than the white pass nudged forward by half a depth LSB — which intermittently lost the depth test. New geometry API. CarveStl is the managed face of the native exact triangle-CSG container. Add is the boolean-union counterpart of Substract, returning UnmanagedAddition, and AddBySweepingVolume mirrors RemoveBySweepingVolume — the geometry-layer symmetric point for additive processes. There is no deposition step in the machining runner yet, so this is a geometry-level API only. FreeformBottomContour is the user-editable point-list bottom contour, mirroring the side contour with the key axis switched to radius."
  },
  "release-note/upgrading-to-3.2/index.html": {
    "href": "release-note/upgrading-to-3.2/index.html",
    "title": "Upgrading from 3.1.175 to 3.2 | HiAPI-C# 2025",
    "summary": "Upgrading from 3.1.175 to 3.2 These pages are the long form of the 3.2 release-note entry. They exist because 3.2 is not an increment on the last release most callers hold — it is the accumulation of everything that landed after the 3.1.175 package set, delivered in one step. Read them in order the first time. The two sections that decide whether an upgrade is a recompile or an afternoon are Breaking changes and Results that change on upgrade; everything after them is new capability you can adopt when you need it. Important Read the Adoption status note on the release-note page before planning around this. The short version: 3.2 is published for review, verification is still in progress across most areas, and NC optimization is not finished on this line — work that depends on it should stay on 3.1, serviced as 3.1.175.<patch>. Pages Ordered the way to read them: what the package numbers mean, then the two sections that decide whether the upgrade is a recompile or an afternoon, then the new capability, adopted when needed. The package line — Why a 3.2 build number starts low, which ten packages moved together, and what that means for a mixed reference set Breaking changes — The eight groups that stop a build, in the order they bite — registration, messages, the session surface, the play verbs, renames with no shim, removals, signature changes, changed defaults Results that change on upgrade — What a simulation produces differently afterwards — usually because 3.1.175 was wrong — and why a byte-for-byte comparison will differ Brand NC language coverage — Where most of the release went: Siemens, Heidenhain, Fanuc and ISO common, and the cross-brand work behind them NC optimization and writeback — The optimization leg as it stands on this line — published for review, not for production Milling physics, training and measured data — Physics in the native kernel, and what changed in training and in the handling of measured signals Cutter-location (CL) playback and CL-to-NC — Replaying an NX CLSF / APT-source toolpath directly, and writing one out as NC Session, project and command model — Runner suits, the three the project holds, and the command model a script and the app share Geometry, rendering and native stability — Disposal crashes that no longer take the process down, and the geometry and rendering changes behind them Performance and footprint — Every figure with its conditions stated, including the places the release spent time on purpose to buy correctness Packaging, resources and hosting — The .default ownership marker, resource seeding, and what a host has to change New diagnostics you may now see — The searchable ids for failure modes that used to be silent"
  },
  "release-note/upgrading-to-3.2/milling-physics-and-training.html": {
    "href": "release-note/upgrading-to-3.2/milling-physics-and-training.html",
    "title": "Milling physics, training and measured data | HiAPI-C# 2025",
    "summary": "Milling physics, training and measured data Physics runs in the native kernel. The per-step milling physics migrated into core.dll in stages: the engagement is scan-converted natively at the substraction completion point, the force kernel is reached through the same handle with no managed marshal, and the sequential cutting-temperature and wear chain runs from a native thermal session held per (tool, cutting parameter) pack. The switch is EnableNativeMillingPhysics, surfaced runtime-only (not persisted to project XML) as EnableNativeMillingPhysics and EnableNativeMillingPhysics, and it now defaults to true. Public entry points that used to reach the managed kernel still work: without a session pack they build an ad-hoc physics pack per live (cutting parameter, tool) pair and run natively. MillingToolPhysicsPack is an immutable record holding one tool's scalar derivations for one cutting-parameter set — spindle-buckle-to-tip length, observation height, effective cutting diameter, the bending/Z-deflection pair, the simplified rake angle, the minimum uncut chip thickness. MachiningSession owns the packs keyed by tool id (GetToolPhysicsPack) and invalidation is explicit at the points that know the state changed: every run-op start and the tool-change act, plus InvalidateToolPhysicsPacks. The corresponding MillingTool / MillingCutter members are now deliberately uncached pure computations. Milling-force waveforms are reproducible again. The parallel per-step force build read lazily built scalar caches on the shared tool objects; a thread could pass a cache guard and then read a value a concurrent writer had stored in between, so two plays of the same NC exported different forces in the thin-chip window of each tooth pass. The caches were first republished as single immutable references and then removed in favour of the frozen session pack. Thermal gating and seeding. The sequential cutting-temperature and wear build now checks EnablePhysics (spindle temperature deliberately keeps running), and the tool-change thermal seeding re-arms whenever the incoming chain state has no flute temperature list — which covers fault and cancel re-seeds, stop-then-replay residue, and EnablePhysics being switched on mid-session. The shank temperature list is seeded to the exact node count the thermal FEM builds, so trailing shank nodes no longer sit at 0 K after a tool change. Cutter geometry is validated up front. GetUpperBeamGeometryIssues collects upper-beam and shank configuration problems as keyed messages — for example an extended-cylinder beam whose full length sits below the flute height (Cutter-UpperBeam--BelowFluteHeight), which inverts the shank solid and makes the shank thermal model unbuildable. They are reported once per tool at BeginSession and at each tool change, instead of surfacing later as a null-reference cascade inside the thermal physics with nothing naming the beam. RakeFaceCuttingPara3d no longer throws on a six-field parameter string (the guard read the seventh element behind a >= 6 check), and the published coefficient index mappings are corrected: the LocalProfileMillingPara(Vec3d, Vec3d) constructor maps (x,y,z) to (Ksr, Kst, Ksa) / (Kpr, Kpt, Kpa), and the 2d element index range is 0–3 with 0=Ksc, 1=Ksn, 2=Kpc, 3=Kpn. Training diagnostics name their cause. The per-step warnings split into Train-StepLuggage--Unreadable (the step luggage row could not be read back) and Train-StepEngagement--Missing (the row is present but the engagement was never built because physics was inactive at simulation time). The gather pass counts both against the eligible steps: silent at zero, one summary warning at or below MissingEngagementAbortRatio (default 0.25), and a configuration error above it. A gather pass that produces no samples at all now reports immediately rather than throwing inside the SVD solve, separating “not one step touched the workpiece” from “touched steps whose mapped force data yielded no usable shots”. New training knobs. EnableDesignMatrixSolver (default false) solves the least squares on a thin QR of the design matrix instead of forming the normal equations, which square the condition number; DesignMatrixSvdRelativeTol is its truncation cutoff. EnableCwePhasePairing (default false) determines each step's rotation phase with a cutter-workpiece-engagement block-pairing detector instead of the self-bootstrapped lead parameter, for one-flute and symmetric two-flute cutters in light radial side cuts. ReTrainAnchorOutputScale exposes the virtual anchor weight. LastMillingParaTrainResult captures the outcome — kind, sample flags, outlier ratio, success, output file, parameter name and note, correlation R, filtered sample count, parameter XML, timestamp — so a caller reads it without re-opening the .mp file. Time mapping is reworked around absolute wall-clock time. AddTimeDataByFile accepts DateTime windows, stored as IFileTimeSection forms, and the project-scoped MappingAnchorDateTime — seeded set-once from the date of the first controller instant seen — converts controller timestamps onto one run-relative axis. EndTimecode replaces AccumulatedTime as the canonical end-of-step time. CSV timing survives midnight. Step durations derive from full date-bearing instants, so a multi-day recording no longer produces negative durations and a negative chart time axis, and a non-physical duration from a spliced recording is clamped with a validation warning instead of stalling physics evaluation. Wall-clock time is dense. The trio moved into one optional sub-object, StepActualTime (Timecode / Instant / IsInterpolated), reached through ActualTime. On CSV plays every built step is stamped: steps built from a controller row re-anchor, and the steps between extrapolate along the machine timeline and are marked interpolated, which makes the actual-time mapper window per-step exact instead of sparse-anchor scaled. Pure NC plays keep null stamps. An empty step-shot pairing window is a data gap, not something to interpolate across. The window builder used to expand outward to the rows bracketing the gap, silently pairing such steps with force values that were never measured — a training run over a file whose transients had been carved out produced a plausible correlation and a full set of coefficients derived entirely from fabricated rows. Such a window now skips its step and one Map-ShotGap--StepsSkipped warning per mapping call carries the count; a window-edge row is interpolated only when its bracketing rows span at most two spindle revolutions. “No cut / No data for step” on freshly-simulated steps is fixed. The bulk step-data readers cached the absence of rows the writer had not committed yet, so a step that had just been simulated could report no data until the program was re-run. A covered-but-missing index now drops the stale segment and re-reads. New end-of-play warnings, each once per session: Play-Touch--None (the play finished without any step touching the workpiece), Tool-FluteCount--Zero (physics is on and a milling cutter resolves to zero flutes, so feed per tooth is undefined), and Play-Physics--None (physics is on and at least one step touched the workpiece but no touched step carries a physics brief — naming the three things that gate it: a tool bound to the spindle, the spindle actually rotating, and the workpiece cutting parameter). That last state previously surfaced one process later, as a training run gathering zero samples. Performance is collected in its own section below."
  },
  "release-note/upgrading-to-3.2/nc-optimization-and-writeback.html": {
    "href": "release-note/upgrading-to-3.2/nc-optimization-and-writeback.html",
    "title": "NC optimization and writeback | HiAPI-C# 2025",
    "summary": "NC optimization and writeback Important NC optimization is not finished on the 3.2 line. What follows describes the leg as it stands, and it is published for review, not for production. Work that depends on optimized output should stay on the 3.1 line, serviced as 3.1.175.<patch>. The optimizer runs on the SoftNc pipeline by default. OptimizeToFiles keeps its signature, its script snippet and its HTTP route, but when EnableSoftNcRunner is on and the session holds played SyntaxPieceLayers, it delegates to the new OptimizeNcFiles; otherwise the frozen HardNc path runs unchanged. The new leg classifies the final SyntaxPiece layer, solves the per-step feed adjustments from milling physics, and regenerates text as anchored token edits over the verbatim source block — lines the optimizer does not touch round-trip byte-identically instead of being re-synthesized. Per-file results are retained in NcOptimizations. EnableIndividualStepAdjustmentLog drives both legs. Depth splition re-interpolates through a planned fragment path, with separate modal chains for the pre-build feed and the emission endpoint, per-step machine-to-program-frame inversion, and per-fragment arc IJK recomputation — including R-to-IJK conversion — wherever the arc block itself carries the centre. An arc whose centre lives on a preceding modal block is exempt: its fragments keep the source block's arc words and share that upstream centre line unchanged, so only their endpoint and F words move. Two cases where the frozen HardNc optimizer is silently wrong are downgraded to a non-split rewrite rather than reproduced: a G91 incremental block (the old fragment rewrite always emitted absolute coordinates), and a klartext C … DR± arc whose modal CC chain left one of the two in-plane axes unstated, so the block's own start point supplied that component — since every fragment would re-derive the centre from its own start. A klartext C block whose centre lands entirely on its own start point never reaches that guard: its radius is zero, so play degrades it to a chord under a validation warning of its own. Neither the controller brand nor klartext as such refuses a split: a klartext L block re-interpolates like an ISO one. The compensation stage is no longer dead on the SoftNc leg. The HardNc baseline wrote the compensation into the step contexts while its output read the piece packs, so it never emitted a compensated coordinate at all. Each fragment endpoint is now offset — XYZ only, rotary words untouched — by the tool-tip deflection rotated into the leaf program frame the endpoint lives in, so a G68.2 tilted setup is compensated in the right direction. It is consumed on re-interpolated splition fragments only, and CompensationMask defaults to 0, so with no mask set the stage is a strict no-op. Output follows the source's decimal digits. Both legs used to write coordinates through a fixed F4 and every F word through F2, so a program stated to three decimals could come back with a fourth — an alarm on controllers strict about their least input increment. Digit counts are now scanned per word family over the played source texts with comment spans masked, floored at 3/3/0 and capped at 9, and threaded through the whole write path. The word-suppression tolerances and the F comparison grid derive from the resolved digits instead of the old fixed literals. Optimized NC is written back in the source file's encoding. NC play reads and optimized writes go through DetectRoundTripEncoding — BOM, then strict UTF-8, then Latin-1 — so an ANSI-family file (GBK, Big5, Shift-JIS) re-encodes to its original bytes instead of having every undecodable byte replaced. Comments in those encodings survive the round trip. A feed change no longer mints a one-step carrier fragment. Under an arc split that fragment is a degenerate arc whose start and end nearly coincide, which an incremental-IJK reader — or a control that treats begin == end as a full turn — expands into a full circle. An F re-statement is now handed to the feed run's next emitted fragment, the one that actually runs at that feed. A splition fragment at the head of the stream writes only the axis words the source stated, so it can no longer invent a Z0. whose value under the source's silence is just the home-fallback modal. Unparsable NC lines survive. A line the parser could not read used to be dropped from the runner's line list, so the optimized file silently lost it. HardNcRunner now rebuilds a parse-failed line as an opaque no-op — the empty-text parse inherits modal state like a blank line, and the raw text is restored for writers — and the optimizer mirrors the fallback, so IF blocks, #-variable macros, G68 R# and GOTO come through verbatim. A BuildNcLines--ParseFailed diagnostic still reports the line, and the line stays un-simulated. The output writer is also closed in a finally, so an exception can no longer leave a half-written file locked. First delivered on the 3.1.175.x service line. A Siemens CYCLE800 swivel counts as a macro line in the piece classifier, so it is preserved rather than treated as an optimizable motion block. The host key HiNC:OptCoreNum governs both legs again. It used to set only the legacy NcOptProc.CoreNum; once the SoftNc optimizer became the default path the key silently stopped governing anything. It now assigns both (0 = derive from the processor count). NC text writeback regenerates NC from a program that has already been played, in two stages over the session's finished syntax pieces: a converter turns the source piece stream into a destination stream plus a bidirectional source↔destination map keyed by sentence index, and a reverse segmenter serializes that stream back to lines. The data→text seam is a brand-agnostic sentence composer, first implemented for Fanuc. A patch-mode writer performs positional token edits — NaN deletes a word absorbing one separator space, insertion follows conventional order, trailing zeros trim keeping the dot — and refuses to rewrite variable, bracket and keyword values rather than corrupting them, reporting Writeback-Patch--VariableValue, --KeywordValue, --CommentOnlyText and --EditUnmatched. Five of its choices follow the dialect rather than the convention: the variable prefix it recognizes and refuses (Q on klartext, R on Siemens, # elsewhere), the keyword feed values it refuses (klartext's FMAX and FAUTO), the comment spans it protects (klartext's ; and // as well as the parenthesized span), and two that show in the written text. On a klartext file an inserted F lands after the rightmost of DR+/DR- and RL/RR/R0 as well as after its conventional predecessor coordinate words, so the patched block keeps the element order a TNC enforces — coordinates, rotation direction, radius compensation, F, M. And a trailing comment is wrapped in the file's own grammar, the Fanuc family's (text) against klartext's ;text, so the optimizer's embedded source note leaves a klartext program valid instead of handing a control a parenthesis it would read as code. A second diagnostic home. NcManipulationDiagnosticProgress is a sibling of the play-time NcDiagnosticProgress, dedicated to NC-rework operations — writeback conversion and optimization — so a play reset never discards manipulation results and vice versa."
  },
  "release-note/upgrading-to-3.2/new-diagnostics.html": {
    "href": "release-note/upgrading-to-3.2/new-diagnostics.html",
    "title": "New diagnostics you may now see | HiAPI-C# 2025",
    "summary": "New diagnostics you may now see Several failure modes that used to be silent now report. These ids are searchable and filterable — they are the fastest way to find out what a run actually did. Id Means Play-Touch--None the play finished without any step touching the workpiece Play-Physics--None physics is on and steps touched, but no touched step carries a physics brief Tool-FluteCount--Zero physics is on and a milling cutter resolves to zero flutes SpindleDirection--AssumedCw an S word greater than zero with no direction ever issued Composition--NotLicensed external pipeline units were skipped for this session Script--NotLicensed an NC-embedded C# script was skipped SiemensToolOffset--TcdpRowMissing a Siemens (T, D) pair had no $TC_DP row; the generic tool height was used Comp-ToolHeight--001 a G43.4 H word could not be resolved Coord-WorkOffset--AdditionalZero a Fanuc-family additional work coordinate system (G54.1 Pn, also written G54 Pn) was selected but no offset has been entered for it; the program runs on the machine origin Coord-WorkOffset--NoTableEntry a work coordinate word (e.g. a G59.x on a controller carrying no brand-neutral table beside its brand table) that no coordinate table on the controller resolves; a zero offset is used Coord-WorkOffset--IndexUnresolved the P word of a G54.1 / G54 P selection is not a positive integer; the active work coordinate system is kept Coord-MachCoord--005 / --006 / --007 a G53 or G53.1 machine-coordinate move failed on a path that used to fail silently Coord-Tilt--001 / --002 a G68.2 tilted plane the machine cannot reach BuildNcLines--ParseFailed a line could not be parsed; it survives verbatim but is not simulated RunNcLines--RunnerMismatch a second runner kind was attempted inside one session ReadNcRunnerSuit--Refused a suit switch was attempted while a program was playing PostExecution--MeshedGeomOutputRetired an old project still carries the retired meshed-geom output pair ConvertClToNc--NoPlay CL-to-NC conversion ran with no prior play on a machine chain ClToMc--NoToolOffset a CL motion resolved no tool offset Map-ShotGap--StepsSkipped steps were skipped because their shot pairing window held no measured row Train-StepEngagement--Missing a step's row is present but its engagement was never built Train-StepLuggage--Unreadable a step's luggage row could not be read back Writeback-Patch--* a writeback edit refused a variable, keyword or comment-only value, or matched nothing HeidenhainPlane--Unsupported / SiemensFrame--Unsupported / HeidenhainCycl--Unsupported the construct is recognized and consumed safely, but not simulated DeclaredMCode--UnmodeledEffects a machine-declared OEM M-code occurred; no effects are simulated for it"
  },
  "release-note/upgrading-to-3.2/packaging-and-hosting.html": {
    "href": "release-note/upgrading-to-3.2/packaging-and-hosting.html",
    "title": "Packaging, resources and hosting | HiAPI-C# 2025",
    "summary": "Packaging, resources and hosting Shipped resources carry an ownership marker. ResourceDefaultMarker introduces the .default convention: files carry the marker before the final extension (AlTiBN.default.CoatingMaterial) and machine-tool packages carry it on the folder (MachineTool/Table-B1.default/). Marked items are system territory the seeder may refresh or delete; unmarked items belong to the user and are never touched. Seed copies the shipped defaults into the admin resource root at startup — anchored on the application base directory rather than the process working directory, version-stamped so steady-state boots do no work. A save-as flow must strip the marker so a user file cannot masquerade as a shipped default. HiNc-Resource ships more presets: Resource/Controller/<Brand>.default.Controller for all five brands, and StandardForcedAir / StandardWaterSolubleCoolant / StandardOilBasedCoolant coolant conditions, so those load browsers start populated instead of empty. CoolantHeatCondition gains name/note, the three static presets, preset find/match/apply, and side-file IO following the workpiece-material pattern — CoolantHeatConditionFile externalizes the condition to a .CoolantHeatCondition file. Obfuscation-safe DTOs. Obfuscar renames compiler-generated anonymous types and strips their constructor parameter names, so System.Text.Json threw on every ToPresentDto serialization in released assemblies — the geometry, cutter and transformer editors all returned HTTP 500 while Debug builds were fine. Every implementation now returns Dictionary<string, object> with nameof keys, which compile to string literals obfuscation cannot touch, and IToPresentDto documents the rule. See the wire-key list under Signature and shape changes. The embedded default font is Noto Sans CJK TC (SIL OFL 1.1) in place of the Big5-only HanWang WCL06, fed to the native engine from memory instead of writing an 11 MB Font/WCL06.ttf into the process working directory. Traditional, simplified and kana render from one face with zh-Hant glyph conventions. Explicit font paths still go through the file route. Third-party notices ship with the two packages that actually redistribute third-party bits: HiDisp (the native files under runtimes/ and the embedded font) and HiNc-Resource (the offline documentation site among its content files). HiLicense gained a real package description. Dependency updates — SQLitePCLRaw.bundle_e_sqlite3 is pinned to 3.0.3 (SQLite CVE-2025-6965), Microsoft.Data.Sqlite to 10.0.9 and Dapper to 2.1.79. Small public additions — DetectRoundTripEncoding, CompactNanOptions and named float literals in GetDouble, CycleUpperInclusive (the (l,u] cyclic window the existing overloads could not express), and AddAndGetIndex. IndexSegment no longer leaves an open run end when the match sits at either edge of the list."
  },
  "release-note/upgrading-to-3.2/performance-and-footprint.html": {
    "href": "release-note/upgrading-to-3.2/performance-and-footprint.html",
    "title": "Performance and footprint | HiAPI-C# 2025",
    "summary": "Performance and footprint Every figure below is a measurement with its conditions stated, and where a change cost time to buy correctness that is said too. Read the ratios rather than the absolute times: several campaigns were run on Debug builds or on small machines, deliberately, because a paired A/B on one machine answers “did this get faster” far more reliably than an unpaired Release number on a fast one. Milling physics in the native kernel The per-step physics moved into core.dll in stages — engagement scan conversion, the force kernel, then the sequential temperature and wear chain. Measured as a same-day paired A/B, managed leg against native leg, on one circular test program: Per touched step managed native Engagement build 46.0 ms 5.03 ms ~9× Force (GetMillingFoce) 17.1 ms 0.75 ms ~20× Temperature and wear chain 3.97 ms 0.24 ms ~16× Whole play 59.3 s / 16.1 GB allocated 40.6 s / 3.4 GB allocated −32% wall, −79% allocation Allocation is where the migration bites hardest: engagement construction alone fell from about 5.2 GB to 29 MB per step. Conditions. Debug x64, EnablePhysics on, collision off, one force worker, a two-core / four-thread laptop, ±10% thermal-throttle noise, single paired run per leg. Absolute times are not representative of a customer machine — the ratios are the claim. Numerical parity. Engagement, force and brief are bit-identical between the two legs on Windows. The Linux build is not bit-identical (different libm), so a cross-platform comparison should use a tolerance, not equality. Playing a long program stays linear NcOptOption.Equals ended on a null-propagating comparison of a dictionary that is created on demand and is null on virtually every option, so the whole comparison collapsed to false — an option compared unequal even to a copy of itself. Both record-on-change guards built on it were therefore dead: the session appended an option-map entry for every played act instead of only at change points, and the step rewrote unchanged entries. Reading the last recorded option through a LINQ LastOrDefault over a SortedList<,> — which has no indexed fast path — then walked the whole map each time, so the two defects together made a long play quadratic. Measured on a 2.35-million-line Siemens program: the option map now holds 1 entry instead of one per line, and the per-100,000-line rate stays flat instead of degrading from 73 s at the start of the file to about 11 minutes by 1.9 million lines. This applies to every runner and to sessions doing no optimization at all, because the call site is the session-level play loop. GetHashCode drops the dictionary in the same change, since it hashed by reference and would otherwise disagree with Equals — relevant if you use NcOptOption as a dictionary key. Where the time actually goes Worth knowing before you tune anything. After the migration, on the measured workload the whole parallel physics stage is about 3.3% of wall time, while the single-worker volume subtraction is about 77% — and that subtraction is single-worker as a correctness requirement, not as an oversight. Raising the force-worker count therefore buys nothing on any machine; the bottleneck moved rather than disappearing. What did change in the worker derivation is narrower than it sounds. An unmeasured six-core ceiling was removed, but it only ever governed the sweep workers, and only machines with nine or more logical processors see a different count; force workers are unchanged everywhere. The throughput benefit on such a machine has not been measured — the development machines are smaller — so this is a ceiling removal, not a claimed speedup. Queue depths became fixed item budgets (120 geometry, 3840 physics) rather than scaling with the core count, because those queues bound per-item memory: uncapped, a 64-core machine would have been handed 40,960-deep physics queues. On machines with fewer than six cores this is a small increase in bounded-queue memory (from 80 / 2560), which is the honest cost of the change. Loading a large STL workpiece Building the topology from an STL was quadratic in triangle count — a pointer-derived hash collapsed into a handful of buckets, so lookups degenerated into linear scans. On one 935,000-triangle binary STL, topology construction was 99.6% of the entire load; reading the file off disk was 0.16% of it. With a multiplicative hash mix the build is linear: Triangles before after worst bucket 100,000 8,711 ms 1,305 ms 6.7× 2,245 → 21 300,000 89,036 ms 4,750 ms 18.7× 6,593 → 23 Per-triangle cost is now flat (0.013 → 0.016 ms/tri across a 3× size increase), which is the real result: the cost grows with the mesh instead of with its square. Extrapolated to the full 935,000-triangle mesh that is roughly 14 minutes → 15 seconds. Deduplication and the resulting topology are unchanged — the equality predicate was not touched, and the 300,000-triangle case produces an identical 899,997 lines before and after. Separately, the managed-to-native STL handoff dropped from three full copies of the buffer (about 86 MB each, plus around twenty doubling reallocations) to two. Conditions. Native test harness, debug CRT — which inflates container-operation constants, so the absolute milliseconds are an upper bound. The composition breakdown and the complexity change are build-configuration independent. The full-mesh figure is an extrapolation, not a measured run. Re-triangulating after a cut The marching-cubes step gained a lookup table, and produces fewer triangles for the same surface: Tree before after triangles 17 MB diagnostic 0.63 s 0.29 s 2.17× −35% 30 MB demo 1.29 s 0.60 s 2.15× −35% 309 MB customer part 14.68 s 6.51 s 2.25× −43% Scope. This lands on the rebuild burst after a cut invalidates cached geometry, not on steady-state rendering, which draws from the display cache and is unchanged. It is also an approximation change, not purely a speedup: a non-finite cut drops its triangles, so a sub-voxel feature vanishes at that level of detail instead of being capped. That is what fixed the broken-face slabs seen on RTCP paths. The contact-loop extraction used by milling physics deliberately still uses the previous walk, so physics results are untouched. Session memory: a long program no longer exhausts the client A session retains every executed NC block for its whole lifetime. Once a block leaves the executing window its piece is now frozen to compact UTF-8. Measured on a 25,018-block play: session retention 406 MB → 142 MB, about 2.9×. The encoding itself is smaller than that ratio suggests — roughly 12 KB per line live against 1.6 KB frozen, about 12.9× — because a retained piece carries more than its JSON. The 2.9× is the figure that matters for whether a program fits in memory. The trade is explicit: after the freeze the JsonObject getter re-parses on every call and returns a fresh read-only snapshot, with no caching and no write-back. Code that reads the same piece repeatedly should hold the snapshot in a local. The switch is FreezeExecutedPieces, on by default. Sizing a meshed workpiece A cube tree costs roughly 3.2× its file size in RAM while loaded — a 10 GB .wct at 0.125 mm resolution is about 95 million nodes, holding around 25 GB of tree plus 6 GB of index. Tearing down a tree that size used to block the caller for over two minutes; disposal now runs serialized on a background chain, so the thread that dropped it does not wait. The remaining cost is genuine work: the live renderer must not be left showing geometry that no longer exists. Cutter-location files at production scale Three costs were removed from the CL-to-machine path, and on a production-scale file they are the difference between replaying and appearing to hang: tool-offset resolution walked back to the distant LOAD block for every motion (O(N²), now O(1) through a modal section), the documentary program-to-Pn stamp did the same walk (now stamped once per run), and the program-zero query deep-cloned the whole equipment assembly on every motion block (now a cached per-run matrix over the live assembly). These are complexity changes; they have not been separately timed. Smaller footprint The embedded default font is handed to the display engine from memory, so an 11 MB .ttf is no longer written into the process working directory on startup. The packages are x64-only, and HiNc-Resource no longer ships a duplicated nested copy of the CT-350 STL set. Things that cost more, on purpose Five-axis inverse kinematics. Tightening the orientation envelope from about 1.4e-3 rad to about 1e-6 rad — measured maxima 1.5e-8 rad on the hot path and 2.1e-8 on teleport, a tip deviation of 0.05 µm on a 50 mm tool — costs roughly eleven solver iterations where one used to do, so a posture-changing call went from about 23 µs to about 251 µs, and a teleport from 418 µs to 1607 µs. Only posture-changing RTCP and arc steps pay it: three-axis programs and constant-posture segments are exempt through the McLinear downgrade. In absolute terms a 1,432-step five-axis replay spends about 0.36 s in the solver. (Debug build including measurement overhead, so those microseconds are an upper bound.) Machine-coordinate linear stepping. ActMcXyzLinearContour derives its step count from the euclidean length of the machine XYZ delta rather than the largest single-axis component, so LinearResolution_mm caps actual tool-tip travel per step. A diagonal move therefore produces up to √3× more steps than before at the same setting — more work, for a sampling density that now means what the setting says. Lower the resolution if the old step count was what you were budgeting for. A tuning cliff worth knowing about MillingCycleDivisionNum saturates. Raising it past roughly 180 buys no additional training accuracy while the cost keeps climbing: a training run that takes about four minutes at 180 takes hours at 720 and needs on the order of 100 GB of RAM to do it. The default of 36 is for ordinary simulation; raise it for training, but not past the point where the curve flattens."
  },
  "release-note/upgrading-to-3.2/results-that-change-on-upgrade.html": {
    "href": "release-note/upgrading-to-3.2/results-that-change-on-upgrade.html",
    "title": "Results that change on upgrade | HiAPI-C# 2025",
    "summary": "Results that change on upgrade None of the following breaks a build. All of them change what a simulation produces, so a byte-for-byte comparison against 3.1.175 output will differ — usually because 3.1.175 was wrong. Silent wrong geometry, now fixed. Each of these produced a plausible-looking simulation of the wrong thing. The kinematic pivot anchor. The pivot-transform chain entry was built as K(0)·K(abc)⁻¹, folding the whole machine-zero forward kinematic — its linear part included — into the pre-pivot anchor. That linear part encodes each axis' motion sense and tool/workpiece-side ownership, so it mirrored the program components of every workpiece-side linear axis before the IK ran. On a table-side chain whose machine-zero linear part is diag(1,1,-1), every program Z was mirrored and a near-180° swing amplified it into metres of machine-Z error, floating the toolpath above the workpiece. The anchor is now the translation alone, matching what HardNc has always kept. Machines whose linear axes all ride the tool side are unaffected. G68 2D coordinate rotation was a silent no-op. TiltTransformUtil judged the active mode from the current block but always took the matrix from the previous one, so every G68 activation past the first block had its freshly authored rotation overwritten with an identity that then propagated. G68 rotation did nothing at all while the block's term still read G68, and the simulation machined the unrotated pattern. Re-running an existing G68 program now gives different — correct — geometry. A blank line reset G90/G91. A piece with no parsing section — a blank line, a comment-only line, %, an O-number — left the next block's single-step lookback empty, and it fell back to the G90 default. A program that was incremental throughout silently flipped to absolute mid-file. Such pieces now carry the positioning section forward like every other modal syntax. A Siemens D offset with no $TC_DP row resolved to zero length, in silence. A whole TRAORI program machined one tool length low. The read point now falls back to the generic tool-number-keyed height and emits SiemensToolOffset--TcdpRowMissing. G43.4 with an unresolvable H word activated RTCP with a zero-length tool. It now reports Comp-ToolHeight--001 as a warning and keeps processing the block. An absent H stays silent — re-activating G43.4 on the modal offset id is legitimate input. Heidenhain DIN/ISO arc centres. I / J / K are absolute circle centres on Heidenhain — the ISO face of the klartext CC pole — not start-to-centre offsets. Reading them incrementally turned arcs into near-full phantom circles. Fixed in all three engines: the HardNc reader (IsIjkAbsolute), the SoftNc reader (IsIjkAbsolute) and the optimizer's write-back. G91 is the exception: an incremental block switches the words back to start-to-centre offsets, so an arc programmed under G91 is unaffected by this change. Also delivered on the 3.1.175.x service line. Feed per tooth, MRR and cutting forces follow the equipped tool's tip, not the controller's F word. The physics used to read the commanded CL feedrate. It now reads the step's real tip feedrate (ActualTipFeedrate_mmds, client key ActualTipFeedrate_mmdmin): the tip's displacement relative to the workpiece over the step duration. On XYZ moves, CL files and RTCP with the equipped tool's own offset the two agree (the recomputation moves forces by at most about 1e-4 relative, from the TimeSpan-quantised step duration); they part under RTCP with a tool-length offset that does not describe the equipped tool, on rotary-axis-limited simultaneous five-axis blocks (the tip is slower than F, up to a few percent), and wherever the commanded value was stale. One such stale case is fixed alongside: a feed block that repeats the current position (X.. Y.. Z.. F1600. right after the same point at F800.) lost its F word, so every following block showed and cut at the old feed; its ActFeedrate now lands. A K0 word on a HardNc G02/G03 saturated the turn count. Under the default G17 plane a written-but-zero plane-normal word divided the axial travel by zero, the additional-turn count saturated to int.MaxValue, and one arc block became a spiral act of roughly 302 simulated years — the play appeared to hang on a single NC line. The reading now falls back to the closed-circle rule for a zero pace, matching the guard the SoftNc side already had. Indexed-rotary programs folded the pivot into plain moves. A block with no active G68.2 or G43.4 no longer folds the kinematic pivot transform into a plain XYZ move, which is what a real controller does with a table-side rotary program. The radius-compensation arc transient cache landed on the wrong block. Any non-motion line between the corner and the arc orphaned the cache, so the arc lost its leading linear bridge and began at the corner intersection instead of on the offset arc. The G68.2 tool-axis IK fallback probed the mirrored tool axis. Both normal-only fallbacks in IsoG68p2TiltSyntax read the transposed third column instead of the third row. On the no-hint path this only skewed a warning gate, but the explicit A/B/C path seeds its hint blend from that solve, so a machine with fewer than three rotary axes composed a mirrored tilted plane. A Fanuc WHILE forward jump bound to the wrong END. Sequential loops idiomatically reuse DO 1, so a second WHILE's falsy-condition exit bound to the first loop's END 1 and redirected execution to a point before the second WHILE — an unbounded loop the iteration watchdog cannot see, because it only ticks on END reverse jumps. The jump now uses the anchored label scan the Siemens loop family already used. Heidenhain G28 is MIRROR IMAGE, not a reference-point return. On the Heidenhain preset the shared pipeline had been reading it as the Fanuc reference return, so a G28 X block minted a phantom rapid to home while the mirror silently vanished. It is now simulated as a program-to-MC transform, ReferenceReturnSyntax leaves the Heidenhain logic list, and klartext CYCL DEF 8 records the same mirror statement so one program mirrors identically in either dialect. HardNc keeps the Fanuc reading, so the two engines are deliberately divergent on Heidenhain G28 files and any parity comparison must account for it. MathUtil.Convert_inchdmin_To_mmds returned mm/min, not mm/s. The body multiplied by 25.4 and never divided by 60, so a caller trusting the name got a 60× feedrate; the sibling Convert_mmdmin_To_mmds divides as its name demands. No shipped path called it — the CL/APT feedrate route converts inches-per-minute to mm/min itself — so this changes nothing inside the product, but a caller who had compensated for the old behaviour must remove that compensation. GetRByZ(List<PairZr>) never interpolated. The list overload looked up its ceiling node with the floor lookup, so floor equalled ceiling and the method degenerated into a step function. For a sharp cone whose inner-beam Z–R list has no node between apex and rim, that pinned the inner radius to 0 across the whole cone face and produced NaN flute vertices — the root cause of the transparent cone-tip flute that 3.1.180 addressed at the display layer. It affects every consumer of radius-by-Z interpolation, force geometry included. Numerical results move even where nothing was renamed. Five-axis IK is roughly 1000× tighter. The rotary solver behind XyzabcSolver now runs coarse→polish: the coarse stage keeps the original dot residual so solve success and failure semantics are unchanged, then a [dot, cross, rr-per-axis] system polishes. The dot criterion is quadratically blind to angle error — an envelope of about 1.4e-3 rad, and the resulting tip error is that envelope times the tool length — so adding the cross term restores quadratic convergence and drops the envelope to about 1e-6 rad. Failed solves no longer pollute the implicit seed, and the measure-zero perfect-saddle case is escaped by a deterministic retry offset instead of by leftover seed pollution. ActMcXyzLinearContour steps by euclidean tip travel instead of the largest per-axis component, so LinearResolution_mm now caps actual tool-tip travel per step and a diagonal move produces up to √3× more steps at the same setting. The SoftNc pipeline is the default engine. Executed SyntaxPieces freeze to UTF-8 (below), so their JsonObject is a fresh read-only snapshot per call rather than a retained live graph. SyntaxPiece.SentenceIndex becomes a session-global execution-order counter and is no longer contiguous per file. Repeated NC diagnostics fold into per-run summaries at the run boundaries. HardNc tool changes fire on M06 / Heidenhain TOOL CALL rather than on a changed T word — a bare T is magazine pre-selection, and a same-tool M06 still runs the changer cycle — and unset HardNcEnv tooling defaults become the three-axis shape (XYZ = NaN, NaN, 0; ABC all NaN). The old defaults swung all three rotary axes home on every M06, which no post expects."
  },
  "release-note/upgrading-to-3.2/session-project-and-commands.html": {
    "href": "release-note/upgrading-to-3.2/session-project-and-commands.html",
    "title": "Session, project and command model | HiAPI-C# 2025",
    "summary": "Session, project and command model A parser and its per-case data travel as one file. NcRunnerSuit bundles a runner with the dependency data a particular job needs, as a single file-loadable unit. The project holds three suits — NcRunnerSuit, CsvRunnerSuit and ClsfRunnerSuit — and ReadNcRunnerSuit / WriteNcRunnerSuit switch the active parser mid-project from a suit file. A switch attempted while a program is playing is refused with ReadNcRunnerSuit--Refused. One NC runner configuration is shareable across projects. Per-case data — tool offsets, work-coordinate offsets, Siemens frames, Heidenhain datums, retained macro variables, seeded brand parameter tables — travels as proxy placeholders inside SoftNcRunner and resolves against the owning project's per-case list, so a controller configuration is no longer welded to the job it was first built for. Machine-config consumers read the resolved view through GetEffectiveNcDependencyList; legacy <NcDependencyList> XML and NcEnv-based projects still load and migrate automatically. HTTP guards and one envelope. RequireActiveSessionAttribute answers a session-scoped action with HTTP 409 and an ApiActionResult.NoActiveSession() body when no session is active, instead of the previous null-reference 500; RequireLoadedProjectAttribute does the same for the project-level controller. Both are applied at the controller level and honour opt-out markers (AllowNoActiveSessionAttribute, AllowNoLoadedProjectAttribute). Mutating actions inject a fresh MessageCollector and return the collected notifications inline in the shared ApiActionResult envelope, so a REST or AI caller sees progress, success and error messages in the response instead of only out of band. LocalProjectServiceController exposes the project-level (session-independent) surface parallel to SessionShellController. Session commands declare themselves. CommandCatalogAttribute marks an ISessionCommand as user-addable and places it in a CommandCategory (Setup / Program / Optimization / Output / Flow, declaration order = display order) with an Order sort key and an optional wire kind (default: the class name minus the Command suffix, lower-cased). CommandFieldAttribute marks a bool / int / double / string property as a directly editable scalar with an optional label, unit and physics-licence flag, so a generic editor renders and updates it without a hand-written form. A command without the catalog attribute stays loadable from project files but is not offered for creation. Program File dispatches by kind. NcFileCommand gains an NcKind property (XML element NcKind, absent = Auto for legacy projects) and its mission label becomes “Program File”; each command resolves its own file, so a List of Program Files can mix brand NC, CL and CSV. Two session commands saved but could never be read back. ListCommand.Reg chained every type except NcOptOptionCommand and RecordMeshedGeomCommand, so any XML round-trip of an entry holding one threw KeyNotFoundException out of the XFactory generator lookup — reloading a saved project containing an NC Optimization Config command failed. Both are now chained. Naming. Title is an optional name shown in place of the type name, so nested command lists can be named in the mission tree. PreSettingCommand displays as “General Config” and NcOptOptionCommand as “NC Optimization Config” — display strings only, so serialization and endpoints are untouched. A bare non-list PlayerCommand root is normalized on read into a single enabled entry of the default ListCommand. Command titles, catalog categories and field labels are now localized, and a zh-Hans resource set was created (none existed before). Default-script template keys stay untranslated on purpose — they compose the C# comments and script title written into the user's .hincproj, which travels to other machines. Script faults are keyed errors. A CompilationErrorException or a faulted script task used to surface as an anonymous warning; ScriptCommand now reports ScriptCommand-Compile--Failed with the full diagnostic list and ScriptCommand-Run--Fault with the exception, both at Error severity. A fresh session re-homes the machining chain. ResetRuntime wrote the configured XYZ home but hard-coded ABC to 0, and it only ran on project switch or pace-player reset — never before a plain Play. A freshly loaded project therefore started from whatever pose the .mt happened to serialize, while the act stream interpolated from the home seed, so the first contour swept from a pose the machine was never at and cut along the way. The re-home now reads the rotary homes from the same home configuration and also runs at BeginSession; a mid-session replay is untouched. What a reset actually resets. ResetRuntime now also rewinds the NC-runner session state, so the next play restarts file and line indexing from scratch the way PowerReset does, and it resets the CL device pose to identity. It no longer clobbers MachiningResolution_mm: the runtime resolution is seeded from the workpiece's initial resolution only when a project loads, so an explicit override survives a runtime reset and a workpiece swap. Mixed runner kinds in one session are refused. NcRunnerSessionState remembers the runner that initialised it and RunNcLines refuses a different one with RunNcLines--RunnerMismatch — reachable now that NcKind.Auto makes mixed-kind missions a first-class flow. Stale state on a chain or project switch. Building the coordinate converter nulls the rotary solver when the chain is not an IXyzabcChain, so a solver built for the old machine no longer keeps converting after a switch to a CL device; and ClearCache now also calls ClearIdealGeomCache, so loading another project stops rendering the previous project's target geometry. Project-file operations are serialized through a zero-wait gate. A New / Load / Save / Reload arriving while another is in progress throws ProjectFileBusyException immediately instead of racing into a file-in-use IOException. AlignWorkpieceProgramZeroToIso computes in the machine-zero state. It reflects the assembly and zeroes every dynamic axis before querying displacements, so the alignment is correct even when the live machine's axes are displaced. RunCount counts runs started, incremented synchronously before the run's task launches and never reset. Pairing it with IsFinished in one snapshot lets a polling client distinguish “the run I started has finished” from a stale Finished left by a previous run."
  },
  "release-note/upgrading-to-3.2/the-package-line.html": {
    "href": "release-note/upgrading-to-3.2/the-package-line.html",
    "title": "The package line | HiAPI-C# 2025",
    "summary": "The package line master develops the 3.2 package line as of 2026-08-24. All ten packages — HiGeom, HiLicense, HiDisp, Hi.WinForm, Hi.WpfPlus, HiCbtr, HiMech, HiUniNc, HiNc, HiNc-Resource — moved to 3.2 together and restarted their build counters. Four consequences worth stating plainly: A 3.2 build number starts low, and the two counters are not comparable. The gap between the last 3.1 number a feed served and the first 3.2 one is expected rather than a missing upload. The ten counters are independent. They did not restart at a common value and they do not advance together: a package's counter moves only when that package is rebuilt, so the ten numbers spread apart and stay spread. Where two of them happen to agree it is coincidence, not a shared set number. A set is named by its HiNc package version — the top of the library stack, and the number the application shows as its own version mark — while the nine packages under it carry their own builds. The published packages reference one another with a floating 3.2.*, so restoring HiNc pulls the newest 3.2 build of each dependency rather than a fixed, reproducible set. A build that has to be reproducible pins each package explicitly. The 3.1 line is closed at the 3.1.175 set and is serviced only as patches on that set. A package on the service line keeps the 3.1 build it was frozen at and gains a fourth segment of its own, so the set is quoted as 3.1.175.<patch> after its HiNc package while the packages beneath it publish under their own frozen builds — looking on the feed for every package at 3.1.175.x finds only HiNc. A reference left on that set receives correctness fixes for it and none of the capability on this page. The 3.1 builds above 3.1.175 were never published as a release set — which is why the release note carries one 3.2 entry where it might have carried a dozen: for a caller moving off 3.1.175, they were never separate releases."
  },
  "technique/api-foundations/basic-geometry.html": {
    "href": "technique/api-foundations/basic-geometry.html",
    "title": "Geometry Objects | HiAPI-C# 2025",
    "summary": "Geometry Objects IGetStl is the single-member interface that hands back an Stl, and it is what the geometries listed below have in common — most of them reach it through IStlSource, which adds XML persistence on top of it. It does not span every geometry object: a voxel mesh reference such as CubeTreeFile persists itself and presents itself without ever answering GetStl. Code meant to accept every kind of geometry binds to the interface that group actually shares, not to IGetStl. Several common geometry types are available: Basic Geometrys Box3d Cylindroid Stl StlFile Management Geometrys TransformationGeom GeomCombination See Transformations for TransformationGeom. GeneralTransform StaticRotation StaticTranslation Note All coordinate values use standard units (millimeters, radians) Example Usage using System; using System.Collections.Generic; using Hi.Geom; using Hi.Mech.Topo; namespace Sample.Geom; /// <summary> /// Demonstrates the creation and manipulation of geometric objects in HiAPI. /// Shows how to create and transform various geometry types including boxes, cylindroids, and STL files. /// </summary> /// <remarks> /// ### Source Code /// [!code-csharp[SampleCode](~/../Hi.Sample/Geom/DemoBuildGeom.cs)] /// </remarks> public static class DemoBuildGeom { /// <summary> /// Generates a collection of geometric objects for demonstration purposes. /// Creates various geometry types including boxes, cylindroids, STL files, and transformed geometries. /// </summary> /// <returns>A list of geometries implementing the IGetStl interface</returns> public static List<IGetStl> GenGeoms() { Box3d box = new Box3d(0, 0, -50, 70, 50, 0); Cylindroid cylindroid = new Cylindroid([ new PairZr(0,12),new PairZr(20,12), new PairZr(20,16),new PairZr(30,16)]); Stl stl = new Stl(\"geom.stl\"); StlFile stlFile = new StlFile(\"geom.stl\"); TransformationGeom transformationGeom = new TransformationGeom() { Transformer = new GeneralTransform(1, new StaticRotation(new Vec3d(0, 0, 1), MathUtil.ToRad(15), new Vec3d(0, 0, 0)), new StaticTranslation(new Vec3d(0, 0, 0))), Geom = stl }; GeomCombination geomCombination = new GeomCombination(stlFile, transformationGeom); return new List<IGetStl>([box, cylindroid, stl, stlFile, transformationGeom]); } } See Also Getting Started with HiAPI — the environment these geometries are assembled into About XML IO — how a geometry is persisted with its project"
  },
  "technique/api-foundations/getting-started.html": {
    "href": "technique/api-foundations/getting-started.html",
    "title": "Getting Started with HiAPI | HiAPI-C# 2025",
    "summary": "Getting Started with HiAPI What a first HiAPI application needs: where the packages come from, what the program has to initialise, and the shape every HiNC program follows once it runs. Installation Create a dotnet project. A console or service project targets net10.0. A project that also takes one of the Windows UI packages targets net10.0-windows — that is what Hi.WinForm and Hi.WpfPlus are built for, and a plain net10.0 project cannot reference them. An earlier target framework cannot reference any of the packages. Register the HiAPI package source on the machine. The feed requires authentication, and the same account that gives you the sample repositories gives you the packages. One command registers the source and its credentials, which is the whole of what a restore needs: dotnet nuget add source https://superhightech-gitea.webredirect.org/api/packages/HiAPI/nuget/index.json --name HiAPI --username <your-account> --password <your-token> --store-password-in-clear-text Run it once per machine. Customers served by the mainland mirror register the feed address issued with their account in place of the URL above; nothing else changes. Prefer this to a project-local nuget.config, and never declare the feed in both places. NuGet resolves credentials by source name, and the match is case-sensitive, so a file that declares the same URL under a name the machine holds no credentials for adds a second, credential-less source. NuGet asks every source about every package, and one 401 fails the whole restore instead of falling through — so the packages it then reports as missing are the public nuget.org ones, and the cause is nowhere near the symptom. A credential-free file cannot stand in for the command either: the feed rejects anonymous requests, so it carries a fresh clone no further than having no source at all. Where a per-machine source is genuinely unavailable — an ephemeral build agent, say — a nuget.config beside the project file does the job, provided it is the only declaration of that URL and carries its own credentials under exactly the key it gave the source: <?xml version=\"1.0\" encoding=\"utf-8\"?> <configuration> <packageSources> <add key=\"HiAPI\" value=\"https://superhightech-gitea.webredirect.org/api/packages/HiAPI/nuget/index.json\" /> <add key=\"nuget.org\" value=\"https://api.nuget.org/v3/index.json\" protocolVersion=\"3\" /> </packageSources> <packageSourceCredentials> <HiAPI> <add key=\"Username\" value=\"xxxxxx\" /> <add key=\"ClearTextPassword\" value=\"xxxxxx\" /> </HiAPI> </packageSourceCredentials> </configuration> That file holds a password in clear text: keep it out of version control. In the dotnet project file, add the package reference. <ItemGroup> <PackageReference Include=\"HiNc\" Version=\"3.2.*\" /> <!--optional; needs a net10.0-windows project--> <PackageReference Include=\"Hi.WpfPlus\" Version=\"3.2.*\" /> </ItemGroup> In the program file, setting the HiNC application initialization and finalization. using Hi.HiNcKits; using Microsoft.Extensions.Logging; using System; namespace Sample { /// <summary> /// A sample class demonstrating initialization and usage of the HiAPI framework. /// Shows the basic setup of display engine, MongoDB server, licensing, and other core functionality. /// </summary> /// <remarks> /// This example serves as an entry point for those getting started with HiAPI. /// It demonstrates proper initialization and teardown of key components. /// ### Source Code /// [!code-csharp[SampleCode](~/../Hi.Sample/HelloHiAPI.cs)] /// </remarks> public static class HelloHiAPI { static int Main(string[] args) { Console.WriteLine(\"HiAPI starting.\"); using var loggerFactory = Microsoft.Extensions.Logging.LoggerFactory.Create(b => b.AddConsole()); LocalApp.AppBegin(loggerFactory.CreateLogger(\"Hi.Sample\")); Console.WriteLine(\"Hello World! HiAPI.\"); LocalApp.AppEnd(); Console.WriteLine(\"HiAPI exited.\"); return 0; } } } The Shape of a HiNC Program Every HiNC program, whether it is the shipped application or twenty lines in a console project, runs the same five steps. DemoBuildMachiningProject in the Hi.Sample repository is the complete worked example. graph TD A[\"Create MachiningProject\"] --> B[\"Setting Environment\"] B --> C[\"Setting Project Tasks\"] C --> D[\"Run Tasks\"] D --> E[\"View Analysis Results\"] 1. Create MachiningProject Creating a machining project is the first step in the HiNC workflow, accomplished by initializing a MachiningProject object. 2. Setting Environment In MachiningProject The equipment has two faces. SetupEquipment is the authored one — the only face a project file persists, and the one every setting below is written to. MachiningEquipment is the runtime face the runner, physics, collision and execution display read; it is rebuilt from the authored face at project assignment and at session boundaries, so a value written onto it is discarded rather than saved. Set SetupEquipment: Usually one-time settings: MachiningChain - Configure the complete machine tool including geometry, kinematic chain, and coordinate transformations SpindleCapability - Configure SpindleCapability CoolantHeatCondition - Configure coolant heat conditions BackgroundTemperature_C - Configure the environment background temperature in Celsius; BackgroundTemperature_K holds the same value in Kelvin Variable settings: Fixture - Configure fixture Workpiece - Configure workpiece Set MachiningToolHouse - Configure tool house Set HardNcEnv (Controller) - Configure NC system environment parameters 3. Setting Project Tasks Set sequential tasks using PlayerCommand: Set NC Files - Set the file path and customize simulation and optimization settings for each NC file Configure NC optimization - Configure NC code optimization parameters Set GeomDiffCommand - Configure geometry comparison functionality to compare target workpiece shape with simulated shape Set MillingTraining - Configure milling parameter training to calibrate simulation parameters based on actual machining data Other task configurations… The PlayerCommand is typically a ListCommand that contains a sequence of command entries to be executed during the simulation. 4. Run the Tasks (Simulation and Optimization) Run PlayerCommand through PacePlayer. At this stage, the simulation process is similar to video playback, which can be: Started Stopped Paused Run one line Run one step Reset The PacePlayer controls the execution pace of the simulation, allowing you to observe the machining process in detail or run it at full speed. View the Analysis During Process or Result ShellProgress contains a sequence of simulation messages and step data, which can be used to monitor and analyze the simulation process and results. Sample Code to Start a MachiningProject See the following sample code to start a HiAPI application. DemoBuildMachiningProject Build a MachiningProject. DemoUseMachiningProject Load a MachiningProject and run NC simulation. DemoRenderingMachiningProcessAndStripPosSelection Apply MachiningProject to 3D canvas with user-interaction in windows platform. See Also HiAPI Packages and Sample Code — the NuGet feed and the sample repositories the demos named here live in Geometry Objects — the geometry types the environment in step 2 is assembled from"
  },
  "technique/api-foundations/index.html": {
    "href": "technique/api-foundations/index.html",
    "title": "API Foundations | HiAPI-C# 2025",
    "summary": "API Foundations What a C# application built on HiAPI needs before anything else runs: where the packages come from, what a program has to initialise, the geometry objects it passes around, and the two cross-cutting services — messages and XML serialization — that the rest of the API assumes are already there. Ordered the way a new application meets them: getting the packages, writing the first program, then the pieces every later page takes for granted. Starting an Application HiAPI Packages and Sample Code — The NuGet feed, the package dependency chain, which package a UI framework needs, and the three sample repositories Getting Started with HiAPI — Wiring the feed into a project, initialising and finalising the runtime, and the five steps every HiNC program follows What Every Page Assumes Geometry Objects — The STL-backed interface behind every geometry type, and the basic and management geometries built on it Message Management — Three independent message channels — diagnostic, UI notification, application log — and why they are never mixed About XML IO — The serialization pattern every persisted HiAPI type implements, and the registration that must happen before a project is loaded See Also Rendering — putting what these types describe on a screen Mechanism — assembling them into a machine that moves"
  },
  "technique/api-foundations/message-management.html": {
    "href": "technique/api-foundations/message-management.html",
    "title": "Message Management | HiAPI-C# 2025",
    "summary": "Message Management HiNc applications use three independent message categories. Each category serves a distinct purpose and should not be mixed. Categories 1. Diagnostic — IProgress<IMessage> Operation-scoped progress and diagnostic messages. The caller provides an IProgress<IMessage> sink to the callee, which reports progress, warnings, and errors through it. Every IMessage carries a Severity, a Category, and a filterable id. Session-scoped: ShellProgress feeds the Session Message Panel; StepDiagnosticProgress retains step-anchored diagnostics and NcDiagnosticProgress retains NC-parsing diagnostics. XML IO chain: XFactory threads IProgress<IMessage> through all deserialization calls so that parsing errors are reported to the caller rather than a global handler. Script-level: ShellProgress exposes the session sink to user scripts. Per-call: inject a MessageCollector to buffer one call's messages and read them back afterwards (e.g., to return them inline in an HTTP response). Project IO: LoadProject and ReloadProject take a sink of their own, because project IO runs outside any session and none of the session sinks above exists while it runs. A load-time diagnostic — a referenced STL missing on disk, a child XML that will not deserialize — does not fail the load; the project comes up without that geometry and the call returns normally. Passing no sink leaves the application log as the only witness, and the caller sees an unqualified success. Reporting to a sink and the log at once An operation a caller may or may not be watching reports to both: always to the service ILogger, and additionally to an injected IProgress<IMessage> when there is one. EnableCollisionDetection, ResetRuntime and the two project-load entry points share that shape, and the parameter being optional is what lets a host with no caller to answer to — a script, a desktop shell — behave exactly as it did before the sink existed. The counterpart obligation is that one operation reports one diagnostic once. Where a later stage re-reads what an earlier one has already reported on — the XML round trip that materialises execution equipment re-walks the sources the deserialization pass just read — that stage stays logger-only deliberately, so a caller collecting a project load does not receive every missing file twice. Reporting helpers, and the args channel Use the MessageUtil id-first helpers to report typed messages. Each is named {Category}{Severity} — SystemError, SystemWarning, ValidationWarning, ConfigurationWarning, … — takes the structured id first, and is null-safe on the sink. Every helper has a {Category}{Severity}Fmt sibling that takes a FormattableString in place of the string. The sibling keeps the template and the values interpolated into it on the message itself, as GetFormat() and GetArgs(), so a consumer holding a translation of that template can re-render the message in another language instead of dropping the numbers. The notification stays the invariant English rendering, so a value carried in it never picks up a decimal separator from a locale. What a client does with the pair, and why the English template is load-bearing rather than descriptive, is under Internationalization. progress.SystemErrorFmt(\"StlFile-Read--Failed\", $\"File Reading Failed: {path}\"); Important The sibling is opted into by name, and nothing reports its absence. An interpolated literal handed to the plain helper binds to string, is formatted on the spot, and the template is gone: the call compiles, reads identically at the site, and produces a message no client can translate. Report through Fmt wherever the text interpolates a value. Where it does not, stay on the plain helper — a client swaps a hole-less message by id alone, so giving it a template only adds a way for the equality gate to miss. 2. UI Error Notification — MessageBoardUtil Toast-style popups for immediate user attention (e.g., “File saved”, “Load failed”). MessageBoardUtil triggers the ShowMessageBoard event consumed by the GUI layer. Note MessageBoardUtil is not yet mature for all scenarios. In practice, ILogger with level-filtered treatment is often applied instead. 3. App Log — ILogger Standard .NET ILogger for application-level logging. Use ActionProgress<T>.FromLogger to bridge IProgress<object> APIs to an ILogger instance: IProgress<object> progress = ActionProgress<object>.FromLogger(logger); This routes each reported IMessage (or raw Exception) to the appropriate log level (LogError, LogWarning, LogInformation) based on its severity — with one precedence worth knowing: a message carrying an Exception as its detail goes to LogError with that exception attached whatever severity the message itself declares, so a warning that names an exception is logged as an error. A null logger is accepted and becomes a no-op sink. A host built without dependency injection has none to hand over, and this bridge is reached from the error-reporting path itself, so a version that threw on a null logger would turn the first reported error into a crash inside the code meant to describe it. Basic-Component / Utility Level Low-level utilities (e.g., in Hi.Common, Hi.Geom) cannot assume which category the caller intends. These APIs accept Action<Exception> or IProgress<IMessage> as parameters so the caller decides how to handle messages: await task.CatchExceptions(ex => progress?.Report(ex)); Design Rationale Static/global message sinks mix the three categories, making it unclear whether a message is diagnostic, UI notification, or app log. The current pattern threads the handler explicitly through the call chain so each caller decides the appropriate category. See Also About XML IO — the other cross-cutting service, and the one that threads a progress channel through deserialization ShellProgress — the session-scoped face of the diagnostic channel, as a script sees it"
  },
  "technique/api-foundations/packages-and-samples.html": {
    "href": "technique/api-foundations/packages-and-samples.html",
    "title": "HiAPI Packages and Sample Code | HiAPI-C# 2025",
    "summary": "HiAPI Packages and Sample Code HiAPI is a C# software development kit for machining simulation. It provides libraries for NC motion simulation, collision detection, geometry removal simulation, milling force simulation, optimization, and more. Nuget Packages The HiAPI is applied by the form of Nuget Packages. You have to apply HiNc nuget package and its dependencies. They include all the functionality of the HiNC software, but do not include the GUI components. The packages can be downloaded and installed from the HiAPI NuGet Server. The server URL is: https://superhightech-gitea.webredirect.org/api/packages/HiAPI/nuget/index.json Note Authentication is required to access the server. Register the feed and the account together with the single dotnet nuget add source command in Getting Started — the feed rejects anonymous requests, so a source declared without credentials gets a restore no further. Direct browser access to the URL will not show meaningful content. Since the server is designed for Visual Studio NuGet package management. For more information about NuGet, visit NuGet.org Package Dependencies The HiNc package has the following dependency chain: graph LR HiGeom --> HiDisp HiDisp --> HiCbtr HiCbtr --> HiMech HiMech --> HiUniNc HiUniNc --> HiNc HiDisp --> Hi.WinForm HiDisp --> Hi.WpfPlus style HiNc fill:#d3d,stroke:#333,stroke-width:2px UI Framework Support If you need to develop Windows desktop applications: For Windows Forms applications, use the Hi.WinForm package. For WPF applications, use the Hi.WpfPlus package. Note See Building Your Own Rendering Canvas to build the rendering canvas cross-platform. HiAPI Sample Code Download the sample repositories below to get the samples. They demonstrate various aspects of using HiAPI for machining simulation: HiNC-2025-webservice https://superhightech-gitea.webredirect.org/HiAPI/HiNC-2025-webservice.git The source of the shipped HiNC application itself — a Quasar SPA served by ASP.NET Core. It is the production-scale example: every screen you see in the product is built from the public API documented here, and each component is dissected in HiNC App Anatomy. Hi.Sample https://superhightech-gitea.webredirect.org/HiNC-Deploy/Hi.Sample.git The repository generally contains the sample codes without using rendering canvas. Hi.Sample.Wpf https://superhightech-gitea.webredirect.org/HiNC-Deploy/Hi.Sample.Wpf.git The repository generally contains the sample code that requires rendering canvas. See Also Getting Started with HiAPI — wiring this feed into a project and writing the first program against it Rendering — what the Hi.WinForm and Hi.WpfPlus packages above are for"
  },
  "technique/api-foundations/xml-io.html": {
    "href": "technique/api-foundations/xml-io.html",
    "title": "About XML IO | HiAPI-C# 2025",
    "summary": "About XML IO The XML IO design pattern in HiNc Framework is based on IMakeXmlSource interface and XFactory class. This pattern provides a standardized way to serialize and deserialize objects to and from XML format. Don't serialize the runtime member object like Func<TResult> or Action either cache object. The runtime objects can be optionally sent by the res part on the XFactory Registration or set by the other host or dependent object. If it is set by the other object, then there is nothing can do to it in the XML IO procedure. Core Components IMakeXmlSource Interface The IMakeXmlSource interface defines the contract for objects that can be serialized to XML format. It contains a single method MakeXmlSource. XFactory XFactory is an instance class with a process-wide Default singleton (XFactory.Default). The instance form exists for test isolation and parallel pipelines that need disjoint generator registries; the static Gen<T> / GenByChild<T> / GenByFile<T> entry points always read from Default. Each instance owns its own Generators dictionary (XML element name → generator delegate). Types add themselves via a Reg(factory) call (see below). Explicit Registration via Reg(XFactory factory = null) Every class implementing IMakeXmlSource exposes a public static Reg method: public static void Reg(XFactory factory = null) { factory ??= XFactory.Default; factory.Generators.TryAdd(XName, (xml, baseDirectory, relFile, progress, res) => new MyClass(xml, baseDirectory, relFile, progress)); } Key properties: Explicit. Callers see registration happen — no hidden side effect from accessing a static member or constructing a type. Idempotent. Uses TryAdd, so the same Reg may be invoked any number of times from any number of boot paths. Composable. Custom factory instances are supported via the optional factory parameter; default usage (MyClass.Reg();) populates XFactory.Default. For example, see BallApt: /// <summary> /// Registers this type's deserializer with the given <see cref=\"XFactory\"/> /// (or <see cref=\"XFactory.Default\"/> when <paramref name=\"factory\"/> is /// <c>null</c>). Idempotent. /// </summary> public static void Reg(XFactory factory = null) { factory ??= XFactory.Default; factory.Generators.TryAdd(XName, (xml,baseDirectory, relFile, progress, res) => new BallApt(xml)); } Composite types chain Reg(factory) on dependents When a class deserializes child elements via XFactory.Gen<T> / XFactory.GenByChild<T>, its Reg(factory) must chain Reg(factory) on each concrete child type so the whole dependency graph is reachable from a single root call: public static void Reg(XFactory factory = null) { factory ??= XFactory.Default; DependentA.Reg(factory); DependentB.Reg(factory); factory.Generators.TryAdd(XName, (xml, baseDirectory, relFile, progress, res) => new MyComposite(xml, baseDirectory, relFile, progress)); } For polymorphic deserialization (GenByChild<IInterface>), the composite must chain every concrete implementation that may appear in the XML. The largest composite, SoftNcRunner, chains roughly 130 dependents (every dependency, initializer, segmenter, syntax, and semantic the NC pipeline may deserialize). Multi-name registration (legacy aliases) When the XML payload may carry an old element name for backward compatibility, register the current XName first and group legacy aliases under a //legacy aliases comment: public static void Reg(XFactory factory = null) { factory ??= XFactory.Default; XFactory.XGeneratorDelegate gen = (xml, baseDirectory, relFile, progress, res) => new MachiningProject(xml, baseDirectory, progress); factory.Generators.TryAdd(XName, gen); //legacy aliases factory.Generators.TryAdd(\"MachiningCourse\", gen); factory.Generators.TryAdd(\"MillingCourse\", gen); } IProgress Threading The IProgress<IMessage> parameter is threaded through the entire deserialization chain. When a class constructor calls XFactory to deserialize child objects, it passes the same progress instance: public MyClass(XElement src, string baseDirectory, string relFile, IProgress<IMessage> progress) { Child = XFactory.GenByChild<IChild>( src.Element(nameof(Child)), subBaseDirectory, progress); } Parsing errors are reported to the caller-provided IProgress<IMessage> handler. What a failing child does XFactory does not swallow failures: a generator that throws propagates, and the load fails with it. Tolerance is opted into per type, and is visible at the place that chose it. A type that owns an external file catches its own read failure and reports it, then comes up without that content. StlFile reports the resolved path rather than the relative SourceFile, because the base directory is gone by the time the message is read anywhere else — a load response, a message panel — and the folder is what says which machine or part file is missing. GenListSkippingUnloadable drops the list entries whose element name is unregistered or whose generator throws, reporting each as a warning. It is for lists whose schema drifts while a feature is in development — the NC pipeline's dependency, initializer and syntax lists — where a partially loadable list beats aborting the whole load. Writing MakeXmlSource produces the element; the file layer around it is MakeXmlSourceToFileRef, which either hands that element back inline — when no relative file is named for it — or writes it to a file of its own and returns a file-reference element in its place. That is what makes a project file a document of references instead of one large document. Children first, parent last MakeXmlSourceToFileRef prepares only the directory up front. The children's own side files — nested XML, STL copies — are written from inside MakeXmlSource, and the parent file itself is written by SaveToFileRef only once every child has succeeded. A child that fails — a locked or read-only side file, a full disk, a serialization bug — therefore leaves the previous version of the parent intact, rather than an empty file that points nowhere. An existing parent is probed for write access before the children are touched, by opening it without truncating. A read-only or locked parent fails there, instead of leaving a folder of freshly written children beside an unchanged old parent. Copy-on-save, and the file that must stay missing StlFile serializes as its path and copies its mesh beside the new document, but only when nothing is at that target path already — the mechanism that lets one project be written under several base directories without rewriting meshes that are there. SaveStlToFile owns the directory creation, from the resolved path, and stays away from the file system entirely when CacheStl is null. That last condition is the contract, not a guard. An STL whose source was missing when the project was read has no cached mesh and must stay missing: a zero-length file in its place reads back as an opaque loading failure instead of an exception naming the path, and it is a new untracked file in someone's project folder. Important exhibitionOnly suppresses the XML writes; it does not reach the copy. MakeXmlSourceToFileRef and SaveToFileRef both honour it and produce the reference elements without creating anything, but StlFile's copy-on-save does not consult it at all. So a purely in-memory round trip still copies cached meshes into a base directory that lacks them — which is what a project load does when it materialises the runtime equipment from the authored one. Writing is not confined to saving. Boot path An application's entry point (web service Program.cs, WPF App.xaml.cs, test fixture, etc.) must call the appropriate top-level Reg() once at startup, before any project XML is deserialized. For the simulation pipeline this is: LocalProjectService.Reg(); LocalProjectService.Reg() chains MachiningProject.Reg(), which in turn chains every type the simulation pipeline may deserialize. After this single call returns, XFactory.Default.Generators carries the full deserialization graph. Implementation Patterns Simple Value Objects See BallApt implementation: /// <summary> /// Name for XML IO. /// </summary> public static string XName => nameof(BallApt); /// <summary> /// Ctor. /// </summary> /// <param name=\"src\">XML</param> public BallApt(XElement src) { Diameter_mm = double.Parse(src.Element(\"D\").Value); FluteHeight_mm = double.Parse(src.Element(\"FluteH\").Value); } /// <inheritdoc/> public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) => ToXElement(); /// <inheritdoc/> public XElement ToXElement() { return new XElement(XName, new XElement(\"D\", Diameter_mm), new XElement(\"FluteH\", FluteHeight_mm) ); } Complex Data Structures See SpindleCapability implementation: /// <summary> /// Name for XML IO. /// </summary> public static string XName => nameof(SpindleCapability); /// <summary> /// Initializes a new instance of the <see cref=\"SpindleCapability\"/> class. /// </summary> /// <param name=\"src\">The XML element containing spindle data.</param> /// <param name=\"baseDirectory\">The base directory for resolving relative paths.</param> /// <param name=\"res\">Additional resolution parameters.</param> public SpindleCapability(XElement src, string baseDirectory, params object[] res) { this.SetNameNote(src); if (src.Element(nameof(EnergyEfficiency)) != null) EnergyEfficiency = XmlConvert.ToDouble( src.Element(nameof(EnergyEfficiency)).Value); src.Element(nameof(WorkingTemperatureUpperBoundary_C))?.SelfInvoke( e => WorkingTemperatureUpperBoundary_C = XmlConvert.ToDouble(e.Value)); src.Element(nameof(GearShiftSpindleSpeed_rpm))?.Value?.SelfInvoke( s => GearShiftSpindleSpeed_rpm = string.IsNullOrEmpty(s) ? null : XmlConvert.ToDouble(s)); if (src.Element(nameof(DryRunFrictionPowerCoefficient_mWdrpm)) != null) DryRunFrictionPowerCoefficient_mWdrpm = XmlConvert.ToDouble( src.Element(nameof(DryRunFrictionPowerCoefficient_mWdrpm)).Value); if (src.Element(nameof(DryRunWindagePowerCoefficient_pWdrpm3)) != null) DryRunWindagePowerCoefficient_pWdrpm3 = XmlConvert.ToDouble( src.Element(nameof(DryRunWindagePowerCoefficient_pWdrpm3)).Value); if (src.Element(\"SpindleSpeedToPowerContours\") != null) //for legacy WorkableDurationToSpindleSpeedPowerContoursDictionary_min_cycleDs_kW = src.Element(\"SpindleSpeedToPowerContours\").Elements(\"Contour\") .ToDictionary( contourElem => { double r = XmlConvert.ToDouble(contourElem.Attribute(\"InsistentRatio\")?.Value); //600s=10mins return r == 1 ? double.PositiveInfinity : (r * 600); }, contourElem => contourElem.Elements(\"SpindleSpeedToPower\").Select( elem => new Vec2d( XmlConvert.ToDouble(elem.Element(\"SpindleSpeed-RPM\").Value) / 60, XmlConvert.ToDouble(elem.Element(\"Power-kW\").Value))) .ToList()); src.Element(\"WorkableDurationToSpindleSpeedPowerContoursDictionary\") ?.SelfInvoke(dicElem => { WorkableDurationToSpindleSpeedPowerContoursDictionary_min_cycleDs_kW = dicElem.Elements(\"Contour\") .ToDictionary( contourElem => XmlConvert.ToDouble( contourElem.Attribute(\"WorkableDuration-min\")?.Value), contourElem => contourElem.Elements(\"SpindleSpeedToPower\").Select( elem => new Vec2d( XmlConvert.ToDouble(elem.Element(\"SpindleSpeed-RPM\").Value) / 60, XmlConvert.ToDouble(elem.Element(\"Power-kW\").Value))) .ToList()); }); if (src.Element(\"SpindleSpeedToTorqueContours\") != null) //for legacy WorkableDurationToSpindleSpeedTorqueContoursDictionary_min_cycleDs_Nm = src.Element(\"SpindleSpeedToTorqueContours\").Elements(\"Contour\") .ToDictionary( contourElem => { double r = XmlConvert.ToDouble(contourElem.Attribute(\"InsistentRatio\")?.Value); //600s=10mins return r == 1 ? double.PositiveInfinity : (r * 600); }, contourElem => contourElem.Elements(\"SpindleSpeedToTorque\").Select( elem => new Vec2d( XmlConvert.ToDouble(elem.Element(\"SpindleSpeed-RPM\").Value) / 60, XmlConvert.ToDouble(elem.Element(\"Torque-Nm\").Value))) .ToList()); src.Element(\"WorkableDurationToSpindleSpeedTorqueContoursDictionary\") ?.SelfInvoke(dicElem => { //MessageUtil.WriteLine($\"dicElem: {dicElem}\"); WorkableDurationToSpindleSpeedTorqueContoursDictionary_min_cycleDs_Nm = dicElem.Elements(\"Contour\").ToDictionary( contourElem => XmlConvert.ToDouble( contourElem.Attribute(\"WorkableDuration-min\")?.Value), contourElem => contourElem.Elements(\"SpindleSpeedToTorque\").Select( elem => new Vec2d( XmlConvert.ToDouble(elem.Element(\"SpindleSpeed-RPM\").Value) / 60, XmlConvert.ToDouble(elem.Element(\"Torque-Nm\").Value))) .ToList()); //MessageUtil.WriteLine($\"keys: {string.Join(',',WorkableDurationToSpindleSpeedTorqueContoursDictionary_min_cycleDs_Nm.Select(e=>e.Key))}\"); }); //for legacy compatible. if (src.Element(\"SpindleSpeedToPower--RPM-to-kW\") != null) InfInsistentSpindleSpeedToPower_cycleDs_kW = src.Element(\"SpindleSpeedToPower--RPM-to-kW\").Elements() .Select(elem => new Vec2d(XmlConvert.ToDouble(elem.Attribute( \"SpindleSpeed-RPM\").Value) / 60, XmlConvert.ToDouble(elem.Value))).ToList(); //for legacy compatible. if (src.Element(\"SpindleSpeedToTorque--RPM-to-Nm\") != null) InfInsistentSpindleSpeedToTorque_cycleDs_Nm = src.Element(\"SpindleSpeedToTorque--RPM-to-Nm\").Elements() .Select(elem => new Vec2d(XmlConvert.ToDouble(elem.Attribute( \"SpindleSpeed-RPM\").Value) / 60, XmlConvert.ToDouble(elem.Value))).ToList(); } /// <inheritdoc/> public XElement MakeXmlSource(string baseDirectory, string relFile, bool exhibitionOnly) { return new XElement(XName, this.GetNameNoteXElementList(), new XElement(nameof(EnergyEfficiency), EnergyEfficiency), //the constructor reads this element; without the matching write a //save/load round trip through the web API silently reverted a //non-default bound to the 65 C default. new XElement(nameof(WorkingTemperatureUpperBoundary_C), WorkingTemperatureUpperBoundary_C), new XElement(nameof(GearShiftSpindleSpeed_rpm), GearShiftSpindleSpeed_rpm), new XElement(nameof(DryRunFrictionPowerCoefficient_mWdrpm), DryRunFrictionPowerCoefficient_mWdrpm), new XElement(nameof(DryRunWindagePowerCoefficient_pWdrpm3), DryRunWindagePowerCoefficient_pWdrpm3), new XElement(\"WorkableDurationToSpindleSpeedPowerContoursDictionary\", WorkableDurationToSpindleSpeedPowerContoursDictionary_min_cycleDs_kW.OrderBy(entry => entry.Key) .Select(entry => new XElement(\"Contour\", new XAttribute(\"WorkableDuration-min\", entry.Key), entry.Value.Select(entry => new XElement(\"SpindleSpeedToPower\", new XElement(\"SpindleSpeed-RPM\", entry.X * 60), new XElement(\"Power-kW\", entry.Y))))) ), new XElement(\"WorkableDurationToSpindleSpeedTorqueContoursDictionary\", WorkableDurationToSpindleSpeedTorqueContoursDictionary_min_cycleDs_Nm.OrderBy(entry => entry.Key) .Select(entry => new XElement(\"Contour\", new XAttribute(\"WorkableDuration-min\", entry.Key), entry.Value.Select(entry => new XElement(\"SpindleSpeedToTorque\", new XElement(\"SpindleSpeed-RPM\", entry.X * 60), new XElement(\"Torque-Nm\", entry.Y))))) ) ); } Best Practices XName: Always define static XName property matching the class name. Registration: Expose public static void Reg(XFactory factory = null); first line is factory ??= XFactory.Default; then factory.Generators.TryAdd(XName, …). Chain dependents: For every concrete type T that the ctor reads via XFactory.Gen<T> / XFactory.GenByChild<T>, add T.Reg(factory); to the chain. For polymorphic GenByChild<IInterface>, chain every implementation that the XML may carry. Idempotent: Use TryAdd, never Add. The same Reg is called from many boot paths. Progress Threading: Pass the IProgress<IMessage> parameter through all nested XFactory calls. See Message Management for the rationale. Legacy Support: Register the canonical XName first, then group aliases under a //legacy aliases comment. Derived class registration: When a derived class needs its own Reg, mark it public new static void Reg(XFactory factory = null) so the C# compiler does not warn about hiding the base method. Side files from inside MakeXmlSource, never ahead of it: an implementation that owns an external file writes it from within MakeXmlSource, which is what keeps the framework's children-first ordering true. It must not create a file for content it does not hold — a source that was missing at load time stays missing, because an empty file is harder to diagnose than an absent one. See Also Message Management — the diagnostic channel threaded through deserialization Geometry Objects — the types most often persisted through this pattern Color Guide System — a project-registered implementation serialized this way"
  },
  "technique/index.html": {
    "href": "technique/index.html",
    "title": "Technique | HiAPI-C# 2025",
    "summary": "Technique The durable knowledge behind HiNC: the milling physics the simulation implements, what the machine and the workstation can actually deliver, how a measured quantity gets into the model, and how the NC optimizer decides a feed rate. GUI-neutral by design — this is the layer that stays true when a screen moves. Ordered by how far the subject sits from the cutting edge: what happens at the edge first, then what the equipment around it can supply, then what is measured, then what is rewritten — and last the API surfaces an application is built on: scripting, rendering, and the mechanism topology. Milling Physics — The frames the numbers live in, the criteria that decide whether a cut survives, tool wear, and the cutter-side levers that move both Machine Capability — Spindle boundary curves and thermal envelope, controller behaviour, CAM-side drift, and the simulating workstation's own throughput ceiling Measurement — How a real cutter angle and a real cutting force get from the bench into the model NC Optimization — What the optimizer targets, what limits each step, and why corner feed rates come out low Simulation Performance — What the simulation itself costs to run, and what a coarser mesh gives up Validation — What has been checked against measurement, how closely it agreed, and where the agreement stops Scripting — The C# command surface a session is driven from, the step objects a run produces, and the message stream it reports through Rendering — Hosting the display engine in a UI framework, producing what it draws, and deciding the colour a machining step comes out with Mechanism — The kinematic topology a machine is assembled from, the transform matrices that move it, and drawing an assembly through its anchors NC Dialects — The interpreter that turns a controller program into motion, and the brand-by-brand support matrix API Foundations — The packages, the shape of a first program, and the geometry, messaging and serialization services everything else assumes See Also Manual — how to do it in the app, chapter by chapter Setup — the equipment settings these models stand behind Workflows — end-to-end task guides API Reference — the generated C# reference"
  },
  "technique/machine-capability/cam-floating-point-drift.html": {
    "href": "technique/machine-capability/cam-floating-point-drift.html",
    "title": "CAM Floating-Point Drift Triggers Floor-Contact Force Peaks | HiAPI-C# 2025",
    "summary": "CAM Floating-Point Drift Triggers Floor-Contact Force Peaks Layered (Z-stepped) cuts can produce force peaks that look like simulation bugs but reflect a real physical sensitivity: sub-micron contact between the cutter bottom face and the previous-layer floor produces a large force difference, and CAM-generated NC programs often drift between layers by similar amounts on whichever axis carries the repeated path. This coupling between CAM floating-point drift and sub-micron floor sensitivity is rarely recognized in typical workflows; HiNC surfaces and diagnoses it through smart-tool-holder validation and force-simulation comparison. See also NC Optimization and Corner Feedrate Behavior. Phenomenon In a Z-stepped uniform cut, one or two specific layers occasionally show a sharp force spike. In the example below, the X-direction force peak reaches ~865 N where adjacent layers stay near a ~477 N steady level on a D16 mm cutter in aluminum. Users often interpret this as a simulation anomaly because the NC optimizer slows the feedrate dramatically at the spike. Schematic of a Z-stepped layered cut. Each horizontal trace is one layer; sub-thousandth-mm in-plane drift between layers (Y in this example) shifts where each layer enters and exits the previous-layer floor. Spike layer that contacts the previous-layer ridge — X peaks reach ~865 N. Adjacent normal layer at the “same” XY — X stays near ~477 N. Mechanism Smart-tool-holder measurements show that the cutter bottom face is sensitive to sub-micron contact with the previous-layer floor: A gap of less than 1 μm already produces a measurable force difference. Below the minimum effective chip thickness — 7.5 μm in this example, and in general varying with workpiece material and cutter edge geometry — no chip is formed, but friction on the cutter's lower contact band still loads the spindle. In simulation, modeling the cutter floor as lifted by 0.15 μm versus not lifted yields visibly different spindle-torque waveforms — and only the lifted version matches the real smart-holder torque shape. Simulation force peaks driven by floor contact therefore reflect a real sensitivity, not a numerical artifact. NC-Side Trigger: Layer-to-Layer Drift CAM-generated NC programs frequently drift by ~0.001 mm between consecutive Z layers when they traverse the “same” position. In the example below, the drift falls on Y; in other programs it may fall on X or any in-plane axis along the repeated path. N1000 G01 Y10.001 (layers 1..4) N1100 G01 Y10.002 (layer 5) N… G01 Y10.005 (last layer) Each layer lands at a slightly different position relative to the previous floor. Some layers contact the leftover ridge from the layer above; others miss it. The contacting layers exhibit the peak. Why the Simulation Peak Is Real The simulation force model simplifies how the cutter upper portion engages when the gap is below the minimum effective chip thickness, so the simulated peak may be slightly larger than the real peak. For ductile materials (aluminum being a representative case), friction dominates the cutting force, so the overestimate is small. The actual machine has independent safety margins: the controller decelerates at corners (see Corner Feedrate Behavior), and cutter rotation provides a flute-level Probabilistic Peak Dodging effect. In the example above, the cutter remains inside its safe limits at the spike peak (~865 N versus the ~477 N baseline). Harder materials would be more prone to flute breakage at the same NC, but the fix is the same. Probabilistic Peak Dodging For a multi-flute cutter, whether a contacting layer actually produces a peak depends on the flute phase at the contact moment. Force samples within one flute period typically split into: ~6 samples in the high-force window (e.g., above ~500 N in the spike-layer chart above) ~3 samples low enough to “miss” the spike i.e., ~2/3 fall in the high-force window and ~1/3 miss it. This is why neighboring layers can give different results despite nominally identical geometry. It also explains why the issue is a yield problem rather than a deterministic failure — and why peaks still appear after fixing some, but not all, of the drifting NC lines. Mitigation: Fix the NC Clean up the NC program rather than tune the simulation: Identify the drifting positions (typically a few dozen lines in a layered pocket) and snap the drifting coordinate to a consistent value across layers. This restores a clean floor-to-floor relationship and removes the spurious peaks. Tuning the simulation around the peak would mask a signal that the controller and the cutter both feel in practice. When the NC Cannot Be Modified For mature client products the NC is often a frozen standard, and the floor-contact peaks have to be accepted on the simulation side. Two optimizer-side levers absorb the peaks without modifying the NC: MinFeedPerTooth_mm (API) — a floor on the optimizer's chosen feed-per-tooth. Set it to a scaled fraction of the original feed so the optimizer cannot slow further at a single-revolution spike: MachiningStepBuilt += (preStep, curStep) => { curStep.UpdateNcOptOption(opt => { opt.MinFeedPerTooth_mm = FeedPerTooth_mm * scale; }); }; OptYieldingUtilizationFactor (API) — raise the acceptance threshold for the yield-stress ratio based on the observed stable extreme (e.g., if 150 % is routinely tolerated, set 1.5). See Tuning Peak Tolerance for the full set of per-metric factors and which can be relaxed. Prefer these over modifying cutting coefficients to suppress peaks. The coefficients describe material behaviour; tuning them away from physical values masks the real signal for every downstream calculation (force, moment, wear, thermal). Note The current API does not filter single-revolution spikes out of the optimization basis. If a client policy requires excluding such spikes, apply the levers above at the MachiningStepBuilt (API) callback so per-step settings can be overridden without disturbing the global option. See Also Probabilistic Peak & Cutter Crack — The general statement of the probabilistic peak effect this section describes Corner Feedrate Behavior — Force-peak interaction with controller deceleration at corners Smart Holder Training — Smart tool holder measurement that confirms sub-micron sensitivity Relief Face Avoidance — Related geometry sensitivity on the relief side"
  },
  "technique/machine-capability/index.html": {
    "href": "technique/machine-capability/index.html",
    "title": "Machine Capability | HiAPI-C# 2025",
    "summary": "Machine Capability What the machine tool in the loop can actually deliver, and what happens when a cut asks for more than that. Every ceiling here belongs to the equipment executing the cut, and none of them is visible in the NC program. Ordered by what the ceiling belongs to — the spindle first, then the controller and the NC toolchain feeding it. Spindle Spindle Capability — Duration-keyed boundary curves, the thermal envelope, and the denominators behind the four torque and power ratios Spindle Power Evaluation — Empirical validation of the simulated spindle power against measured Fanuc ServoGuide TCMD data Controller and NC Toolchain CAM Floating-Point Drift — Sub-micron layer-to-layer drift in CAM output meeting a genuinely sub-micron floor-contact sensitivity, and what to do when the NC cannot be changed Condition of the Machine Itself Machine Condition and Safety Factors — Why the results hold only while every ratio stays under 100%, and how a worn machine is described to the optimizer See Also Milling Physics — the physics of the cut that runs into these ceilings NC Optimization — what the optimizer does with these ceilings once it knows them Simulation Performance — the other machine in the loop: what the workstation running the simulation can deliver Validation — the measurements these ceilings were calibrated and checked against"
  },
  "technique/machine-capability/machine-condition.html": {
    "href": "technique/machine-capability/machine-condition.html",
    "title": "Machine Condition and Safety Factors | HiAPI-C# 2025",
    "summary": "Machine Condition and Safety Factors Two machines of the same model, one maintained and one not, do not accept the same NC program. The simulation models the cut, not the wear state of the machine running it, so the machine's condition enters through the safety factors — and setting them honestly is the difference between an optimized program that runs and one that only runs in simulation. The Simulation Is Valid Only Under Stable Machining Every availability ratio HiNC reports — yield stress, spindle torque, spindle power, thermal yield — is a fraction of what the cut is allowed to demand. The results describe reality only while all of them stay under 100%. Above that the machine is no longer doing what the model says it is doing: the spindle droops, the feed per tooth rises, and the divergence grows rather than staying proportional. Reading those ratios, and what each one means at 100%, is Evaluating Process Machinability. Safety Factors Are Where the Machine's Condition Goes HiNC exposes a safety factor per limiting quantity — spindle power, spindle torque, thermal yield — and they feed straight into the optimizer's output. They are not decoration: raising a factor lowers the feed the optimizer is willing to assign, across the whole program. Use them to describe the machine you actually have. A machine in poor condition should be given larger factors, or a lower preferred cutting force, so that the optimized program leaves it more headroom. The same program optimized for a well-maintained machine will be faster, and will be the wrong program for the worn one. See Also Spindle Capability — the curves the power and torque factors are applied to Chatter, and What the Simulation Does About It — the failure mode the force ceiling exists to avoid, and the two cases it does not cover Cutting Force and Torque Validation — a worked maximum feed rate, and where the safety factor enters it"
  },
  "technique/machine-capability/spindle-capability.html": {
    "href": "technique/machine-capability/spindle-capability.html",
    "title": "Spindle Capability | HiAPI-C# 2025",
    "summary": "Spindle Capability SpindleCapability (API) describes the energy, torque, power, and thermal envelope of a machine spindle. It is loaded as XML (.SpindleCapability files under Resource/SpindleCapability/) and lives on SpindleCapability (API) as part of the project equipment. This page explains what the model represents physically and how the per-step ratios on a machining step are derived. For editing values interactively, see Spindle Capability Page. For empirical validation of the resulting power numbers against Fanuc ServoGuide, see Spindle Power Evaluation. Boundary curves: continuous vs instantaneous A typical spindle datasheet chart (FANUC aT12/12000i, shipped as FANUC-aT12-12000i.SpindleCapability): torque (N-m) and power (kW) plotted against spindle speed. The S1 Cont. curves are the continuous boundary; the S3 60% curves are a short-duration rating. HiNC stores exactly these curves, keyed by workable duration. The capability stores two dictionaries keyed by workable duration (in minutes), mapping spindle speed to the maximum power or torque the spindle can deliver for that duration: WorkableDurationToSpindleSpeedPowerContoursDictionary_min_cycleDs_kW (API) WorkableDurationToSpindleSpeedTorqueContoursDictionary_min_cycleDs_Nm (API) Two duration keys are special: PositiveInfinity — the continuous boundary. The spindle can run at any (speed, value) point on this curve forever without overheating. Industry usage often calls this the S1 rating. The smallest finite key (e.g. 15) — the instantaneous boundary. The spindle can run at any (speed, value) point on this curve only for that workable duration before the temperature ceiling is reached. A capability typically also has intermediate keys (e.g. 60 minutes) which document the spindle's published rating curve. Note Why duration-keyed and not just two curves? The duration key serves two roles. The contour values give peak load capability (used by the ratio computation, see below). The duration values implicitly encode the thermal time constants (used by the thermal envelope, see further below). One family of curves drives both. If GearShiftSpindleSpeed_rpm (API) is set, each contour is treated as two segments split at that speed; only the segment for the current spindle speed is used for interpolation. Outside the segment, interpolation uses nearest-neighbour clamping rather than extrapolation. How the four ratios are computed For every machining step where the spindle speed changes, SpindleSpeedCache (API) interpolates each of the four contour-based curves at the current spindle speed and stores four scalar boundaries: Boundary (denominator) Source contour MinInsistentRatioSpindleTorqueBoundary_Nm smallest-key entry of the torque dictionary, interpolated at current rpm InfInsistentRatioSpindleTorqueBoundary_Nm ∞-key entry of the torque dictionary, interpolated at current rpm MinInsistentRatioSpindlePowerBoundary_W smallest-key entry of the power dictionary, interpolated at current rpm InfInsistentRatioSpindlePowerBoundary_W ∞-key entry of the power dictionary, interpolated at current rpm The four MachiningStep ratios are then divisions: \\[ \\begin{aligned} \\text{MaxSpindleTorqueRatio} &= \\frac{\\text{MaxAxialTorque\\_Nm}}{\\text{MinInsistentRatioSpindleTorqueBoundary\\_Nm}} \\\\[6pt] \\text{ContinueSpindleTorqueRatio} &= \\frac{\\text{MaxAxialTorque\\_Nm}}{\\text{InfInsistentRatioSpindleTorqueBoundary\\_Nm}} \\\\[6pt] \\text{MaxSpindlePowerRatio} &= \\frac{\\text{inputPower\\_W}}{\\text{MinInsistentRatioSpindlePowerBoundary\\_W}} \\\\[6pt] \\text{ContinueSpindlePowerRatio} &= \\frac{\\text{inputPower\\_W}}{\\text{InfInsistentRatioSpindlePowerBoundary\\_W}} \\end{aligned} \\] Because the continuous boundary is always lower than (or equal to) the short-duration boundary, the corresponding Continue- ratio is always greater than (or equal to) its Max- counterpart for the same load: A Max- ratio above 100% means the spindle is overdriven instantaneously and will trip thermal protection within the rated short duration. This is the criterion MaxSpindleTorqueRatio (API) and MaxSpindlePowerRatio (API) use to flag tool breakage on Process Machinability. A Continue- ratio above 100% means the spindle cannot sustain this load forever — short bursts may still be safe. Useful for pacing long operations rather than predicting immediate failure. Input power vs output power The power numerator above is input power (energy entering the spindle), not output power (energy reaching the cutting end). They are related by the spindle's energy efficiency: \\(\\text{inputPower\\_W} = \\frac{\\text{AbsAxialPower\\_W}}{\\text{EnergyEfficiency}}\\) — where EnergyEfficiency is EnergyEfficiency (API) and AbsAxialPower_W is what the cutting actually demands. The lost fraction \\((1 - \\text{EnergyEfficiency})\\) becomes heat that the thermal envelope has to dissipate. Spindle Power Evaluation documents the empirical justification for this conversion against measured Fanuc ServoGuide TCMD data. Dry-run idle power Even when the cutter is in air, a rotating spindle dissipates power as bearing friction and aerodynamic windage. HiNC models this as a sum of a linear-in-rpm term (bearing friction) and a higher-order term (windage), parameterised by: DryRunFrictionPowerCoefficient_mWdrpm (API) — friction term coefficient DryRunWindagePowerCoefficient_pWdrpm3 (API) — windage term coefficient The friction term dominates at low rpm; the windage term takes over at high rpm. The thermal envelope (next section) uses the larger of the dry-run idle power and the cutting-induced heat, so the spindle keeps warming up even during air moves. Thermal envelope The same SpindleCapability also drives a thermal model of the spindle body. You do not set heat capacity or convection directly — the thermal model is auto-calibrated from your existing inputs. The continuous (∞-key) curve plus WorkingTemperatureUpperBoundary_C (API) together determine how fast the spindle dumps heat at steady state. Physically: the continuous rating is, by definition, the load the spindle can hold forever without exceeding the working-temperature ceiling — so HiNC infers the steady-state heat-loss capacity from this constraint. The shortest-duration curve plus its duration key together determine how much heat the spindle can absorb before reaching the ceiling. Physically: the short-duration rating is, by definition, the load that brings the spindle to the ceiling exactly within that workable time — so HiNC infers the body's effective thermal mass from this constraint. What this means for you: refining the contour data (more accurate (speed, power/torque) points, better matched duration keys) automatically improves both load-capacity prediction and thermal-response speed. There is no separate thermal parameter to tune. Per-step temperature outputs At each step the body temperature evolves under whatever heat input is currently applied (cutting losses or dry-run, whichever is larger), approaching the steady-state temperature implied by that heat input. The two outputs published per step are: SpindleTemperature_C (API) — current body temperature SpindleWorkingTemperatureRatio (API) — body temperature normalised so that ambient is 0 and the working-temperature ceiling is 1. A value approaching 1.0 means the spindle is near its thermal limit. Note SpindleWorkingTemperatureRatio describes the spindle housing as a whole. It is not the same as the cutter-edge thermal failure tracked by ThermalYieldRatio in Process Machinability, which is a localized cutting-edge phenomenon. Editing and file IO Capabilities are persisted as XML (.SpindleCapability files). Three pre-built spindles ship in Resource/SpindleCapability/: FANUC-aT12-12000i.SpindleCapability TMV-720A-STD-8000RPM.SpindleCapability VP-8--Fanuc-10000RPM.SpindleCapability To edit values interactively, see Spindle Capability Page. See Also Process Machinability — uses MaxSpindleTorqueRatio / MaxSpindlePowerRatio for tool-breakage prediction Spindle Power Evaluation — empirical validation of HiNC spindle power against Fanuc ServoGuide measurements Step Field Reference — where the spindle power and torque ratios surface, step by step Spindle Capability Page — UI editor walkthrough Project Data Checklist — what to collect from the machine owner, the speed-power-torque curve included CPU Usage During Simulation — the workstation-side throughput ceiling, alongside this spindle-side one Machine Condition and Safety Factors — the factors applied to these curves, and why a worn machine needs larger ones Spindle Capability Setup — entering these curves in the application, and the stand-in a project without them inherits"
  },
  "technique/machine-capability/spindle-power-evaluation.html": {
    "href": "technique/machine-capability/spindle-power-evaluation.html",
    "title": "Spindle Power Evaluation | HiAPI-C# 2025",
    "summary": "Spindle Power Evaluation For the spindle capability model itself (boundary curves, thermal envelope, and the four torque/power ratios), see Spindle Capability. This page focuses on empirical validation of HiNC's spindle-power evaluation against measured data. The role of spindle power for energy cost of Milling The energy distribution can be referenced from Heidenhain's published measurements1. The total machine power splits into two main flows: External processing — Cooling lubricant and Compressed air, typically supplied by facility infrastructure. Electrical power of the machine — The machine's own electrical consumption, further split into Auxiliary components and CNC control (which contains Spindle and Feed drives). Note Case A: Mean power requirement for manufacturing a housing part — Roughing (13 kW) sankey-beta Total power (13 kW),External processing,6.4 External processing,Cooling lubricant,5.1 External processing,Compressed air,1.3 Total power (13 kW),Electrical power of the machine,6.6 Electrical power of the machine,Auxiliary components,3.1 Electrical power of the machine,CNC control,3.5 CNC control,Spindle,3.25 CNC control,Feed drives,0.25 Note Case A: Mean power requirement for manufacturing a housing part — Finishing (7.4 kW) sankey-beta Total power (7.4 kW),External processing,2.8 External processing,Cooling lubricant,1.5 External processing,Compressed air,1.3 Total power (7.4 kW),Electrical power of the machine,4.6 Electrical power of the machine,Auxiliary components,2.8 Electrical power of the machine,CNC control,1.8 CNC control,Spindle,1.55 CNC control,Feed drives,0.25 Note Case B: Mean power consumption of the drives during rough facing Face-milling cutter D = 60 mm, speed 4 100 rpm, infeed depth 4 mm. xychart-beta title \"Mean power consumption of the drives (kW)\" x-axis [\"Spindle\", \"Feed axes\"] y-axis \"Mean power (kW)\" 0 --> 20 bar [18.5, 0.3] In Case A roughing, the workpiece material seems like Al6061. CNC control (Spindle + Feed drives) takes about 27% of the total power (3.5 / 13 ≈ 26.9%). From HiNC spindle power evaluation: Milling S45C cost 200% energy compare to Al6061T6. Milling Inconel718 cost 800% energy compare to Al6061T6 i.e., Spindle power of milling S45C occupies 42% of total power. Spindle power of milling Inconel718 occupies 75% of total power. Conclusion: Spindle Power matters for not easy-working materials for computing the energy cost of milling. Verification of HiNC Spindle Power Evaluation HiNC Spindle Power Evaluation is verified by comparison of the gathering Data based on the following setting. Setting Machine Tool: YCM NDV102A Max Spindle Power: 22.4 kW Controller: Fanuc 31i-Model A Sampling: 1ms Total Spindle Expended Energy: 0.412 kWh The total spindle expended energy is rearranged from Fanuc ServoGuide TCMD data. Work Time: 8min 30s Comparison The following figures are spindle power based on Controller and the spindle power evaluated by HiNC. Note The spindle power by Fanuc ServoGuide TCMD(%) * MaxSpindlePower Note The evaluated spindle power by HiNC Milling Power * Energy Conversion Efficiency (here is 0.4) See Also Spindle Capability — the model these measurements validate Data summarized from Heidenhain, Technical Information: Aspects of Energy Efficiency in Machine Tools, November 2010.↩"
  },
  "technique/measurement/index.html": {
    "href": "technique/measurement/index.html",
    "title": "Measurement | HiAPI-C# 2025",
    "summary": "Measurement How a physical quantity gets from a real cutter or a real cut into the model. These are protocols rather than theory: follow them and the simulation is fed a measured number instead of a default. Ordered from the cutter on the bench, through the instrument that watches it, to the cutter in the cut and the experiment that has to be designed before it. Radial Angle Measurement — Reading the radial rake and radial relief angles off a cutting-plane scan Smart Tool Holder — The moment arm and installation angle that decide whether the holder's torque is scaled right at all Smart Holder Training — The three cut shapes and the conditions that let a smart tool holder train milling coefficients Designing a Training Cut Set — The two degeneracies that leave a coefficient unrecoverable whatever the data quality, and the helix and feed spread that remove them See Also Milling Physics — the model these measurements feed"
  },
  "technique/measurement/radial-angle-measurement.html": {
    "href": "technique/measurement/radial-angle-measurement.html",
    "title": "Radial Rake Angle and Radial Relief Angle Measurement on the Cutting Plane | HiAPI-C# 2025",
    "summary": "Radial Rake Angle and Radial Relief Angle Measurement on the Cutting Plane The method for measuring angles on the tool cutting plane scan is illustrated below: Radial Rake Angle (α) Sweep along the tool rotation direction to find the trailing point A of the cutting edge Connect point A to the center O The angle ∠OAA' between line OA and the first polyline endpoint A' on the cutting side of the edge is the rake angle α Radial Relief Angle (β) Find the contact point B between the tool and the envelope circle Construct the tangent line Lt to the envelope circle at point B BB' is the first line segment on the relief side of the tool Pick an arbitrary point B'' on Lt in the relief direction The angle ∠B'BB'' between BB' and Lt is the relief angle β See Also Relief Face Avoidance — the minimum relief angle the measured β has to clear Cutter Geometry — the cutter description these angles are part of"
  },
  "technique/measurement/smart-holder-training.html": {
    "href": "technique/measurement/smart-holder-training.html",
    "title": "Smart Tool Holder Coefficient Training | HiAPI-C# 2025",
    "summary": "Smart Tool Holder Coefficient Training By cutting the following shapes and collecting three-direction torques with a smart tool holder, you can train milling coefficients through HiNC projects. Overview T1 End mill D10 4 flutes T2 Drill bit, diameter unrestricted Click to download NC code. Note Adjusting Machining Method Speed and feed can be changed according to material conditions, but feed per tooth must be in multiples. Slower spindle speed allows the smart tool holder to collect more data per unit time. The wall thickness between the two slots in Shape I needs to be thin enough so that Shape II cutting is discontinuous per revolution. Shape I Shape I consists of three red slots, which are preparatory shapes, no need to collect smart tool holder data. ae10; ap1; S1500; F600 Shape II Shape II penetrates through the thin walls between the three red slots, need to collect smart tool holder data. lineA: T1; ap1; S50; F20 (frt0.1) lineB: T1; ap1; S50; F10 (frt0.05) Shape III Shape III is drilling, need to collect smart tool holder data. drillA: T2; dp4; S50; F20 drillB: T2; dp4; S50; F10 See Also Designing a Training Cut Set — what a set of passes has to span before the coefficients are recoverable at all Smart Tool Holder — the moment arm and installation angle a training run assumes are already right CAM Floating-Point Drift — a measurement error source to rule out before trusting a training run Milling Physics Coordinates — the spindle-rotation frame the holder's torques are reported in"
  },
  "technique/measurement/smart-tool-holder.html": {
    "href": "technique/measurement/smart-tool-holder.html",
    "title": "Smart Tool Holder | HiAPI-C# 2025",
    "summary": "Smart Tool Holder A smart tool holder is a machine tool accessory equipped with sensors that can monitor force and torque data in real time during machining. To ensure simulation accuracy, the following parameters must be configured correctly: Sensor Configuration Moment Arm Height The sensor height setting has a significant impact on simulation accuracy This height defines the moment arm distance for the torque measured by the sensor If not set correctly, a constant scaling error will appear in the torque calculation Coordinate System Alignment Basic Principle The cutting edge should be aligned with the sensor's X-axis Ensure the sensor XY coordinate system is consistent with the simulation XY coordinate system The impact of coordinate system misalignment is relatively smaller compared to the moment arm setting Installation Angle Adjustment If perfect alignment is not possible, measure the offset angle Enter the measured angle in the “Installation Angle” field The maximum possible deviation is 45 degrees Factors Affecting Accuracy Coordinate Transformation Effects An installation angle deviation can cause up to a √2 factor difference in values This difference is inherently a result of coordinate transformation, not a measurement accuracy issue Even with the same smart tool holder, different installation angles will produce different measurement data Best Practices Prioritize accurate moment arm height configuration Align the cutting edge with the sensor X-axis as closely as possible If perfect alignment is not achievable, always measure and set the correct installation angle Only with these parameters correctly configured will the simulated micro-waveforms match the actual sensor measurements. See Also Smart Holder Training — the cut shapes and conditions that turn a correctly configured holder into trained milling coefficients Milling Physics Coordinates — the frame the holder's forces and torques are reported in Cutter — where the holder's settings are entered in the application"
  },
  "technique/measurement/training-cut-set-design.html": {
    "href": "technique/measurement/training-cut-set-design.html",
    "title": "Designing a Training Cut Set | HiAPI-C# 2025",
    "summary": "Designing a Training Cut Set Training recovers the six milling coefficients by fitting simulated force against measured force over a set of passes. Whether a given set of cutters and passes can determine those coefficients at all is a property of the design rather than of the data quality: two specific degeneracies leave a coefficient unrecoverable however clean the samples are. Each has its own fix, and neither fix substitutes for the other. The Two Degeneracies What goes wrong How it shows up in the result What removes it The bending-moment plane null. In rotation-averaged Mx/My one particular combination of the edge and normal shear coefficients is exactly unobservable Shear coefficients come back orders of magnitude too large, and their signs flip between runs on the same data Helix diversity — at least two clearly different helix angles among the cutters trained together Slope–intercept collinearity between the shear and ploughing coefficients, which enter the fit as the slope and the intercept of the same line The correlation still looks good. Shear comes back low by roughly a tenth, ploughing high by around a half A spread of feed per tooth across the passes — a range of chip loads, not a range of depths A set that fixes one and not the other still fails, and it fails in the manner of the one left unfixed. Both are properties of the cut set as a whole, so both are decided before any metal is cut. Why the Helix Angle Is the Lever The unobservable direction is a combination of the edge and normal shear coefficients weighted by the cosine and sine of the helix angle. Changing the helix angle does not remove that direction — it rotates it. Two helix angles far enough apart therefore give two different null directions whose only common point is zero, so the pooled fit has no null at all, and the edge coefficient becomes identifiable from the measurement alone: no torque channel, no prior value, no externally supplied phase. A single helix angle of zero is the worst case, and misleadingly so, because it aligns the null exactly with the edge-coefficient axis. A cut set built that way returns an edge coefficient that is null-space fill rather than a value the data demands, while the normal coefficient beside it comes out as the most accurate number on the page. Important At a single helix angle the individual edge and normal shear values are not meaningful on their own, even when the correlation coefficient is high. A training run is judged by the force it reproduces over time — see Cutting Force and Torque — not by the magnitude of any one coefficient. Flute Count Is Not a Lever Adding more passes with the same symmetric multi-flute cutter buys nothing, at any feed. That sample subspace is degenerate, and more of it stays degenerate: a set made only of symmetric four-flute passes cannot derive its own cutter phase, and the fit collapses rather than degrading. What buys identifiability is spread — in helix angle, and in feed per tooth. Symmetric off-the-shelf cutters are nonetheless sufficient. Custom single-flute grinding is not required for either fix; a pair of stock two-flute cutters ground at different helix angles carries the same identifiability, and is what a shop can actually obtain. Engagement: Side Cuts Rather Than Slots The useful excitation comes from passes whose radial engagement is small enough that at most one helix flute is in contact at a time — the engagement arc narrower than the angular pitch between flutes. A full slot holds several flutes in the cut at once and averages away the very variation the fit needs. Stepping a shallow side cut along the edge of the stock produces a set where no pass is ever a slot. Adding depth of cut is not a substitute. Depth moves the load without changing the chip load, so it does nothing for the slope–intercept collinearity that the feed-per-tooth spread exists to break. See Also Smart Holder Training — the shipped cut shapes these constraints apply to Cutter Geometry — where the helix angle this design turns on is described and entered"
  },
  "technique/mechanism/assembly-anchors.html": {
    "href": "technique/mechanism/assembly-anchors.html",
    "title": "Assembly Anchors | HiAPI-C# 2025",
    "summary": "Assembly Anchors How the parts of a machining scene are held together. Assembly in HiNC is not a placement step but a statement of coincidence: two named anchors are declared equal, and everything they belong to moves so that they are. The buckle anchors below are the joints the machine, fixture, workpiece and tool are assembled at. Ordered from what an anchor is, to the two chains built out of them. What an Anchor Is Anchors are used for assembly purposes. When anchors between geometries coincide, assembly is completed. Strictly speaking, an Anchor is not a point, but a coordinate system. For two coordinate systems to be equal, their origins must coincide and their rotation directions must be the same. Note Anchor Assembly Example As shown in the figure below, there are two components, each with two anchors, {AnchorA,AnchorB} and {AnchorC,AnchorD} respectively. The two components are assembled by making AnchorB and AnchorC coincide. Worktable Anchor and Workpiece Anchor The machine's worktable end is the chain's w anchor. The fixture carries a TableBuckle that meets it, and a WorkpieceBuckle that the workpiece meets — and the workpiece's own anchor there is named FixtureBuckle, so this joint is made of two anchors each named after the other part. Only the machine-to-fixture branch carries an editable transform, which is where the fixture is placed on the table. The fixture-to-workpiece branch carries none: it is plain coincidence. Note Workpiece Fixture Assembly Example Workpiece and fixture are assembled by making the fixture's WorkpieceBuckle and the workpiece's FixtureBuckle coincide. If no fixture is set, both fixture anchors drop out of the chain and the machine's w anchor meets the workpiece's FixtureBuckle directly, carrying the same placement transform. Spindle Anchor and Cutter Anchor The machine's tool end is the chain's t anchor, and it meets the SpindleBuckle of the tool as a whole. Inside that tool the holder sits between spindle and cutter: the tool's SpindleBuckle meets the holder's own SpindleBuckle, and the holder's CutterBuckle meets the cutter's buckle anchor (Buckle). If no holder is set, both holder anchors drop out and the tool's SpindleBuckle meets the cutter's Buckle directly. The machine-side joint is the same either way. See Also Kinematic Topology — the anchor, branch and assembly classes this convention is expressed in Anchor — where these relationships are edited in the application Program Zero Alignment — aligning the program origin onto these anchors"
  },
  "technique/mechanism/chain-code.html": {
    "href": "technique/mechanism/chain-code.html",
    "title": "Machine Chain Code | HiAPI-C# 2025",
    "summary": "Machine Chain Code A machine tool file can carry its kinematic topology as a chain code — a short bracket notation for the same connectivity the mechanism builder produces, meant for hand-editing the XML. It is read and written by CodeXyzabcChain(API), which builds the very same mechanism, so a hand-written code and a builder-drawn structure are interchangeable — with two exceptions on the way back: a mechanism with two components sharing one name, or with an unnamed component that more than one segment would have to mention, cannot be written down as code. The code carries connectivity only. Pivots, exact axis vectors, end-anchor offsets and shapes are properties of the mechanism, and editing the code preserves them for every component whose name is unchanged. The Notation Each segment declares branches from left to right: [O][base][Z][C][w];[O][base][Y][X][B][S][t] [A][B][C] is shorthand for the branches [A][B];[B][C], so a segment is just a path. Words are components. The same word in different segments is the same component, which is how segments join into one structure. The first word of the whole code names the ground anchor. Within a segment each branch runs from the word on its left to the word on its right. Reserved words are the topology keywords: X, Y, Z, A, B, C become motion axes, and w and t become the end anchors. Any other word is a plain component carried along without motion, such as base or S above. A code must name exactly one [w] and one [t]; the six axes are optional, and each may be used at most once. That uniqueness check reads the words without regard to letter case, so it refuses a code naming no table buckle at all — the chain code must contain the table buckle [w] — and a code letting two components claim one role — more than one component claims the table buckle: [w], [W]. A lone [W] satisfies it, one component claiming the role, and builds a component named W; that code is refused further along, by the exact-match end-anchor check below. Spell the keywords exactly — upper case for the axes, lower case for t and w. Everything downstream of the code compares them as written: axis discovery, the default collision pairs, and the end-anchor check a machine file is loaded through. So a mis-cased axis contributes no motion, and a mis-cased end anchor stops the file loading, with a message naming the near miss. [] is an anonymous component. Each occurrence is a separate one, it cannot be referred to from another segment, and it cannot hold a geometric shape — shapes are stored by component name. Declaring the same branch twice is harmless; it states the same connection. A segment with a single word just declares a component, which is how a ground anchor that only receives branches gets named. Any number of segments is allowed, so auxiliary structures can branch off any component: [O][base][Z][C][w];[O][base][Y][X][B][S][t];[base][loader][gripper] Direction and Convergence Branch direction is free. A branch authored towards the ground anchor is simply written that way, as in [Z][O]. A branch belongs to the component farther from the ground anchor, so [O][Y] and [Y][O] both make Y the axis; only the direction differs. Pointing every branch away from the ground anchor remains a readability convention — it makes the structure read outwards, ground → base → motion axes → the t and w end anchors — but the motion, the axis keywords and the default collision pairs all read a branch the same way round regardless. Limbs may meet again. [A][B][D];[A][C][D] gives D two incoming branches. Only one route through such a loop drives the motion, so use it for structure rather than for a second motion path. Axis directions follow the machine-building convention: axes between the ground anchor and w are seeded negative, the others positive. See Also Kinematic Topology — the anchors, branches and assemblies this notation encodes Machine Tool — building the same structure in the mechanism builder, and the keywords both forms share"
  },
  "technique/mechanism/index.html": {
    "href": "technique/mechanism/index.html",
    "title": "HiAPI Mechanics Overview | HiAPI-C# 2025",
    "summary": "Mechanism How a machine tool is assembled out of moving parts, and how HiAPI solves where each part ends up. A kinematic topology describes the motion relationships between components; from it come forward and inverse kinematics, component placement, and the geometry collision detection runs against. Ordered from the structure outwards: the topology first and the shorthand that writes it down, then the matrices that move it, then drawing it. Kinematic Topology — Anchors, branches and assemblies, and how a machine chain is built out of them Machine Chain Code — The bracket notation a machine file can carry its connectivity in, and the keyword spelling everything downstream reads it by Assembly Anchors — What an anchor is, and the buckles the machine, fixture, workpiece and tool are assembled at Handle Transform Matrix by ITransformer — The transform-matrix interface behind every joint, and the implementations covering the common cases Render Topology — Drawing an assembly through its anchors, by anchoring matrix map or by anchored displayee See Also Rendering — the engine that draws what the topology places API Foundations — the geometry types a topology carries, and how an assembly is persisted Hi.Mech.Topo — the generated reference for the namespace Asmb — assemblies Branch — chains"
  },
  "technique/mechanism/render-topology.html": {
    "href": "technique/mechanism/render-topology.html",
    "title": "Render Topology | HiAPI-C# 2025",
    "summary": "Render Topology Read Kinematic Topology Rendering for the prerequisite. A Asmb is a group to render its descendent Anchors. Several ways to render with the topology: Render by Anchoring Matrix Map Render by Anchored Displayee Render by Anchoring Matrix Map Render by Anchored Displayee Inherit IAnchoredDisplayee or apply AnchoredDisplayee to Asmb.Display(). Inherit ITopoDisplayee to manage the object with Asmb and plural anchors . The base logic is also by the anchoring matrix. Here is some class and function wrapping the logic. The sample code shows the topology rendering for a MillingTool editing helper: using Hi.Common; using Hi.Common.Messages; using Hi.Disp; using Hi.Disp.Flag; using Hi.Geom; using Hi.Mech.Topo; using Hi.Milling.Cutters; using Hi.NcMech.Holders; using System; using System.Collections.Generic; namespace Hi.Milling.MillingTools; /// <summary> /// Display host for a milling tool composed of a cutter and a holder. /// </summary> public class MillingToolEditorDisplayee : ITopoDisplayee, IClearCache { /// <summary> /// Gets or sets the delegate that provides the <see cref=\"MillingTool\"/> instance. /// </summary> public Func<MillingTool> MillingToolGetter { get; set; } /// <summary> /// Gets the current <see cref=\"MillingTool\"/> instance. /// </summary> public MillingTool MillingTool => MillingToolGetter?.Invoke(); /// <summary> /// Gets or sets whether to show the cutter. /// </summary> public bool ShowCutter { get; set; } = true; /// <summary> /// Gets or sets whether to show the holder. /// </summary> public bool ShowHolder { get; set; } = true; /// <summary> /// Gets the displayee for the milling cutter. /// </summary> public MillingCutterEditorDisplayee MillingCutterEditorDisplayee { get; } = new MillingCutterEditorDisplayee(); /// <summary> /// Gets the displayee for the holder. /// </summary> public HolderEditorDisplayee HolderEditorDisplayee { get; } = new HolderEditorDisplayee(); /// <inheritdoc/> public List<IAnchoredDisplayee> GetAnchoredDisplayeeList() { var dst = new List<IAnchoredDisplayee>(); var millingTool = MillingTool; if (millingTool == null) return dst; if (ShowCutter) { var cutter = millingTool.Cutter; if (cutter is MillingCutter millingCutter) { //MessageKit.AddMessage($\"MillingTool.Cutter: {MillingTool?.Cutter?.GetHashCode()}\"); MillingCutterEditorDisplayee.MillingCutterSourceFunc = () => MillingTool?.Cutter as MillingCutter; dst.Add(MillingCutterEditorDisplayee); } else if(cutter!=null) dst.Add(cutter); } if (ShowHolder) { HolderEditorDisplayee.Holder = millingTool.Holder; dst.Add(HolderEditorDisplayee); } return dst; } /// <inheritdoc/> public void Display(Bind bind) { bind.PushCoveringPixelMode(); DimensionBar.Display(bind, \"mm\"); bind.ModelMatStack.Pop(); TopoDisplayeeUtil.Display(this, bind); } /// <inheritdoc/> public void ExpandToBox3d(Box3d dst) { TopoDisplayeeUtil.ExpandToBox3d(this, dst); } /// <inheritdoc/> public Asmb GetAsmb() => MillingTool?.Asmb; /// <inheritdoc/> public Anchor GetAnchor() => MillingTool?.GetAnchor(); /// <inheritdoc/> public void ClearCache() { MillingCutterEditorDisplayee?.ClearCache(); } } See Also Kinematic Topology — the assembly and anchors this renders through"
  },
  "technique/mechanism/topology.html": {
    "href": "technique/mechanism/topology.html",
    "title": "Kinematic Topology | HiAPI-C# 2025",
    "summary": "Kinematic Topology The Kinematic Topology is composed of three elemental classes: Anchor, Branch and Asmb. Basic Elements Anchors and Branches Anchor object contains a cartesian coordinate. It can be a mechanical component or a flag. Branch object is a directional link between two Anchor objects. It contains the ITransformer object. The ITransformer object contains a coordinate transformation matrix. As shown in the following sketch: Assembly Management Asmb (Assembly) provides organization and management of Anchors. An Assembly can contain both Anchors and other Assemblies. Key features include: Grouping related Anchors together Managing coordinate transformations Providing display and indexing functions Supporting hierarchical structure Kinematic Chain Example The following figure shows a kinematic chain of a non-orthogonal 5-axis machine tool: Each Anchor represents a component: Axis components: X, Y, Z, B, C Base components: O (base1), O* (base2) Tool components: S (spindle), T (tool body), T* (tool flute) Workpiece: W The relative transform between two Anchors is calculated by multiplying the transform matrices along the Branch. For example, the transform matrix from W to T is: \\[ M_{WT} = M_{CW}^{-1} \\cdot M_{YC}^{-1} \\cdot M_{OY}^{-1} \\cdot M_{OO^*} \\cdot M_{O^*X} \\cdot M_{XZ} \\cdot M_{ZB} \\cdot M_{BS} \\cdot M_{ST} \\] This matrix can be obtained using GetMat4d(IGetAnchor, IGetAnchor). See Also Machine Chain Code — the bracket notation that writes this same connectivity down for hand-editing Assembly Anchors — the four named buckle anchors a machining scene is assembled at Handle Transform Matrix by ITransformer — what sits on each branch and moves it Render Topology — drawing an assembly through the anchors defined here"
  },
  "technique/mechanism/transformers.html": {
    "href": "technique/mechanism/transformers.html",
    "title": "Handle Transform Matrix by ITransformer | HiAPI-C# 2025",
    "summary": "Handle Transform Matrix by ITransformer ITransformer contains a transform matrix and a inverse transform matrix. The matrix is 4x4 column-major matrix, which describe the orientation or movement between 3D coordinates. Several common used interface and class are implemented from ITransformer. The inheritance is shown: IStaticTransformer NoTransform StaticTranslation StaticRotation StaticFreeform GeneralTransform IDynamicTransformer IDynamicRegular DynamicTranslation DynamicRotation DynamicFreeform IStaticTransformer is transformer with constant matrix. NoTransform, StaticTranslation and StaticRotation contains transform matrix of identity, translate and rotate respectively. StaticFreeform contains a arbitrary constant transform matrix. The transform matrix of StaticTranslation is: \\[ M_{StaticTranslate}= \\begin{bmatrix} 1 & 0 & 0 & 0 \\\\\\\\ 0 & 1 & 0 & 0 \\\\\\\\ 0 & 0 & 1 & 0 \\\\\\\\ Trans.x & Trans.y & Trans.z & 1 \\end{bmatrix} \\] The transform matrix of StaticRotation and DynamicRotation is: \\[ M_{Rotate}= \\begin{bmatrix} 1 & 0 & 0 & 0 \\\\\\\\ 0 & 1 & 0 & 0 \\\\\\\\ 0 & 0 & 1 & 0 \\\\\\\\ -Pivot.x & -Pivot.y & -Pivot.z & 1 \\end{bmatrix} \\cdot \\\\\\\\ \\begin{bmatrix} Rot_{00}(axis,rad) & Rot_{01}(axis,rad) & Rot_{02}(axis,rad) & 0 \\\\\\\\ Rot_{10}(axis,rad) & Rot_{11}(axis,rad) & Rot_{12}(axis,rad) & 0 \\\\\\\\ Rot_{20}(axis,rad) & Rot_{21}(axis,rad) & Rot_{22}(axis,rad) & 0 \\\\\\\\ 0 & 0 & 0 & 1 \\end{bmatrix} \\cdot \\\\\\\\ \\begin{bmatrix} 1 & 0 & 0 & 0 \\\\\\\\ 0 & 1 & 0 & 0 \\\\\\\\ 0 & 0 & 1 & 0 \\\\\\\\ Pivot.x & Pivot.y & Pivot.z & 1 \\end{bmatrix} \\] Where Pivot is the position of the rotation axis. Tip Pivot is a point. However, rotation axis is a line. It means that it causes the same matrix no matter how the pivot is moving along the axis. IDynamicTransformer is transformer with inconstant transform matrix. IDynamicRegular has a property Step, implied that the transform matrix is one parameter driven. GetSteps(IDynamicRegular[]) and SetSteps(IDynamicRegular[], double[]) provide easy handle of an array of IDynamicRegular objects. The transform matrix of DynamicTranslation is: \\[ M_{DynamicTranslate}= \\begin{bmatrix} 1 & 0 & 0 & 0 \\\\\\\\ 0 & 1 & 0 & 0 \\\\\\\\ 0 & 0 & 1 & 0 \\\\\\\\ Trans.x \\cdot Step & Trans.y \\cdot Step & Trans.z \\cdot Step & 1 \\end{bmatrix} \\] Note In convention, Trans should be normalized. See Also Kinematic Topology — the anchors and branches these matrices move TransformationGeomControl — the app panel that wraps a geometry in one of these transforms"
  },
  "technique/milling-physics/chatter.html": {
    "href": "technique/milling-physics/chatter.html",
    "title": "Chatter, and What the Simulation Does About It | HiAPI-C# 2025",
    "summary": "Chatter, and What the Simulation Does About It Chatter is self-excited vibration between cutter and workpiece, and it is the one failure mode that a purely geometric look at the toolpath cannot see. HiNC does not predict chatter directly. What it does instead is give the cut a force ceiling that keeps it out of the regime where chatter starts, which covers the cutter side and leaves two other cases to be handled by the operator. Cutter Chatter — Handled by a Force Ceiling Cutter chatter does not begin while the cutting force stays below a threshold. That threshold is a property of the machine, not of the program: a well-maintained machine tolerates a higher force before it chatters, and the same NC on a worn one will chatter earlier. So the lever is the optimizer's preferred cutting force (OptPreferedForce_N). Optimizing to a preferred force holds the cut under a ceiling for its whole length instead of only at the peaks, and if a particular machine still chatters, the answer is a lower preferred force rather than a different toolpath. The value that works is found once per machine and reused. Workpiece Chatter — Not Estimated Workpiece chatter is not estimated. A thin, tall or poorly supported workpiece can vibrate at forces the cutter itself tolerates comfortably, and nothing in the simulation reports it. Where the part is the flexible member, the force ceiling that protects the cutter is not the ceiling that protects the surface. Fixed-Frequency Vibration — Not the Program's Fault Fixed-frequency vibration comes from the machine's own condition — bearings, drives, structure — and is independent of the toolpath. No NC change removes it, and re-optimizing will not help. The practical avoidance is a spindle speed that does not coincide with the machine's harmonic frequencies. Strain Hardening — Why It Is Not Modelled A related question that comes up in the same conversation: milling's depth of cut is far greater than the strain-hardened layer left by the previous pass, so the hardened material is a small fraction of what each tooth removes. The effect on the process is minimal, and the simulation does not model it. See Also Machine Condition and Safety Factors — the machine-side settings that decide how much force the model is allowed to ask for Cutter Adjustment Levers for Force Reduction — what to change when the force has to come down and the feed rate is already as low as it can go"
  },
  "technique/milling-physics/coolant-model.html": {
    "href": "technique/milling-physics/coolant-model.html",
    "title": "Coolant Model | HiAPI-C# 2025",
    "summary": "Coolant Model What the cutting-zone cooling actually does to the simulation. The chosen condition lives on CoolantHeatCondition(API) and is consumed by MillingTemperatureUtil(API) every simulation step, which is why the NC program's own coolant M-codes, not a single setting, decide the coefficient in force at any moment. Ordered from what selects a coefficient, through what the shipped presets set and what each field means, to how the condition is stored. NC program drives the mode The parser reads M07/M08/M09 into CoolantMode(API) and carries it on every MachineMotionStep(API). The FEM picks the effective convection coefficient at run time from that mode. M-code CoolantMode Coefficient source M08 Flood CoolantConvectionCoefficient_Wdm2K (baseline of the chosen type) M07 Mist baseline × MistFloodConvectionRatio M09 Off OffConvectionCoefficient_Wdm2K Before the first M07/M08/M09 the mode is UnDefined; the FEM treats it as Off. For StandardForcedAir (dry cutting) the machine has no liquid circuit, so even M08 only means “air blast on” — its flood baseline is an air-blast coefficient, not a liquid one. What each shipped file sets Each shipped cooling type is also a static preset on CoolantHeatCondition(API) (StandardForcedAir, StandardWaterSolubleCoolant, StandardOilBasedCoolant) — the same pattern as WorkpieceMaterial.Al6061T6; the resource files are generated from them: Preset / file Flood baseline W/(m²·K) Mist ratio Off W/(m²·K) Temperature °C StandardForcedAir 100 0.5 50 25 StandardWaterSolubleCoolant 1 000 0.5 50 25 StandardOilBasedCoolant 300 0.5 50 25 The baselines are engineering defaults from the literature ranges below; when you have dynamometer / thermocouple data for your own system, tune the fields and save your own file instead. API side: ApplyPreset copies a preset in place; MatchStandardPreset maps values back to a preset name. Properties These are the fields shown under Name / Note in the Coolant panel: Property Default Notes CoolantTemperature_C 25 Room temperature inside the enclosure. CoolantConvectionCoefficient_Wdm2K 1 000 Flood baseline. Water-based emulsion ≈ 1 000–3 000, oil ≈ 100–500, forced air ≈ 10–500. MistFloodConvectionRatio 0.5 MQL is roughly half the heat removal of flood. See below. OffConvectionCoefficient_Wdm2K 50 Forced air inside a running enclosure. Natural air ≈ 5–25. Name / Note — From the loaded file / preset; Save As… renames the condition after the file. Legacy projects without a name still work. Why the mist ratio defaults to 0.5 MQL removes much less heat than flood because a thin oil aerosol has a tiny thermal mass; its main value is lubrication plus evaporative cooling, not convection. Industry handbooks place it at roughly half of flood, which gives the conservative default 0.5. Override it when you have dynamometer / thermocouple data for your own MQL system. Note Further reading: UNIST MQL Handbook (source of the “about half” rule), ANEBON mist-vs-flood AISI 1045 tests, Mukesh et al. IEJ May 2023 review on sustainable machining. Use these only to dig deeper — the 0.5 default is already calibrated from them. Coolant files (WorkpieceMaterial pattern) MachiningEquipment.CoolantHeatConditionFile tracks an optional .CoolantHeatCondition side-file, exactly like Workpiece.WorkpieceMaterialFile tracks a material file: No file (default): the condition serializes inline in the .hincproj, byte-compatible with pre-pattern readers. File tracked: the project save externalizes the condition as <CoolantHeatCondition><XmlSource>relPath</XmlSource></CoolantHeatCondition> and (re)writes the side-file. Loading a file installs it in place of the current condition and records the reference (XFactory.GenByFile<CoolantHeatCondition>); a file loaded from the resource folder is copied into the project on the next save (self-contained project root). XML <CoolantHeatCondition> <Name>StandardOilBasedCoolant</Name> <Note>Oil-based cutting fluid (neat oil).</Note> <CoolantTemperature_C>25</CoolantTemperature_C> <CoolantConvectionCoefficient_Wdm2K>300</CoolantConvectionCoefficient_Wdm2K> <MistFloodConvectionRatio>0.5</MistFloodConvectionRatio> <OffConvectionCoefficient_Wdm2K>50</OffConvectionCoefficient_Wdm2K> </CoolantHeatCondition> Name/Note are optional (pre-preset files omit them); omit the last two elements to accept the defaults. The same element saved standalone is the .CoolantHeatCondition file format; inside a .hincproj it may instead appear as the <XmlSource> reference shown above. See Also Coolant — picking a cooling type in the application, which is the whole of the end-user setup Background / Coolant Page — the Control-Tree editor for these values, field by field Process Machinability — the thermal-yield ratio this model's temperatures feed"
  },
  "technique/milling-physics/cutter-adjustment-levers.html": {
    "href": "technique/milling-physics/cutter-adjustment-levers.html",
    "title": "Cutter Adjustment Levers for Force Reduction | HiAPI-C# 2025",
    "summary": "Cutter Adjustment Levers for Force Reduction When force peaks push close to or beyond tool limits, three cutter-side levers reduce peaks without changing the NC or the toolpath. Shorten Tool Overhang The unsupported tool length above the cut multiplies bending stress. A common installation leaves 15 mm or more above the flute start; reducing this exposure toward ~5 mm typically produces a large drop in the yield-stress ratio for the same NC. Process documents may fix the overhang for procedural reasons. If the engineering envelope allows, shortening the overhang is the cheapest mitigation before tuning anything else. Adjust Core Radius Heavy-cut cutters narrow the chip-evacuation flute to thicken the cutter core, raising bending strength. The exact core radius cannot be measured externally; it is an empirical input. The HiNC default is 0.6 (cutter-core radius as a fraction of cutter radius) for 4-flute end mills. If the cutter routinely tolerates yield-stress ratios around 200 % without breakage, the actual core is thicker than the default — raise the value in steps (e.g., 0.7) until the simulated ratio aligns with the observed safety margin. Upgrade Cutter Material The default WC-Co6-800nm is a low-cost grade. Finer-grain or coated grades have higher yielding stress and better thermal tolerance: WC-Co6-TiC-400nm — finer grain with TiC. A reasonable upgrade when the cutter quality is unknown but suspected better than the baseline. For a known cutter, configure the matching material file under Resource/CutterMaterial/ rather than guessing the grade. Before Reaching for the Cutter The cutter-side levers below are for when the cutting parameters have already been tried, because the parameters are cheaper to change. In order: Reduce feed per tooth. The most direct route to lower force, and the one the optimizer itself takes. Reduce depth of cut, or width of cut. Where feed per tooth alone is not enough. Both cut the engagement rather than the chip load per tooth, so both cost more cycle time per unit of force removed. Only when those are exhausted, or when they would cost more cycle time than the job can afford, do the cutter-side levers become the better trade. See Also Evaluating Process Machinability — Reading the yield-stress ratio and the spindle ratios Chatter, and What the Simulation Does About It — the force ceiling that keeps a cut out of the chattering regime Tuning Peak Tolerance — Per-metric utilization factors and when each is safe to relax Tool Life & Wear — Wear modes affected by material grade Cutter Geometry — the full cutter description these three levers are quantities of"
  },
  "technique/milling-physics/cutter-geometry.html": {
    "href": "technique/milling-physics/cutter-geometry.html",
    "title": "Cutter Geometry | HiAPI-C# 2025",
    "summary": "Cutter Geometry How a cutting tool is described to the simulation: what kind of tool it is, how its cutting envelope is expressed, and the individual quantities the force, wear and thermal models read off it. Every value here is a property of the tool rather than of a cut, so it is entered once per tool and reused by every step that tool takes. Ordered from the classification, through the two ways an envelope is expressed, to the quantities that hang off it. Cutter Body Types Cutter body types include: Milling Any tool that machines by rotation is classified as milling in HiNC, including drilling and boring. Freeform Subtraction Cutting tools, EDM (electrical discharge machining) dies. Milling Tool Description Parameters Material: Shank material, cutter body material, (multi-layer) coating material and thickness. Cutting edge rotation envelope: Can use simplified parameters (APT) or a custom ZR table. Simplified (yield-equivalent) edge center rotation envelope: Solid space ratio of the cutting edge rotation envelope. Custom ZR table. Clamping end (non-cutting zone) shape: Custom ZR table. Per-tooth geometry (including side edges and bottom edges): Simplified parameters: Helix angle position, rake angle, relief angle. Custom per-Z value: Helix angle position, rake angle, relief angle, radius length. Hone radius, tool weight, insert weight, and (thermal-equivalent) thickness. For information on measuring rake angle and relief angle, refer to Radial Angle Measurement. APT — the Simplified Edge Envelope APT (Automatically Programmed Tool) is a universal tool definition, and the simplified alternative to a custom ZR table for the cutting-edge rotation envelope. Refer to the APT parameter diagram: Note APT parameter description: D: Diameter Rc: Corner radius Rr: Distance from corner center to tool centerline Rz: Distance from corner center to tool tip horizontal plane Alpha: Angle between horizontal plane and tool tip cone surface Beta: Angle between tool centerline and tool wall cone surface Upper Beam (Clamping End / Shank) Geometry The upper beam is the cutter's shank / body above the flute — the non-cutting, clamping zone. It can be modeled with several geometry types; the two common choices are: Cylindroid — an explicit ZR table. You author every (Z, r) pair, so the shank radius (and any stepped / necked profile) is whatever you type in. This faithfully reproduces a known shank, but every value is data you must supply. Extended Cylinder — a cylinder whose start (bottom) profile is driven by the flute and whose only parameter is the total length. Its radius follows the cutter (flute-top) radius automatically, so it needs no shank measurements — only a length long enough to reach the holder. ⚠ FullLength is the beam's FULL length measured from Z=0 (the cutter tip), so it includes the flute span — it is not the remaining segment from the flute top to the exposed end. It must therefore be larger than the flute height: e.g. flute height 20 mm and 10 mm of shank above it → FullLength = 30, not 10. A value at or below the flute height inverts the beam solid; thermal physics then cannot build its shank shell layers and reports a Cutter-UpperBeam--BelowFluteHeight configuration error at tool change (the web editor rejects such a value outright). Convention — prefer the Extended Cylinder when the shank is not given. Most tool sheets (especially at quoting stage) list only the cutting diameter, corner radius, and stick-out; they do not give a shank diameter or a stepped/necked profile. In that case use the Extended Cylinder: it extends the flute by a length without inventing a radius the data does not support. A hand-authored Cylindroid here would bake a guessed shank radius into the model — and an over-fat guess produces false clearance / collision results, while an over-thin one understates the body. Reserve the Cylindroid (explicit ZR) for tools whose shank or neck profile is actually known or measured — e.g. stepped, necked, or back-tapered shanks where a flute-radius extension would be wrong. Tip: because the Extended Cylinder's radius tracks the flute, set its length comfortably past the exposed cutter height so the beam reaches into the holder with no gap; the overlap is harmless for clearance checks. Relief Angle Setting The relief angle setting in HiNC refers to the primary relief angle. It is used to calculate flank wear width (Flank Wear, VB). Cutter Body Weight Cutter body weight is used for thermal transfer calculations. Solid tools: Enter the weight of the solid tool as the cutter body weight. Indexable tools: Enter the total insert weight as the cutter body weight, excluding the weight of the tool body. Hone Radius The hone radius represents the sharpness of the tool and is the radius at the cutting edge tip. Typical values range from 20 to 50 um. Tools used for machining easy-to-cut materials typically have a smaller hone radius (e.g., Al6061-T6, which can be assumed as 20 um); tools used for difficult-to-cut materials typically have a larger hone radius (e.g., stainless steel, which can be assumed as 50 um). Edge Profile and Edge Grind — Bottom Edge Grind The bottom edge grind needs to be configured when the bottom edge is horizontal or concave, and it affects segments with downward cutting. Drill bits do not require bottom edge grind configuration — only the side edge grind needs to be set. This is because drill bit bottoms are not horizontal or concave. If a custom drill bit has a horizontal or concave bottom, then the bottom edge grind must be configured. Typically, only bull-nose cutters require bottom edge grind configuration. Note that flat end mills usually do not perform downward cutting and should not, but if the process does so, the bottom edge grind must be configured. Insert Cutters — a Worked ZR Table Insert cutters can be modeled in the virtual environment. See the examples below. Z R S.Ang. R.Ang. 0 8 1 3 0.2 8 0.5 3 0.4 8 0 3 0.5 8 0 3 3 8 3 3 6 8 4 3 8 8 4 3 See Also Radial Angle Measurement — how to measure the rake and relief angles entered here Designing a Training Cut Set — why the helix angle entered here decides whether a training run can recover the shear coefficients Cutter-Location (CL) Playback — a CL file's TLDATA feeds this same tool-geometry model Cutter Adjustment Levers — the three of these quantities a process engineer can actually move to cut a force peak Cutter — where a tool carrying this geometry is created and edited in the application"
  },
  "technique/milling-physics/index.html": {
    "href": "technique/milling-physics/index.html",
    "title": "Milling Physics | HiAPI-C# 2025",
    "summary": "Milling Physics What happens where the flute meets the workpiece, and what it does to the cutter. These pages carry the model the simulation implements — the frames the numbers are expressed in, the criteria that decide whether a cut is survivable, and the two ways a cutter is lost: instantly, and slowly. Ordered from what the model is handed, through the frame the numbers live in and instantaneous failure, to long-term wear and the levers that move both. What the Model Is Given Cutter Geometry — How a tool is described to the model: the body types, the APT envelope and the ZR-table alternative, the upper beam, and the hone radius, weight and angles the force, wear and thermal models read Coolant Model — What the cutting-zone cooling does to the temperature model: the coefficient the running program's own M-codes select, the shipped presets, and how a condition is stored Frames Milling Physics Coordinates — The workpiece, tool-running and spindle-rotation frames, and which sensor reports in which Instantaneous Failure Process Machinability — The yield-stress, spindle-torque, spindle-power and thermal-yield ratios, what a value above 100% means for each, and the mesh-quantization ripple that is an artifact rather than a signal Probabilistic Peak & Cutter Crack — Why one narrow angular window of high contact makes an identical cut pass most of the time and crack a flute occasionally Relief Face Avoidance — The minimum relief angle the trochoidal edge path demands, and what happens when the clearance face presses on uncut material Long-Term Loss and What To Change Tool Life & Wear — The wear model, the three quantities it reports, and where flank-wear width stops being a valid measure Cutter Adjustment Levers — Overhang, core radius and material grade: three cutter-side ways to cut a force peak without touching the NC Chatter — The force ceiling that keeps a cut out of the chattering regime, the two chatter cases it does not cover, and why strain hardening is not modelled See Also Machine Capability — the equipment ceilings this physics runs into Measurement — where the coefficients and angles in this model come from Cutter — the application task that creates a tool carrying this geometry NC Optimization — what the optimizer does when a cut fails these criteria Scripting — the per-step values that carry these quantities out of a run Validation — how closely this model has been held against measurement"
  },
  "technique/milling-physics/machinability.html": {
    "href": "technique/milling-physics/machinability.html",
    "title": "Evaluating Process Machinability | HiAPI-C# 2025",
    "summary": "Evaluating Process Machinability The machinability time-series chart can be used to evaluate tool breakage risk during machining. Tool breakage occurs when any of the following exceeds 100% and persists for longer than one simulation step: Yielding Stress Ratio [YieldingStressRatio (API)], Max Spindle Torque Ratio [MaxSpindleTorqueRatio (API)], or Max Spindle Power Ratio [MaxSpindlePowerRatio (API)]. If the value significantly exceeds 100% — roughly speaking, above 200% — tool breakage can occur even without sustained duration. Note: The default simulation uses per-revolution milling mode, where one simulation step equals one spindle revolution. Yielding Stress Ratio is a percentage indicator with the tool material's breakage force as the denominator. The numerator is the simulation step's absolute force MaxAbsForce_N(API). Compared to using the absolute force value directly as a limit, the ratio incorporates tool material mechanics and more accurately reflects the tool's actual safety margin. The optimization target force OptPreferedForce_N(API) represents the desired MaxAbsForce_N after optimization. For small tools, breakage is typically caused by insufficient tool force capacity, and breakage is based on the Yielding Stress Ratio. For small-to-medium tools, breakage is typically caused by insufficient spindle performance, and breakage is based on the Max Spindle Torque Ratio or Max Spindle Power Ratio. When cutting resistance exceeds spindle performance, the machine feed rate remains constant but the spindle speed continuously decreases, causing the feed per tooth to continuously increase, which drives cutting forces to spike until tool breakage or machine stoppage. For the underlying boundary curves and how each ratio's denominator is computed at the current rpm, see Spindle Capability. Note Tool Breakage Solutions Modify the toolpath to reduce cutting width/depth, or use HiNC's optimization feature to adjust feed rates, bringing the Yielding Stress Ratio, Max Spindle Torque Ratio, and Max Spindle Power Ratio below 100%. Ripple on Curved and Tilted Cuts (Mesh Quantization) On a nominally constant-engagement cut that is curved or tilted — arc or helical hole milling, ramping, or 5-axis moves — the Yielding Stress Ratio (and the underlying MaxAbsForce_N(API)) can show a small step-to-step ripple even though the theoretical engagement is steady. This is a discretization artifact, not a bug. Cause. The workpiece is represented by an axis-aligned cubic voxel mesh (see Workpiece Entity Resolution). Orthogonal cubes cannot represent a circle or an inclined face smoothly, so the removed volume and the contact engagement area quantize against the grid from step to step. That quantization shows up as ripple in the per-step peak force, and therefore in the ratio. What helps. A finer MachiningResolution_mm makes the quantization step smaller, so the ripple amplitude shrinks — at the cost of slower geometry removal (see CPU Usage During Simulation). What does not help. Switching to fixed-pace / sweeping motion resolution (FixedPace) does not remove this ripple. The ripple comes from the spatial cubic grid, not from the spacing between steps, so changing the step spacing leaves it essentially unchanged. Getting a smooth curve. There is no built-in filter that smooths step-series curves. If a smooth curve is needed for a report, post-process the exported CSV (WriteStepFiles(API)) yourself — e.g. a moving average. Note that the Yielding Stress Ratio is defined on the per-revolution peak force only (there is no averaged variant); the averaged force fields (Avg…) are inherently smoother when a trend, rather than the breakage peak, is what you need to read. Thermal Plastic Deformation of Cutting Edge If the Thermal Yield Ratio [ThermalYieldRatio (API)] exceeds 100%, thermal plastic deformation of the cutting edge occurs, accelerating wear. Unlike the Yielding Stress Ratio, Max Spindle Torque Ratio, and Max Spindle Power Ratio, this is a long-term indicator — exceeding 100% does not cause immediate effects. Note Thermal Plastic Deformation Solutions After addressing tool breakage issues, reduce the spindle speed to allow sufficient time for the cutting edge to dissipate heat. Note that whether the coolant is properly directed at the cutting edge has a significant impact. If the coolant is not aimed at the cutting edge, it effectively reduces the heat dissipation coefficient. Tool manufacturers typically provide recommended machining conditions, and the Thermal Yield Ratio obtained by simulating under those conditions usually exceeds 100%. This is because the manufacturing formulations of tool materials differ from HiNC's conservatively set default values. If you consider machining conditions with a Thermal Yield Ratio above 100% to be reasonable, you can adjust the thermal properties of the tool material so that the calculated Thermal Yield Ratio approaches 100%. See Also Coolant Model — what decides the convection coefficient behind the thermal-yield ratio Cutter Adjustment Levers — what to change on the cutter when a step is not machinable as programmed Spindle Capability — where the spindle torque and power ratios come from CPU Usage During Simulation — what a finer MachiningResolution_mm costs in simulation time Mesh Resolution — how to choose that value, and the thin-wall geometry a coarse mesh can lose entirely Cutting Force and Torque Validation — how closely the forces behind these ratios agree with measurement Cutting Force Anomaly Cases — two production failures these ratios would have flagged"
  },
  "technique/milling-physics/milling-physics-coordinates.html": {
    "href": "technique/milling-physics/milling-physics-coordinates.html",
    "title": "Milling Physics Coordinate Systems | HiAPI-C# 2025",
    "summary": "Milling Physics Coordinate Systems Physical properties such as milling forces, milling torques, and deformations can be represented in different coordinate systems. Sensor raw data also corresponds to different coordinate systems. When viewing physical simulation data in HiNC, you will often see coordinate system notations. This chapter explains the three coordinate systems shown in the figure below. Note Workpiece Coordinate System Workpiece Coordinate System, abbreviated as [W]. Usually the program origin coordinate system. The workpiece coordinate system is consistent with the dynamometer coordinate system. Tool Running Coordinate System Tool Running Coordinate System, abbreviated as [TR]. Takes the tool running direction excluding tool normal movement as +X, tool normal vector as +Z, and defines +Y by the right-hand rule. For climb milling, +Y direction is away from the wall. The tool running coordinate system is suitable for understanding machining conditions. Spindle Rotation Coordinate System Spindle Rotation Coordinate System, abbreviated as [SR]. The tool running coordinate system rotated around the Z axis by spindle motion angle \\(\\theta\\) becomes the spindle rotation coordinate system. The spindle rotation coordinate system is consistent with the smart tool holder coordinate system, as the smart tool holder sensor rotates with the spindle. See Also Smart Tool Holder — the sensor whose torque is reported in the spindle-rotation frame, and the mounting values that decide its scale Step Field Reference — the per-step outputs whose [W] / [TR] / [SR] marks these frames decode Smart Holder Training — the measurement that reports in the spindle-rotation frame"
  },
  "technique/milling-physics/probabilistic-peak-crack.html": {
    "href": "technique/milling-physics/probabilistic-peak-crack.html",
    "title": "Probabilistic Peak: Why a Cut Passes Most of the Time and Occasionally Cracks the Cutter | HiAPI-C# 2025",
    "summary": "Probabilistic Peak: Why a Cut Passes Most of the Time and Occasionally Cracks the Cutter Left — spindle-moment dartboard. The (Mx, My) moment-vector tip is drawn as a closed locus over one spindle revolution, coloured by the axial moment Mz; the concentric rings are moment magnitude (Nm). For most of the revolution the locus stays near the centre — small flute–workpiece contact length, small moment. One narrow lobe stretches out to the outer rings: the angle where the contact length spikes and produces the large force that can crack the flute. Right — the 3D engagement at that high-load phase, showing the flute deeply engaged with the workpiece. The Mechanism The flute–workpiece contact length is small for most spindle angles and spikes only inside one narrow angular window. The large force — and the crack risk — exists only inside that window. The cutter's flutes are discrete. Whether a cutting flute actually lands inside the narrow high-contact window is a matter of flute phase, not a certainty: High probability — the flutes fall in the wide low-contact region and step over the window. The pass completes safely. Low probability — a flute lands inside the narrow window, takes the full contact length, and sees the large force. The flute can crack. This is why a cut with a clear high-contact window still passes most of the time and only occasionally breaks the cutter, and why nominally identical geometry can pass on one pass and crack on another. It is the same effect documented under Probabilistic Peak Dodging. See Also CAM Floating-Point Drift — a concrete case of the same probabilistic peak effect, triggered by sub-micron floor contact."
  },
  "technique/milling-physics/relief-face-avoidance.html": {
    "href": "technique/milling-physics/relief-face-avoidance.html",
    "title": "Primary Relief Angle Clearance | HiAPI-C# 2025",
    "summary": "Primary Relief Angle Clearance All relief angles discussed in this article refer to the primary relief angle — the relief angle closest to the cutting zone. Also known as the clearance angle. During cutting, the milling cutter edge follows a trochoidal motion, shown as the red trochoid in the figure below. The blue circle is the tool envelope circle. The region inside the red trochoid (toward the center of the envelope circle) is the already-cut area; the region outside the red trochoid is the uncut area. If the relief face falls in that region, it will collide with the uncut material. Therefore, the angle marked RA (abbreviation for Relief Angle) represents the minimum required relief angle. If the actual tool relief angle is smaller than the minimum required relief angle, the clearance face will press against the uncut workpiece, increasing forces on both the tool and the workpiece. This leads to greater tool vibration, workpiece surface springback, a sharp rise in surface roughness, and reduced tool life. Minimum Required Relief Angle Calculation For fixed-axis machining, the minimum required relief angle can be calculated from the feed rate, spindle speed, and tool radius. For simultaneous multi-axis machining, it must be computed in batch for each contact point along the program path. The following outlines the calculation for fixed-axis machining. \\(\\vec r_p = \\left(t\\cdot v-R\\cdot\\sin\\left(t\\cdot w\\right),R-R\\cdot\\cos\\left(t\\cdot w\\right)\\right)\\) \\(\\vec r_b = \\left(a\\cdot v-R\\cdot\\cos\\left(s\\right),R-R\\cdot\\sin\\left(s\\right)\\right)\\) Where: \\(\\vec r_p\\) is the position vector of the red trochoid; \\(\\vec r_b\\) is the position vector of the blue circle; \\(R\\) is the tool radius (mm); \\(w\\) is the spindle speed (rad/s); \\(v\\) is the feed rate (mm/s); \\(t\\) is time; \\(s = t\\cdot w\\); \\(a\\) is a specified time, used as a constant. Let the velocity vectors be \\[ \\vec v_p = \\frac{d\\vec r_p}{dt} , \\vec v_b = \\frac{d\\vec r_b}{ds} \\] The angle between \\(\\vec v_p\\) and \\(\\vec v_b\\) is the minimum required relief angle. See Also CAM Floating-Point Drift — drift in the toolpath that can look like relief-face contact Radial Angle Measurement — how the cutter's actual relief angle is measured"
  },
  "technique/milling-physics/wear.html": {
    "href": "technique/milling-physics/wear.html",
    "title": "Tool Life and Wear | HiAPI-C# 2025",
    "summary": "Tool Life and Wear There are many modes of cutting edge damage, which can be attributed to instantaneous failure modes, including tool breakage and thermal cracking, see this article; while for modes attributed to long-term consumption failure, it is recommended to use flank wear as the target for evaluating tool life . HiNC adopts the wear model1: \\(W(T) = \\frac{k(T) L P}{H(T)}\\) where W is wear amount, k is wear coefficient, L is contact length, P is pressure, H is hardness, T is temperature. HiNC calculates wear including: Crater Wear Flank Wear Width Flank Wear Depth Here crater wear refers to crater wear depth. Flank wear width is most commonly used as an evaluation target in papers because it has measurement standards. In planar motion, tools will wear at the cutting peak first then the flank, so flank wear width can be used to evaluate total wear in laboratory settings. However, if the tool has up and down motion during milling, the flank will experience random collisions before the cutting peak is worn out, in which case flank wear width loses its value for evaluating total wear. The flank wear width calculated by HiNC assumes no random flank collisions and is only applicable to planar cutting. HiNC retains this value for research purposes. See Also Temperature and Wear Validation — this model checked against thermal imaging and a measured wear depth Cutter Adjustment Levers — which cutter parameters to move once wear is the limit Lee, R. S, and J. L Jou. “Application of Numerical Simulation for Wear Analysis of Warm Forging Die.” Journal of Materials Processing Technology, Proceedings of the 6th Asia Pacific Conference on materials Processing, 140, no. 1 (September 22, 2003): 43–48.↩"
  },
  "technique/nc-dialects/controller-heidenhain.html": {
    "href": "technique/nc-dialects/controller-heidenhain.html",
    "title": "Heidenhain Controller Support | HiAPI-C# 2025",
    "summary": "Heidenhain Controller Support Heidenhain programs run on a single controller preset that reads both dialects — TNC klartext (TNC 640 / TNC 530 conversational) and Heidenhain DIN/ISO. There is no separate selection to make: pick Heidenhain as the project's controller and the program is read in whichever dialect it is written in. Coverage is stated in the same three states as General NC Code Support — supported, recognized but not simulated, and not supported. Recognized but not simulated is a deliberate state: the construct is consumed and reported under its own message id, so it can never be silently misread as something else. A PLANE AXIAL B+45 will never be mistaken for a rotary-axis command. Program format Separators are optional Klartext is normally written with spaces between the letter instructions, and that is what the control shows. Some post-processors emit the same program with no separators at all. Both forms parse, and so does the detached feed spelling. Equivalent, all parsed: L X-26.3 Y+43.1 Z+100.3 A-90.0 C+13.123 FQ3 and LX-26.3Y+43.1Z+100.3A-90.0C+13.123FQ3 L X+0 Y+0 R0 FMAX and LX+0Y+0R0FMAX FMAX M03 M08 and FMAXM03M08 F20000 and F 20000 Multi-line blocks A statement broken across lines with the tilde continuation — the usual shape of a CYCL DEF body or a long PLANE statement — is joined back into one block before parsing, so it is read as the single statement it is. Motion Construct Support L Straight-line motion with its axis words. LN Surface-normal block — a straight line carrying the endpoint plus up to two normalized vectors, in the fixed element order X,Y,Z → NX,NY,NZ → TX,TY,TZ. See Vector blocks. FMAX Rapid traverse. CC / C Circular motion — CC sets the pole, C states the end point. DR- is clockwise and DR+ counter-clockwise, the centre always comes from the modal CC rather than from the C block, and an arc that closes on its start point is a full circle. See Arc centres. RL / RR / R0 Radius compensation left / right / off. M91 One-shot machine-coordinate move for that block. M126 / M127 Shortest-path rotary traverse on / off. With neither stated, shortest path is the default. M140 MB+n / M140 MB MAX Tool-axis retract — by n mm, or to the positive Z stroke limit. Without a configured stroke limit, MB MAX reports M140--NoStrokeLimit and is skipped. The statement's own F drives the retract without entering the modal feedrate. STOP Program stop, alongside M00 / M01. CYCL DEF 32 TOLERANCE Path-smoothing tolerance. BLK FORM Recorded as a stock declaration. It does not replace the workpiece configured in the project. Arc centres (CC) A C block never states its own centre. Each in-plane component is resolved from the modal CC section: the CC block's own axis word first, then the same axis of the previous CC, and last the arc's own start point. A CC stating no coordinates is the one spelling that supplies all three at once — it takes the last programmed position, read at the CC block rather than at the arc, and replaces the modal centre instead of inheriting it. That is what makes the manual's own shape work: CC on the centre, a move out to the arc start, then the C block. A centre that lands on the arc's own start point leaves the block with no radius and so no arc geometry: it reports Arc-CircleCenter--OnStartPoint and is degraded to a straight move to the endpoint. One in-plane coordinate is enough to escape that — an arc whose modal chain still leaves the other coordinate to the start point keeps real geometry and plays normally, and is refused only by the optimizer's splition, described under Optimized output. Vector blocks (LN) CAM-generated five-axis programs state the posture as vectors rather than as rotary words. An LN block carries the endpoint plus the surface-normal vector NX/NY/NZ — the 3D tool-compensation direction — and, optionally, the tool vector TX/TY/TZ. HiNC resolves whichever vector governs into the machine's rotary axes and feeds the result through the same RTCP machinery the rotary-word programs use, so there is no second motion path to reason about. Which vector governs follows the control's own rules: Situation Tool axis T present, M128 or FUNCTION TCPM active The T vector — the tool keeps the set orientation. T absent, RTCP active The surface normal N — the tool is held perpendicular to the contour. RTCP inactive The T vector is ignored, exactly as the control ignores it. Reported as Orientation-Vector--IgnoredNoTcpm, with the posture left untouched. RTCP counts as active when the same block turns it on, so a block that both activates RTCP and carries a vector is not skipped. Two limits are worth knowing before trusting the result: The vector is read in the untilted program frame. An LN block under an active PLANE tilt is reported as Orientation-Vector--TiltedFrameAssumed rather than remapped. Compensation along the surface normal (DR2 / 3D-ToolComp) is recognized, not simulated — SurfaceNormal--CompNotSimulated, raised once per run. A vector that is not unit length is normalized and reported (Orientation-Vector--NotNormalized); a zero vector is reported as Orientation-Vector--ZeroVector. Tools TOOL CALL performs the tool change on its own — klartext has no separate M06 trigger. A tool number or a quoted tool name is accepted. Parsed: TOOL CALL 1 Z S5000 TOOL CALL \"1\" Z S5000 TOOL CALL \"B40R\" Z S3000 DL+0.5 The spindle speed S is recorded modally. DL is a length delta — the effective tool height is the tool-table height plus DL. DR is read and recorded but not applied: radius compensation uses the tool-table radius as-is, and the block reports ToolChange--DeltaUnsupported. A tool axis other than Z reports ToolChange--AxisUnsupported. A TOOL CALL whose tool number could not be captured — an unevaluated variable, for example — reports ToolChange--MissingToolId. Datums CYCL DEF 247 sets the datum preset and CYCL DEF 7 is an additive shift on top of it, which is the TNC semantic. The two compose as separate entries in the coordinate chain instead of replacing each other. Parsed: CYCL DEF 247 Q339=+1 CYCL DEF 7.0 DATUM SHIFT CYCL DEF 7.1 X10.123 CYCL DEF 7.2 Y22.223 CYCL DEF 7.3 Z32.97 Q parameters and FN Q, QR, QL and QS parameters are read wherever a value is expected, so FQ1 reaches the feedrate, L X+Q2 reaches the program position and TOOL CALL SQ3 reaches the spindle speed. Q0–Q99 free parameters and QR0–QR499 permanent parameters are held as per-project data and saved with the project. Construct Support FN 0–FN 5 Assignment and arithmetic, including the DIV keyword of FN 4 and the prefix SQRT of FN 5. FN 9–FN 12 Conditional jumps — executed, with a per-label iteration cap so a corrupt or hostile program cannot spin forever. Other FN opcodes (FN 14, FN 16, FN 18 SYSREAD, …) Recognized, not simulated. The statement is claimed and reported, so its target parameter stays empty instead of taking a fabricated value. Parsed: Q1 = 5000 FN0: Q1 = 5000 FN1: Q1 = -Q2 + -5 FN2: Q1 = +10 - +5 FN3: Q2 = +3 * +3 Tilted planes and RTCP Construct Support PLANE SPATIAL Fully composed, including SEQ+ / SEQ-, COORD ROT / TABLE ROT, and the STAY / MOVE / TURN positioning behaviours. PLANE RESET Cancels the tilt. PLANE VECTOR Structurally captured, not simulated. PLANE EULER / POINTS / RELATIV / AXIAL / PROJECTED Recognized, not simulated — consumed and reported as HeidenhainPlane--Unsupported, with the previous tilt retained. FUNCTION TCPM Supported, read as the default REFPNT TIP-TIP. A center-referenced reference point (REFPNT CNT-CNT / TIP-CENTER) is recognized, not simulated: the coordinates are still taken as tip-to-tip, so CNT-referenced CAM output simulates offset by the ball radius along the tool axis. Reported as Orientation-RefPoint--CntNotSimulated. M128 / M129 Tool centre point control on / off — real RTCP, the Heidenhain sibling of ISO G43.4 and Siemens TRAORI. Parsed: PLANE SPATIAL SPA-60.3 SPB+0 SPC-19.88 STAY SEQ- TABLE ROT PLANE RESET STAY Cycles and calls CYCL DEF 2xx bodies are read with their Q parameters mirrored into the block. Cycles 200, 232, 251, 252 and 253 are mapped onto the shared drilling machinery and simulated; the mapping follows the cycle's own Q values, so a Q202 peck increment routes to peck drilling and a Q211 bottom dwell to dwell drilling. A CYCL DEF body that is not one of those is recognized, not simulated — reported as HeidenhainCycl--Unsupported. CYCL CALL and CYCL CALL POS fire the cycle once; M99 fires once and M89 arms modal firing. CALL LBL n inlines the label body up to LBL 0; CALL LBL n REP m repeats that section m times. CALL PGM resolves the called program by file name. Mirror image in both spellings — the klartext CYCL DEF 8 form and the DIN/ISO G28 form. DIN/ISO dialect The same preset, with nothing to switch. % tape header and N block numbers. T plus M06 tool change. Arc centres I / J / K are absolute pole coordinates, not incremental offsets from the start point. This is the Heidenhain reading, and the pole carries forward modally. The ISO label family — G98 L<n> definitions, and the head-anchored L<n>,<m> call whose comma count maps onto the repeat count. G247 Q339 stamps the same datum preset as CYCL DEF 247. G54 with axis words is read as a datum-shift declaration. G70 / G71 units. Warning G28 on Heidenhain is MIRROR IMAGE, not a reference-point return. The Fanuc reading of G28 is deliberately absent from the Heidenhain preset. Select the Heidenhain controller for a Heidenhain DIN/ISO file — read as Fanuc, every mirror statement becomes a home move. Optimized output An optimized program is patched into the source text block by block rather than re-emitted, so it comes back in the dialect it was written in, and two rules keep the result a program a TNC will accept. A feed the optimizer writes into a block that carried none lands after the coordinate words and after DR+ / DR- and RL / RR / R0, so the element order the control expects — coordinates, rotation direction, radius compensation, F, M — holds on the patched block: L X+10 Y+20 RL comes back as L X+10 Y+20 RL F500. A block that already states an F keeps that word where it stands, and only its number changes — unless the feed is FMAX, FAUTO or a Q parameter, which patch mode refuses to rewrite: the block is left exactly as written, reporting Writeback-Patch--KeywordValue or Writeback-Patch--VariableValue. The optimizer's embedded source note is written in the klartext comment grammar — a ; comment, never a parenthesized one, because a TNC reads parentheses as code: 120 L X+35 Y-11.7 R0 F500 ;src(LineNo: 140, StepIndex: 256) Re-interpolation itself is not refused for being klartext. A C … DR± arc splits like any other when the modal CC chain supplies both in-plane centre coordinates: no centre words are rebuilt, and each fragment carries the block's own words with its own endpoint and feed, around the one CC line they all share unchanged. The arc that is optimized whole instead is the one whose modal chain left an in-plane coordinate unstated — no CC ever gave it, so the arc's own start point supplies it, and every fragment would re-derive that centre from its own start. Such pieces are optimized as whole lines under NcOpt--SplitionStartPointCenterUnsupported, raised once per run. Not supported TOOL DEF, FK free-contour programming, SL cycles, PATTERN DEF, and TCH PROBE. These are left unconsumed, and the block that carried them reports Parsing--Unconsumed naming the words. Machine-specific M-codes that are not part of the Heidenhain vocabulary above are declared on the machine rather than built in — see the M-code note on General NC Code Support. See Also General NC Code Support — Fanuc, Syntec, Mazak and Siemens SINUMERIK. NC Parsing Engine — the pipeline behind these constructs, the brand-by-brand support matrix in one table, and how a machine's own vocabulary is added without changing HiNC."
  },
  "technique/nc-dialects/controller-iso.html": {
    "href": "technique/nc-dialects/controller-iso.html",
    "title": "General NC Code Support | HiAPI-C# 2025",
    "summary": "General NC Code Support The vocabulary HiNC interprets is decided by the controller brand selected for the project. This page covers the ISO-family presets — Fanuc, Syntec and Mazak — and Siemens SINUMERIK. Heidenhain is a different language and has its own page: Heidenhain Support. How to read this page Coverage is stated in three states. State What happens when the construct appears in your program Supported interpreted, and its effect is simulated. Recognized, not simulated consumed on purpose and reported under its own message id. The block keeps running and the construct's effect does not apply — but it can never be silently misread as something else. Not supported the words are left over, and the block reports Parsing--Unconsumed naming them. Tip The message list a run produces is the coverage report for your program. Every word the interpreter could not use is named on the block that carried it, so you never have to infer coverage from the simulated result. An unknown code does not stop the run — it is reported and skipped. ISO core Fanuc, Syntec and Mazak share the vocabulary below. Siemens spells most of it the same way and adds its own for the rest — see Siemens SINUMERIK. Motion Code Meaning G00 Rapid positioning. G01 Linear interpolation at the programmed feedrate. G02 / G03 Circular interpolation, clockwise / counter-clockwise. The centre may be given as I / J / K offsets or as a radius R. G04 Dwell. X / U are seconds, P is milliseconds, S is spindle revolutions. Both the G4 and G04 spellings are read. G28 Reference-point (home) return through an intermediate point. G53 One-shot machine-coordinate move — work offsets are bypassed for that block only. Plane, units and positioning mode Code Meaning G17 / G18 / G19 Plane selection — XY / ZX / YZ. Arcs and canned cycles follow the active plane. G21 Metric. This is the HiNC default. G71 Metric — the RS-274-D / Fanuc G-code system C / Syntec spelling of G21, accepted the same way on the Fanuc and Syntec presets. Mazak EIA stays G20 / G21 only. G20 Inch — not supported. The block reports Unit--InchNotSupported; post the program in metric. G70 Inch — the RS-274-D / Fanuc G-code system C / Syntec spelling of G20, read on the Fanuc and Syntec presets. Not supported; the block reports Unit--InchNotSupported; post the program in metric. G90 / G91 Absolute / incremental positioning. G94 / G95 Feed per minute / feed per revolution. Work coordinates Code Meaning G54–G59 Standard work coordinate systems. G59.1–G59.9 Extended work coordinate systems, backed by the brand-neutral table the Fanuc, Mazak and Syntec presets carry behind their brand table. Like G54–G59, a row left at zero is read as an authoring convention and stays silent. G54.1 P1–P48 Fanuc additional work coordinate systems, backed by the extended work offset table. Also read in the manual's second spelling G54 P1–P48, with or without the space; a G54 with no P word is the plain G54 above. A selected row nobody has entered reports Coord-WorkOffset--AdditionalZero. G52 Local coordinate offset, applied on top of the active work coordinate system. Tool compensation Code Meaning G43 / G44 / G49 Tool length compensation, positive / negative / cancel. H selects the offset row. G41 / G42 / G40 Cutter radius compensation, left / right / cancel. D selects the offset row. Radius compensation is resolved against the blocks that actually travel in the compensation plane. A block whose own words command no movement in that plane — a bare G41 / G42, a comment, an empty line, a Z-only plunge — takes no offset of its own and no part in a corner: Start-up waits for motion. A G41 or G42 block that does not move in the plane does not start the offset; the first block that travels in the plane is the start-up block and takes the perpendicular (type A) offset. The blocks between them carry the previous block's offset vector, so nothing moves on their account. Corners are resolved between travelling blocks. Wordless blocks sitting between two moves are passed over, and the corner is the intersection of the two real segments. Running axes are the in-plane part of each displacement, so a ramping move keeps its full offset and a Z-only plunge stays on the offset line. A bare G40 closes the region. The last compensated block ends on its own perpendicular offset rather than turning toward the first uncompensated move after the cancel. A G40 that carries motion is the last corner's partner instead, and the compensated path meets the cancel line at their intersection (Fanuc type B); the legacy interpreter (EnableSoftNcRunner set false) ends that case perpendicular. Rotation, tilted planes and five-axis Code Meaning G68 Coordinate rotation in the active plane, around a centre point by angle R. G68.2 Tilted work plane — Euler angles I / J / K with origin X / Y / Z. G69 Cancels G68 and G68.2. G53.1 Tool-axis direction — swings the rotary axes into line with the active G68.2 plane. G43.4 RTCP / tool centre point management. The Siemens equivalent is TRAORI, the Heidenhain equivalent M128. Canned cycles Code Cycle G73 High-speed peck drilling — Q increments with a partial retract. G74 Left-hand tapping. G76 Fine boring — oriented spindle stop, Q shift, rapid out. G81 Drilling. G82 Drilling with a dwell at the bottom. G83 Peck drilling — Q increments with a full retract to the R point. G84 Right-hand tapping. G85 Boring, feed out. G86 Boring, spindle stop then rapid out. G87 Back boring. G89 Boring with a dwell at the bottom. G80 Cancel. G98 / G99 Retract to the initial level / to the R level. A cycle is expanded into the individual strokes it performs — approach, peck, dwell, retract — each with its own feedrate, so material removal and cycle time come out of the real motion rather than an approximation. Modal repetition and G91 incremental cycle data are resolved before the strokes are built. Polar interpolation G12.1 turns polar coordinate interpolation on and G13.1 turns it off. Inside a polar section the X word is a diameter and the C word is a hypothetical Cartesian axis in millimetres, not rotary degrees. HiNC halves X, resolves G90 / G91, writes both the polar and the derived Cartesian positions along with the machine C angle, and simulates polar linear and polar arc motion — the arc as real spiral geometry that stays continuous across ±180°. G41 / G42 compensation is resolved on the hypothetical plane, and YA / ZB axis pairs work the same way. G codes that conflict with polar mode are checked before the mode is entered. Path smoothing G05.1 Q1 enables high-precision contour control (AICC / Nano Smoothing) and Q0 disables it. The optional R precision level is preserved. Bare G05 (or G5) is a different feature under a confusingly similar name, and the two are tracked separately so they cannot cancel one another. It selects a function through its P word, on the Fanuc, Syntec and Mazak presets: P Reading P10000 HPCC — RISC-based high-precision contour control. Recognized, deliberately not simulated: it changes the machine's look-ahead, acceleration and servo behaviour, never the programmed coordinates. Reports Hpcc--NoOp. P0 Cancels HPCC. Consumed silently — cancelling a no-op needs no message. P10001–P10999 High-speed cycle machining. The real machine executes cycle data pre-registered in its variable area, which is actual axis motion HiNC cannot see, so the simulated result misses that machining. Reports Hpcc--HighSpeedCycleIgnored as a warning. anything else, or no P at all Not supported offline and ignored, reported as Hpcc--UnsupportedFunction. Small P values select the high-speed remote buffer modes. An unevaluated macro variable or expression in P is tolerated — it reports Hpcc--UnsupportedFunction rather than failing the block. M codes Code Meaning M00 / M01 Program stop / optional stop. M02 / M30 Program end. M03 / M04 / M05 Spindle clockwise / counter-clockwise / stop. M06 Tool change. The axis travel the change requires is synthesized rather than teleported. M07 / M08 / M09 Mist coolant on / flood coolant on / coolant off. M98 / M99 Subprogram call (M98 P{program} L{repeat}) and return, including M99 P{sequence} early return. M198 Subprogram call from external storage — same shape as M98, different lookup folder. Note Composite and OEM M-codes are not built in — they are declared on the machine. An M13 that means “spindle CW plus flood coolant”, an M-code that triggers a tool change, or turret T-word semantics are stated once in the machine's own M-code table and expanded into the ISO effects the rest of the pipeline already understands. A code declared with no modelled effect is voiced once as DeclaredMCode--UnmodeledEffects instead of raising an unknown-code warning on every occurrence. Note If a program states a spindle speed greater than zero but never issues a direction, HiNC assumes clockwise and reports SpindleDirection--AssumedCw. Without that assumption the cutting-force model would silently produce zero mechanics for the whole file. Fanuc Everything in the ISO core, plus: Custom Macro B. # variable assignment and arithmetic, with each range routed to the store it belongs to — #1–#33 local to the macro frame, #100–#499 volatile and cleared on M02 / M30, #500–#999 retained and saved with the project, #3000–#3999 system control. Boolean and logical operators, IF [..] GOTO n, IF [..] THEN <statement>, and WHILE [..] DO m / END m with a bounded-loop watchdog. Position and tool-offset system variables read back into expressions. Macro and subprogram calls. G65 one-shot macro call, binding arguments A–Z onto #1–#26; G66 / G67 modal macro, firing at every positioning block until cancelled; M98 / M198 / M99. A callee's blocks are spliced into the program at the call site, so the rest of the run treats them exactly as if they had been written in the main file. Not supported. G10 programmable data setting, G50 spindle speed clamp, G31 skip. Syntec Syntec runs the ISO core plus the Fanuc-family macro and subprogram vocabulary and polar interpolation. Not supported. Custom G macros defined on the controller, Pr parameter mapping, and twin-head / twin-turret program syntax. Mazak Mazak reads EIA/ISO with the Fanuc-family macro and subprogram vocabulary and polar interpolation. Not supported. MAZATROL conversational sections, and switching between MAZATROL and EIA/ISO inside one program. Export the EIA/ISO program from the controller. Siemens SINUMERIK Real .mpf / .spf programs replay end to end — this is not an ISO subset with a Siemens label on it. Modal vocabulary. SUPA / G153 suppress all frames for one block; G70 / G71 units; the path-smoothing family (G60x / G64x, FNORM / SOFT / FFWON / COMP* / UPATH, CYCLE832); MSG() and STOPRE; CR= and TURN= arcs. Tail comments are quote-aware, so a ; inside MSG(\"A;B\") does not truncate the block. G74 / G75 fixed-point return is claimed as a whole block, so the dummy axis values it carries never mint a rapid to those coordinates and its F never reaches the modal feedrate. Tools. T=\"NAME\" string tool calls with D cutting-edge offsets, resolved through the $TC_DP tool table — lengths and radius plus additive wear. Variables and expressions. R parameters R0–R999 are held as per-project data, DEF REAL / DEF INT declarations lower into assignments, and a full expression evaluator means Z=R63+150 and X=SIN(R10)*20 drive real motion. $P_UIFR[n,axis,TR] binds both ways to the frame table. Any other $ variable is recorded with an unsupported note rather than silently dropped. Frames and five-axis. TRANS / ATRANS / ROT / AROT (with RPL=) compose into the tilt chain in Sinumerik RPY order; TRAORI is a real RTCP mode, the sibling of ISO G43.4, with TRAFOOF handing the offset back; CYCLE800 is decoded from its MODE bits across all four swivel modes. Calls and control flow. L-prefixed and named subprogram calls, inlined with their P repetition count; M17 / RET; REPEAT over a labelled slice; MCALL CYCLE81 / 82 / 83 / 85 mapped onto the shared canned-cycle machinery; PROC headers and labels. GOTOF / GOTOB, IF / ELSE / ENDIF, and WHILE / FOR / REPEAT-UNTIL / LOOP. Jumps and loop iterations are capped rather than hanging the session — over the cap the construct warns and falls through. Per-word coordinate functions. AC() / IC() / DC() / ACP() / ACN(), including on I / J / K circle centres, so G90 C=IC(360/17) is one incremental index inside an absolute program. ACP() takes the forward window, ACN() the backward one, and DC() the shortest swing. Coded positions. CAC / CIC / CDC / CACP / CACN take a 1-based indexing position number instead of a coordinate, resolved against the machine's own indexing-position tables. OEM auxiliary M-codes. The preset declares M12 / M13 / M22 / M23 and M330 / M331 as note-only, so each occurrence voices DeclaredMCode--UnmodeledEffects rather than an unknown-code warning. A machine's own table overrides the declaration once the real effects are known. Recognized, not simulated. ROTS / AROTS, SCALE / ASCALE, and MIRROR / AMIRROR — each reported as SiemensFrame--Unsupported. Not supported. SETAL. See Also Heidenhain Support — klartext and Heidenhain DIN/ISO. NC Parsing Engine — the pipeline behind these codes, the brand-by-brand support matrix in one table, and how a machine's own vocabulary is added without changing HiNC."
  },
  "technique/nc-dialects/index.html": {
    "href": "technique/nc-dialects/index.html",
    "title": "NC Dialects | HiAPI-C# 2025",
    "summary": "NC Dialects How a controller program becomes motion. A machine's NC is not one language but a family of dialects that disagree about almost everything except the axis letters, so HiNC parses a program against the brand it was written for and reports what it could not honour rather than guessing. Ordered from the engine that reads every dialect to the two reader-facing pages that say what each brand's vocabulary actually does. NC Parsing Engine — The interpreter pipeline, the brand-by-brand support matrix, and how a machine's own vocabulary is added without changing HiNC ISO / General NC — What Fanuc, Syntec, Mazak and Siemens SINUMERIK code HiNC honours, recognises without acting on, or refuses Heidenhain — Klartext and Heidenhain DIN/ISO: the block format, Q parameters, tilted planes and the cycles that are read See Also NC Optimization — what rewrites the program this engine reads Setup — the setup tasks these dialects are configured from Program Zero Alignment — the setup task that decides which work offset the code in these pages resolves against Controller — picking the brand a project reads its programs with, and the tables that brand grows"
  },
  "technique/nc-dialects/nc-parsing.html": {
    "href": "technique/nc-dialects/nc-parsing.html",
    "title": "NC Parsing Engine | HiAPI-C# 2025",
    "summary": "NC Parsing Engine SoftNcRunner is the NC interpreter. It reads a controller program — Fanuc, Siemens, Syntec, Mazak or Heidenhain G-code, an NX cutter-location file, or a CSV controller recording — and turns it into the machine actions the simulation executes. It is a composed interpreter rather than a fixed one. The segmenter, the initializers, the syntax stages, the semantics and the dependency data are five ordered lists on the runner object, all of them serializable. Adding support for a G-code means adding one syntax unit and one line to a list; removing support means removing that line. Nothing about a brand is compiled into a central class. Note SoftNcRunner is the default NC pipeline as of 3.2 (EnableSoftNcRunner defaults to true). HardNcRunner remains reachable as the opt-out fallback for the shrinking set of features still bound to it. The pipeline A program becomes actions in five ordered stages. Each shipped preset expresses them as five BundleSyntax containers named Parsing, Evaluation, Logic, PostLogic and Inspection. graph TD A[NC raw lines] --> SEG[ISegmenter] SEG --> SENT[Sentence stream] SENT --> INIT[INcInitializer] INIT --> P[Parsing<br/>text to structure] P --> E[Evaluation<br/>variables, expressions,<br/>calls, control flow] E --> L[Logic<br/>modal state, coordinates,<br/>compensation, motion] L --> PL[PostLogic<br/>modal carry] PL --> I[Inspection<br/>backfill, unconsumed check,<br/>snapshot] I --> SEM[INcSemantic] SEM --> OUT[Machine actions] DEP[INcDependency list<br/>brand tables, coordinate systems,<br/>tool offsets, kinematics, ...] DEP -. injected .-> P DEP -. injected .-> E DEP -. injected .-> L DEP -. injected .-> SEM Stage Responsibility ISegmenter cuts the raw text into blocks. Three implementations ship — one line per block, and the two multi-line forms Heidenhain and Siemens programs need INcInitializer seeds the stream head with the machine's starting state, for example the configured home position Parsing recognizes the text: words, statements, cycle bodies, comments. Writes structure, never meaning Evaluation resolves anything the block computes for itself — variable reads and writes, arithmetic, conditional jumps, loops, and subprogram or macro calls, whose bodies are spliced into the stream so later stages walk them as if they had always been in the host file Logic the modal machine model: units, positioning mode, plane, feed, spindle, coolant, tool change and compensation, work offsets, tilt and RTCP, and the program-to-machine coordinate chain PostLogic carries the block's full modal context forward, so every block's data is self-contained Inspection back-fills derived values, reports words nothing consumed, and optionally snapshots the block INcSemantic turns the finished block into machine actions — linear and arc motion, teleports, tool change, spindle, dwell, stroke-limit checks Over 150 syntax units ship across those five stages, plus the per-brand lists that select and order them. Most syntax units implement ISituNcSyntax — they mutate the block in place. IExpandingNcSyntax exists for a unit that must turn one block into several. Note that the shipped call and repeat syntaxes are not expanders: they splice the callee's already-segmented blocks into the stream ahead of the current position, which keeps one block's identity intact through the rest of the pipeline. Composition and presets The runner is a container; its five lists are what make it a Fanuc runner or a Heidenhain one. <SoftNcRunner> <PipelineNcDependencyList>...</PipelineNcDependencyList> <Segmenter>...</Segmenter> <NcInitializationList>...</NcInitializationList> <NcSyntaxList>...</NcSyntaxList> <NcSemanticList>...</NcSemanticList> </SoftNcRunner> Every unit implements IMakeXmlSource and registers itself with XFactory, so the whole pipeline round-trips through XML. Seven presets are built in: Preset Reads FanucNcRunner Fanuc G-code, including Custom Macro B SiemensNcRunner Sinumerik .mpf / .spf SyntecNcRunner Syntec G-code MazakNcRunner Mazak EIA/ISO HeidenhainNcRunner klartext and DIN/ISO, on one preset GeneralCsvRunner a CSV controller recording NxClRunner NX CLSF / APT-source cutter-location files The five brand presets also ship as standalone files under Resource/Controller/ with the .Controller extension, written by ControllerPresetWriter, so the load browser starts populated. Those files are regenerable snapshots — the static properties above are the source of truth, and the files are rewritten whenever a brand pipeline changes. Important Reading a preset file back requires the pipeline types to be registered first (Reg through Reg at startup). The loader drops unregistered entries silently rather than failing the load, so an unregistered process reads a hollow pipeline that parses nothing. A runner rehydrated from an older saved file keeps the syntax list it was saved with — nothing re-derives a brand's syntax list at read time. To pick up new brand syntaxes, take the current preset or a fresh NcRunnerSuit built from it. Missing system-wired dependencies are back-filled automatically on load; syntaxes are not. The dataflow Each block travels the pipeline as a SyntaxPiece carrying a JSON object. Every stage reads some keys, writes some keys, and removes the keys it has consumed. The convention is section plus term: the section key is a semantic name that is the same across brands (Unit, Feedrate, Motion, CoordinateOffset), while the controller's actual keyword lives in the section's Term field so the correspondence with the source text is never lost. A Fanuc block N162 X-14.696 Y-6.42 Z45.638, after the pipeline (matrices elided): { \"IndexNote\": {\"Symbol\":\"N\",\"Number\":162}, \"Positioning\": {\"Term\":\"G90\",\"Mode\":\"Absolute\"}, \"Unit\": {\"Term\":\"G21\",\"System\":\"Metric\"}, \"PlaneSelect\": {\"Term\":\"G17\",\"Plane\":\"XY\"}, \"Feedrate\": {\"FeedrateValue\":400,\"Term\":\"G94\",\"Unit\":\"mm/min\"}, \"SpindleSpeed\": {\"SpindleSpeed_rpm\":20000,\"Direction\":\"CW\"}, \"Coolant\": {\"IsOn\":true,\"Mode\":\"Flood\"}, \"ToolChange\": {\"ToolId\":4,\"IsChange\":false}, \"TiltTransform\": {\"Term\":\"G68.2\"}, \"ProgramToMcTransform\": [ {\"Source\":\"TiltTransform\", \"Mat4d\":[ ... ]}, {\"Source\":\"ToolHeightCompensation\", \"Mat4d\":[ ... ]}, {\"Source\":\"CoordinateOffset\", \"Mat4d\":[ ... ]}, {\"Source\":\"PivotTransform\", \"Mat4d\":[ ... ]} ], \"ToolHeightCompensation\": {\"Offset_mm\":16,\"Term\":\"G43\",\"OffsetId\":4}, \"CoordinateOffset\": {\"CoordinateId\":\"G54\",\"Offset_X\":72.4,\"Offset_Y\":-72.4,\"Offset_Z\":-116.44}, \"ProgramXyz\": {\"X\":-14.696,\"Y\":-6.42,\"Z\":45.638}, \"MachineCoordinateState\": {\"X\":140.5947,\"Y\":-78.8200,\"Z\":-124.4559}, \"MotionState\": {\"Term\":\"G01\"}, \"MotionEvent\": {\"Form\":\"McLinear\",\"IsRapid\":false}, \"RadiusCompensation\": {\"Term\":\"G40\",\"OffsetId\":0,\"Radius_mm\":0} } Three things are worth reading off that block. Program and machine coordinates are both present. The source states program coordinates; the pipeline keeps them and adds the solved machine coordinates, so a report or a UI can use either. ProgramToMcTransform flattens the cause chain. The program-to-machine mapping is not one opaque matrix but the ordered list of contributions that built it — tilt, tool height, work offset, pivot — each with its own matrix. When a machine coordinate is not what you expected, this array names which compensation is responsible without re-running anything. Modal state is complete on every block, even where the source line states none of it, because PostLogic carries the previous block's sections forward. A section the pipeline synthesized rather than read from the source carries an AddedBy marker (ModalCarry or Backfill), so a reader can tell authored data from carried data — see SyntaxStageKeys. Retention and the freeze A session retains every executed block for its lifetime, and the live JSON graph costs about 12 KB per line against about 1.6 KB for its compact UTF-8 form — which is what made multi-million-line programs exhaust a client machine. Once a block leaves the executing window its piece is frozen: the graph is replaced by those bytes (Freeze, IsFrozen). On a 25,000-line play that takes session retention from 406 MB to 142 MB. The switch is FreezeExecutedPieces, on by default. Downstream readers are unaffected — the JsonObject getter re-parses on demand and the encoding is byte-identical to the live form — but the object it returns is a fresh read-only snapshot per call, with no caching and no write-back. Two reads are not reference-equal, a mutation lands on a throwaway copy, and code that reads the same piece repeatedly should hold the snapshot in a local. To inspect the dataflow, snapshot it in the pipeline with the SnapshotSyntax entry each bundle carries (disabled by default) rather than holding pieces and poking them afterwards. Type discrimination is slightly looser after a round trip, because JSON has fewer types than the live graph: NaN and ±Infinity serialize as quoted strings and thaw as string nodes, and 5.0 freezes as 5, so an integer read of it succeeds where it previously would not. GetDouble maps the quoted non-finite spellings back to their double constants, so read numbers through it rather than through a raw node cast. Dependencies Machine and case data reach the syntaxes as a list of INcDependency objects rather than as fields on a shared configuration object. A syntax declares what it needs by interface and pulls it: // A syntax that needs the machine's home position asks for the interface, not for a class. var homeConfig = ncDependencyList.OfType<IHomeMcConfig>().FirstOrDefault(); Adding a brand means adding a table that implements the interfaces its syntaxes ask for — the brand parameter tables derive from ControllerParameterTableBase. Per-case data travels as a proxy. Tool offsets, work-coordinate offsets, Siemens frames, Heidenhain datums and retained macro variables belong to a job, not to a controller configuration. Those entries sit in the pipeline list as placeholders that resolve, per session, against the owning project's per-case list — which is what lets one controller configuration be shared across projects. PipelineNcDependencyList is the raw list; consumers read the resolved view through GetEffectiveNcDependencyList. NcRunnerSuit bundles a runner with its per-case data as one file-loadable unit, so a whole parser configuration — pipeline and job data together — moves as a single file. Machine wiring ConfigureByMachiningChain takes the machining chain and settles what the pipeline needs to know about the physical machine: axis order, which axes are rotary and which linear, and the kinematics the coordinate syntaxes solve against. A five-axis machine, a four-axis machine and a twin-table machine all run the same program path — the difference is the chain, not the parser. Extending it Three kinds of customization need no rebuild of the libraries: Switch brand. var runner = SoftNcRunner.HeidenhainNcRunner; runner.ConfigureByMachiningChain(machine.Chain); Add a syntax for one machine's own vocabulary. A machine whose PLC uses a non-standard M168 for clamping needs a class implementing ISituNcSyntax and one entry in that project's pipeline list. No HiAPIs source changes. Declare OEM M-codes without writing code at all. IMCodeDeclarationConfig and MCodeEffects let a machine state what its own M-codes do — a composite spindle-and-coolant code, a tool-change trigger, turret T-word semantics — and MCodeExpansionSyntax expands them into the canonical ISO flags the shared consumers already understand. A code declared with no modeled effects is voiced once as DeclaredMCode--UnmodeledEffects instead of raising an unknown-code warning on every occurrence. Important Composing the pipeline is a licensed capability. Registering a unit that is not built in — into the syntax list, the dependency list, the semantics, the initializers or the segmenter — and executing an NC-embedded C# script both require the NcComposition licence feature. The check runs once per session at the run entry, so it covers project-XML load, whole-object replacement and direct list mutation alike. Degradation is silent and functional, not an error: external units are skipped for that session and named in one Composition--NotLicensed diagnostic, an external segmenter falls back to the single-line segmenter, and scripts are skipped with Script--NotLicensed. The runner's persisted lists are never mutated, so the project still saves correctly — but the simulation that ran is a different one. If you build against this surface, check for that diagnostic rather than assuming your unit ran. Built-in units are unrestricted in order, count, duplication and constructor configuration, and calling the public API from your own application or session script needs no extra licence. Brand support Coverage is stated in three states. Recognized but not simulated is a deliberate state, not a gap: the construct is consumed safely and reported with its own diagnostic id, so it can never be misread as something else — a PLANE AXIAL B+45 will not be mistaken for a rotary axis command. Brand Supported Recognized, not simulated Not supported Fanuc ISO core, canned cycles G73–G89, G41/G42, G43.4 RTCP, G53/G53.1, G68/G68.2/G69, G12.1/G13.1 polar with compensation, Custom Macro B (# variables, IF/GOTO, WHILE/DO), M98/M99 subprograms, G65/G66/G67 macro calls bare G05 P HPCC selections (Hpcc--NoOp, Hpcc--HighSpeedCycleIgnored, Hpcc--UnsupportedFunction) G10 programmable data setting, G50 spindle limit, G31 skip Siemens modal vocabulary, SUPA/G153, T=\"name\" with D offsets, $TC_DP tool tables, R-parameters and DEF variables with a full expression evaluator, $P_UIFR, TRANS/ATRANS/ROT/AROT frames, TRAORI/TRAFOOF, CYCLE800, MSG/STOPRE, CR=/TURN= arcs, L/named subprograms, MCALL, REPEAT, PROC/labels, GOTOF/GOTOB, IF/ELSE/ENDIF, WHILE/FOR/REPEAT-UNTIL/LOOP, AC()/IC()/DC()/ACP()/ACN(), the coded-position family, G74/G75 ROTS/AROTS, SCALE/ASCALE, MIRROR/AMIRROR (SiemensFrame--Unsupported) SETAL Heidenhain klartext motion and FMAX, LN surface-normal blocks resolved into the rotary axes, M91, TOOL CALL with DL/DR, CYCL DEF 247 presets and CYCL DEF 7 additive shifts, CC/C arcs, RL/RR/R0, M126/M127, M140, CYCL DEF 32, Q/QR parameters with the FN grammar and FN 9–12 jumps, PLANE SPATIAL, FUNCTION TCPM, M128/M129, machining cycles 200/232/251/252/253, CYCL CALL/CYCL CALL POS, CALL LBL with REP, CALL PGM, tilde continuation, BLK FORM, STOP, mirror image (G28 and CYCL DEF 8), and the DIN/ISO dialect with absolute I/J/K centres, the ISO label family, G247, G54 datum words and G70/G71 PLANE VECTOR (captured), PLANE EULER / POINTS / RELATIV / AXIAL / PROJECTED (HeidenhainPlane--Unsupported), unimplemented FN opcodes such as FN 18 SYSREAD, unrecognized CYCL DEF bodies (HeidenhainCycl--Unsupported), center-referenced FUNCTION TCPM REFPNT (Orientation-RefPoint--CntNotSimulated), and 3D-ToolComp along the LN surface normal (SurfaceNormal--CompNotSimulated) TOOL DEF, FK free contour, SL cycles, PATTERN DEF, TCH PROBE Syntec ISO core plus the Fanuc-family macro and subprogram vocabulary, polar interpolation bare G05 P HPCC selections, as Fanuc custom G macros, Pr parameter mapping, twin-head / twin-turret syntax Mazak EIA/ISO with the Fanuc-family macro and subprogram vocabulary, polar interpolation bare G05 P HPCC selections, as Fanuc Mazatrol conversational sections, MAZATROL ↔ EIA/ISO switching Note On the Heidenhain preset, DIN/ISO G28 is MIRROR IMAGE, not a Fanuc reference-point return, and ReferenceReturnSyntax is not in that preset's Logic list. HardNcRunner keeps the Fanuc reading, so the two engines are deliberately divergent on Heidenhain G28 files. Scope and testing Two limits sit outside the per-brand table and apply to everything in it. Milling only. Turning and tapping operations are not simulated. A program containing them parses as far as its milling content allows; the operations themselves are not modelled. Fanuc syntax is the primary test surface. All five presets are exercised, but Fanuc carries the most coverage, and a construct that is unusual in Fanuc but ordinary in another dialect is the likeliest place to meet an unimplemented case. The three-state table above exists so that such a case is reported rather than silently mis-read. Full five-axis RTCP is supported across the presets that have it — Fanuc G43.4, Heidenhain FUNCTION TCPM and M128, Siemens TRAORI. Loading a HardNc-era project Projects written for the legacy interpreter still load. Mechanism Purpose FromLegacyNcEnvXml builds a SoftNcRunner from a legacy configuration element the NcEnv XML alias a project saved under the old element name still deserializes the legacy version patches a project saved by an older build gains the syntaxes and semantics added since, according to the project API version it carries the system-wired back-fill a saved pipeline gains the runtime-wired dependencies it predates EnableSoftNcRunner set false to run the legacy interpreter for comparison The version patches cover projects back to the 3.1.163 era; the back-fill is unconditional, because the dependencies it adds are stateless runtime-wired singletons for which presence is the only question worth asking. See Also Heidenhain Support — the reader-facing page for klartext and Heidenhain DIN/ISO General NC Code Support — the reader-facing page for Fanuc, Syntec, Mazak and Siemens SINUMERIK"
  },
  "technique/nc-optimization/corner-behavior.html": {
    "href": "technique/nc-optimization/corner-behavior.html",
    "title": "Optimized Feed Rate at Corners Is Lower Than Empirically Feasible | HiAPI-C# 2025",
    "summary": "Optimized Feed Rate at Corners Is Lower Than Empirically Feasible See also NC Optimization and the script command Workflow: NC Optimization. Phenomenon During NC feed rate optimization, corners often exhibit significant feed rate reductions — sometimes even lower than what is empirically known to be feasible. This puzzles users: actual machining at corners doesn't require such drastic reductions, so why does the optimization produce these results? Controller Deceleration at Corners At corners, the controller automatically decelerates at high speeds. This is a built-in controller behavior as well as a hardware limitation, designed to ensure the machine can safely and accurately complete direction changes. The controller also provides parameters to adjust this acceleration/deceleration behavior. Relationship Between Buffer Distance and Speed The higher the speed, the longer the required buffer distance. The figure below shows machining conditions for several straight-line paths: The figure labels the spindle speed (S) and feed rate (F) settings for different segments: through1/through2: S500, F200/F100 low1/low2/low3: S1200, F200/F400/F600 high1/high2/high3: S7200, F1200/F2400/F3600 Why Corners Produce Force Peaks Independently of feed-rate optimization, corners themselves generate force peaks that can be 3–4× the straight-line steady force. The mechanism is geometric: Contact area grows at the corner. Two cut segments share the corner's swept volume, so during the turn the engaged arc on the cutter exceeds the steady-state arc. Friction force scales with contact area. For ductile materials (aluminum, nickel) friction is a large share of the cutting force, so the area increase translates directly into a torque/force peak. Both bending moment and torque feel it. CAM can amplify the contact area. Layer-to-layer drift or imperfect corner alignment in CAM-generated NC leaves residual ridges that increase the corner sweep on subsequent layers; the peak then reflects both the geometric corner effect and the CAM-side drift. See CAM Floating-Point Drift for the floor-contact mechanism that compounds with this. Peaks are expected, not artifacts. As long as the corner geometry is correctly aligned, peaks will appear in simulation; absent them, suspect a misalignment. A peak contained inside a single revolution is itself a partial safety margin — controller corner smoothing and spindle inertia together absorb a single-rev overshoot. Sustained peaks across multiple revolutions are a different story: they drag the spindle below commanded rpm and compound through feed-per-tooth growth. See Tuning Peak Tolerance for which metrics can be relaxed in response and which cannot. Force Simulation Error Analysis The figure below shows the force simulation error after applying and comparing dynamometer data, with blue-to-red indicating error ratio from low to high: Error Characteristics The following characteristics can be observed from the figure: Errors increase closer to tool retraction (corners toward the Z direction) Higher feed rates result in longer high-error intervals Error Sources The errors mainly originate from controller deceleration. From the per-revolution waveform at the F3600 corner in the lower part of the figure: Data Source Description Left (simulated ideal force) Ideal cutting force calculated based on the set feed rate Right (dynamometer data) Measured cutting force, approximately one-third of the ideal force The test material was S45C. At that location, the actual feed should be even lower than one-third of the ideal feed. Why Is the Optimized Value Lower Than the Empirical Value? During NC feed rate optimization, corners often show significant feed rate reductions. Beyond the fact that corners typically produce higher cutting forces, the reason the optimized value is lower than the empirically feasible feed rate is: The controller has already reduced the feed rate on its own; the optimization simply reveals this. In other words, the optimization result reflects the feed rate actually executed by the controller, not the feed rate specified in the NC program. This “excessively low” optimized value is in fact the real machine behavior. Conclusion When you find that the optimized feed rate at corners is unusually low, this is typically not a system error but rather: The controller has already automatically reduced the actual feed rate for safe cornering The optimization function faithfully reflects this deceleration behavior Even if you set the empirical value, the controller would still decelerate to a similar value during actual machining Understanding this phenomenon allows you to evaluate optimization results more rationally and adjust cornering strategies or machine parameters as needed. Tracking the Limiting Physical Quantity per Step To find out which physical quantity limits the feed rate at each individual step, refer to the Tracking Physical Quantity Constraints of Individual Steps section in Workflow: NC Optimization. Feed Rate Acceleration Is Not Simulated HiNC applies the programmed feed rate from the NC directly; it does not model the controller's acceleration and deceleration. The error that introduces is in the safe direction: the real machine slows into a corner, so the real cutting force there is lower than the simulated one, and a program that passes in simulation has margin in hand on the machine. The recovery is quick. A corner feed rate typically returns to the programmed value within about five spindle revolutions — roughly 100 ms — though the exact figure depends on the controller's own settings. That is short enough that the simulated force is a good description of everything except the corner itself, and it is the reason the corner is the one place where the optimizer's answer and the machinist's experience disagree. See Also CAM Floating-Point Drift — how drift in the CAM output shows up at corners Machining Time Estimation — the same omitted dynamics, and what they mean for a quoted cycle time"
  },
  "technique/nc-optimization/index.html": {
    "href": "technique/nc-optimization/index.html",
    "title": "NC Optimization | HiAPI-C# 2025",
    "summary": "NC Optimization How HiNC rewrites feed rates against the physical limits of a cut, and how to read a result that looks wrong. The optimizer is conservative by construction: it lowers feed until every tracked ratio sits under its ceiling, so an unexpectedly low value is usually a report of a real limit rather than a fault. Ordered from the general rule to the case that most often prompts the question. NC Optimization Principles — The optimization objective, what limits each step, velocity smoothing, and the per-metric utilization factors that decide which peaks may be tolerated Corner Feedrate Behavior — Why the optimized feed at a corner falls below the empirically feasible value, and why that is the controller's own deceleration being reported back Machining Time Estimation — What the quoted cycle times are computed from, why they agree with controller simulators, and why the ratio is sounder than the absolute See Also Milling Physics — the per-step criteria the optimizer holds under 100% Machine Capability — the spindle, controller and workstation ceilings the optimizer works against Scripting — the Opt* settings a script uses to drive the optimizer NC Dialects — the engine that reads the program before it is rewritten"
  },
  "technique/nc-optimization/machining-time-estimation.html": {
    "href": "technique/nc-optimization/machining-time-estimation.html",
    "title": "Machining Time Estimation | HiAPI-C# 2025",
    "summary": "Machining Time Estimation Every optimization result is quoted as a time — 303 minutes down to 95 — so it matters what that number is and is not. HiNC's machining time is computed from the ideal feed rate in the NC or CL program together with the maximum rotary-axis speed limits. It does not model dynamic behaviour: no acceleration and deceleration ramps, no look-ahead, no servo lag. Why It Matches Controller Simulators That simplification is the same one the controller vendors' own simulators make, which is why the two agree closely. On a five-axis impeller program: Estimator Cutting time Heidenhain simulator 15 h 02 min HiNC 15 h 05 min Difference 0.39% Agreeing with the vendor's simulator is a useful check that the program was read correctly. It is not evidence that either number matches the shop floor. Why the Shop Floor Differs Real machining time can differ substantially from any of these estimates — the vendor's included — because the dynamics they all omit are real. Acceleration limits at direction changes, look-ahead window size, and block processing rate all cost time that no ideal-feed estimate contains. The same NC on two controllers with different look-ahead settings takes different times. The consequence for reading an optimization result: trust the ratio, not the absolute. Before and after are computed the same way and omit the same dynamics, so a reported reduction from 303 to 95 minutes is a sound statement about what the optimization achieved, even where neither number will be observed on the machine. Feed rate acceleration is also the reason an optimized corner feed is conservative rather than wrong — see Optimized Feed Rate at Corners. See Also Optimized Feed Rate at Corners — the same missing dynamics, seen from the corner where they matter most NC Optimization Principles — what the optimizer changes to produce the reduction this page quantifies Optimization Results — the tables whose ratios this page says to trust"
  },
  "technique/nc-optimization/nc-optimization-principles.html": {
    "href": "technique/nc-optimization/nc-optimization-principles.html",
    "title": "NC Optimization | HiAPI-C# 2025",
    "summary": "NC Optimization Also refer to the script commands section Workflow: NC Optimization. Optimization Objective Optimization aims to make the physical quantities during machining as close to the target values as possible. Since the optimization uses a conservative feed rate strategy, the physical quantities in the optimized NC code will be as close to equal to or less than the target values as possible. Factors Determining the Optimized Feed Rate The optimized feed rate is determined by: Physical quantity constraints of individual steps: Feed rate limits calculated for each step based on target force, yielding stress, spindle torque, etc. For detailed descriptions of indicators such as yielding stress ratio and spindle torque ratio, refer to \"Evaluating Process Machinability\". Inter-step smoothing: Interactions such as acceleration/deceleration limits and extended distances. Differences in Simulation Results After Optimization Simulation with modified feed rates produces different interpolation points than before, resulting in: Different simulation mesh errors Surface morphology changes at the surface roughness level Therefore, the simulated physical quantities after optimization may not always be equal to or below the target values — they may also be slightly above. The influence of interpolation point density on surface morphology is greater at rounded corners than on straight lines, so this effect may be more pronounced at corners. Tip For abnormally low optimized feed rates at corners, refer to Corner Feed Rate Optimization. Velocity Smoothing The smoothing range terminates at macro commands or line commands with unresolvable paths. Velocity smoothing applies acceleration/deceleration limits based on the path length traversed by the current line command. Therefore, velocity smoothing is effective for re-interpolatable regions; however, for non-re-interpolatable regions, although acceleration/deceleration limits still apply, the excessively long path length of a single line may render them impractical in actual use. Impact of Geometric Errors Current NC optimization is based on an ideal geometric model. If the workpiece is a casting or has installation errors, a conservatively larger workpiece geometry should be configured in the system to prevent the system from misidentifying cutting regions as non-cutting regions, which could cause tool crashes. Tool Breakage Solutions Modify the toolpath to reduce cutting width/depth, or use HiNC's optimization feature to adjust feed rates, bringing the yielding stress ratio, max spindle torque ratio, and max spindle power ratio below 100%. For detailed descriptions of these indicators and tool breakage criteria, refer to \"Evaluating Process Machinability\". Tuning Peak Tolerance Optimization defaults treat the 100 % line on every ratio as a hard ceiling. In practice some metrics tolerate routine excursions and others don't. The per-metric Opt*UtilizationFactor levers let the optimizer accept higher peaks where physically safe. Metric Factor (API) When to raise Yielding stress OptYieldingUtilizationFactor Per-instant. Safe to raise. If 150 % is routinely tolerated without breakage, set 1.5. Controller corner smoothing and spindle inertia absorb a single-revolution overshoot. Spindle torque OptSpindleTorqueUtilizationFactor Cumulative. Keep at 1. Sustained excursions stall the spindle: feed continues, rpm drops, feed-per-tooth grows, forces spike further. Spindle power OptSpindlePowerUtilizationFactor Cumulative. Keep at 1. Same reason as torque. Thermal yield OptThermalYieldUtilizationFactor Long-term. Can be raised modestly if the calibrated tool material is more thermally tolerant than the conservative defaults — see Thermal Plastic Deformation of Cutting Edge. Rule of thumb: relax per-instant per-step metrics based on observed stable extremes; never relax cumulative metrics. For a complementary feed-rate floor lever — useful when the NC cannot be modified to remove single-revolution peaks — see MinFeedPerTooth_mm (API) and When the NC Cannot Be Modified. Thermal Edge Chipping Solutions After addressing tool breakage issues, reduce the spindle speed to allow sufficient time for the cutting edge to dissipate heat. Note that whether the coolant is properly directed at the cutting edge has a significant impact. Tracking Physical Quantity Constraints of Individual Steps Every optimization already writes the per-step log — one .IndependentStepAdjustment.log beside each optimized NC file that had steps to solve — so nothing has to be switched on to obtain it. What that log cannot answer on its own is which physical quantity limited an individual step, because smoothing carries neighbouring steps into the feed it records. Disable the smoothing settings before the run: OptMaxAcceleration_mmds2 = double.PositiveInfinity; OptFeedrateAssignmentRatio = 0; OptExtendedPreDistance_mm = 0; OptExtendedPostDistance_mm = 0; After running the optimization, inspect the .IndependentStepAdjustment.log file to view the independent optimization calculation results for each step and identify which physical quantity limited the feed rate. For detailed field descriptions of the log file, refer to the Optimization Logs section in the Workflow: NC Optimization workflow. When a Step Cannot Be Solved A step whose solve fails does not stop the optimization. That step keeps the feed rate the simulation ran it at instead of a solved one, and every other step is optimized as usual, so a completed optimization can contain steps no physical criterion ever set the feed of. Three records name them: an Error message per failed step, carrying the step index, the NC file and line, and the underlying exception — the first twenty failures of a run, after which only the summary is kept; one Warning at the end of the pass, giving the number of failed steps and the first of them; a StepFailed row in that file's .IndependentStepAdjustment.log, in place of the step's usual per-criterion row. What such a step does not keep is that feed all the way to the file. The stages after the solve treat it like any other step, constraining it against the extended segment and the acceleration limit, and where the step shares one feed word with the rest of its line, the value written is the lowest that line allowed. So the output NC marks nothing and the feed in it names nothing either: a failed step is indistinguishable in the file both from a step the optimizer had no reason to change and from one it had every reason to slow down. The messages are the only place that difference is stated, so read them before sending an optimized program to a machine. Failures also do not shorten the pass. The per-step solve closes with exactly one row of its own in every run — Optimization Feedrate built. when it reached the end of the steps, Optimization Feed Process canceled. when Stop caught it first — and that row follows the failure summary rather than replacing it. The run then carries on through the stages after the solve. A pass that reported failures still produces optimized files, and neither of those two rows having appeared yet means the solve is still working, not that it gave up. A run ended with Stop leaves the per-step log short. Its buffered tail is dropped rather than flushed, so the lines written since the last batch — batches go out at most once a second — never reach the file, and neither does any step line still held back waiting for a lower step index the stopped run never solved. A log that ends before the last step the run reached is the stop showing, not a gap in what the optimizer reports. A NaN Feed Boundary Is Refused by Name Each step's feed-per-tooth boundary is composed from the option's feed-rate limits and feed-per-tooth limits, the step's tooth-arc duration, and the cutter's own optimization limits. A boundary that comes out NaN is refused before the solver runs, and the message names the values it was given — MinFeedrate_mmdmin, MaxFeedrate_mmdmin, MinFeedPerTooth_mm, MaxFeedPerTooth_mm and the step's tooth-arc duration — because a NaN trial feed otherwise reaches the physics and is reported far from its cause. The usual source is a script writing NaN into the per-step option from a step event; see Script Commands. See Also Cutter Adjustment Levers — what to change on the cutter when feed optimization runs out of room Script Commands — the script side of the per-step options, including the one that fails a step Machining Time Estimation — what the cycle-time reduction this produces is measured against Optimization Results — measured before-and-after on a hardened mould and a five-axis titanium job"
  },
  "technique/rendering/color-guide.html": {
    "href": "technique/rendering/color-guide.html",
    "title": "Color Guide System | HiAPI-C# 2025",
    "summary": "Color Guide System The Color Guide System allows you to assign colors and rendering priorities to visual elements based on machining steps or data states. Overview The IColorGuide interface defines the core functionality for color mapping, allowing different colors and rendering priorities to be returned based on various steps or states. This system is particularly suitable for scenarios requiring visual encoding based on data states, such as CNC machining path visualization. Core Interface IColorGuide Interface IColorGuide is the core interface of the Color Guide System, inheriting from IMakeXmlSource and IGetColorGuide. Methods Method Description GetRgb Returns RGB color value based on the step object GetRgbWithPriority Returns RGB color and rendering priority Priority Explanation The attachmentPriority parameter controls the overlay priority during rendering: Higher values take priority: Larger priority values are displayed first Graph scaling for pixel consolidation: When multiple machining steps are rendered within the same pixel, higher priority colors take precedence Effects on Rendering Systems In CubeTree (CubeTree): Color priorities determine which machining state is displayed when multiple operations overlap in 3D space Higher priority colors (like collision detection) will override lower priority colors (like normal cutting) Application Scenarios The Color Guide System is suitable for the following scenarios: CNC Machining Visualization: Display different path colors based on machining states Data State Encoding: Convert numerical states to visual color representations Priority-based Graph Scaling: When zooming out or viewing dense data, higher priority colors (critical states) remain visible while lower priority colors may be consolidated Multi-resolution Rendering: Critical machining issues (collisions, safety violations) are always displayed regardless of zoom level or data density Registering Color Guide in Project To make the Color Guide effective in a project, implement the IColorGuide interface and register it in the project's color guide dictionary. XML Serialization See About XML IO for details on XML serialization implementation. Source Code Path HiMech/Coloring/IColorGuide.cs See HiNC App Anatomy for git repository links. See Also Drawing — the rendering unit whose colour and priority this system decides About XML IO — how a colour guide is serialized with its project"
  },
  "technique/rendering/custom-rendering-canvas.html": {
    "href": "technique/rendering/custom-rendering-canvas.html",
    "title": "Building Your Own Rendering Canvas | HiAPI-C# 2025",
    "summary": "Building Your Own Rendering Canvas This guide provides detailed implementation information for creating your own RenderingCanvas using the DispEngine. By understanding these implementation details, you can customize the rendering component for specific application needs or create implementations for other UI frameworks. Note For Windows Applications: If you are developing for Windows systems, it is recommended to directly use the existing RenderingCanvas implementations in the Hi.WinForm or Hi.WpfPlus packages, rather than creating your own. These implementations are fully tested, optimized, and maintained. The implementation details provided in this document are primarily for educational purposes or for developers who need to port RenderingCanvas to other platforms/frameworks. Basic DispEngine Usage The DispEngine is designed to display objects that implement the IDisplayee interface. This is the fundamental purpose of DispEngine - to render displayable objects. Assign IDisplayee to DispEngine.Displayee. Core Implementation Pattern When implementing a custom RenderingCanvas for a UI platform, follow these key steps: Initialize UI Component - Set up the UI control properties and event handling Configure DispEngine - Create and properly initialize the DispEngine instance Set Up Rendering Pipeline - Implement buffer swapping mechanism for visualization Handle User Input - Map platform-specific input events to DispEngine methods Manage Component Lifecycle - Ensure proper resource management and cleanup Let's examine the actual implementations in WinForm and WPF frameworks to understand these patterns in practice. WinForm Implementation Details The WinForm implementation in Hi.WinForm combines Windows Forms controls with the DispEngine rendering system. Core Properties and Fields Here are the essential properties and fields defined in the WinForm implementation: /// <summary> /// <see cref=\"DispEngine\"/>. /// </summary> public DispEngine DispEngine { get; } // Constants and structures for WM_TOUCH private const int WM_TOUCH = 0x0240; private const int TOUCHEVENTF_MOVE = 0x0001; private const int TOUCHEVENTF_DOWN = 0x0002; private const int TOUCHEVENTF_UP = 0x0004; [StructLayout(LayoutKind.Sequential)] private struct TOUCHINPUT { public int x; public int y; public IntPtr hSource; public int dwID; public int dwFlags; public int dwMask; public int dwTime; public IntPtr dwExtraInfo; public int cxContact; public int cyContact; } [DllImport(\"user32.dll\")] private static extern bool RegisterTouchWindow(IntPtr hWnd, uint ulFlags); [DllImport(\"user32.dll\")] private static extern bool GetTouchInputInfo(IntPtr hTouchInput, int cInputs, [In, Out] TOUCHINPUT[] pInputs, int cbSize); [DllImport(\"user32.dll\")] private static extern void CloseTouchInputHandle(IntPtr lParam); Initialization The initialization code sets up event handlers and creates the DispEngine: /// <summary> /// Ctor. /// </summary> /// <param name=\"displayees\">displayees</param> public unsafe RenderingCanvas(params IDisplayee[] displayees) { // Configure the control's visual styles SetStyle(ControlStyles.Selectable, true); SetStyle(ControlStyles.OptimizedDoubleBuffer, false); SetStyle(ControlStyles.ContainerControl, false); SetStyle(ControlStyles.ResizeRedraw, false); DoubleBuffered = true; InitializeComponent(); Dock = DockStyle.Fill; // Connect event handlers for user input and window events this.Resize += RenderingCanvas_Resize; this.VisibleChanged += RenderingCanvas_VisibleChanged; this.MouseMove += RenderingCanvas_MouseMove; this.MouseDown += RenderingCanvas_MouseDown; this.MouseUp += RenderingCanvas_MouseUp; this.MouseWheel += RenderingCanvas_MouseWheel; this.KeyDown += RenderingCanvas_KeyDown; this.KeyUp += RenderingCanvas_KeyUp; // Add focus event handler this.GotFocus += RenderingCanvas_GotFocus; this.HandleCreated += OnHandleCreated; // Enable touch input and click events for the control this.SetStyle(ControlStyles.StandardClick, true); this.SetStyle(ControlStyles.StandardDoubleClick, true); this.TabStop = true; // Initialize the DispEngine with provided displayees DispEngine = new DispEngine(displayees); DispEngine.BackgroundColor = new Vec3d(0.1, 0.1, 0.5); DispEngine.BackgroundOpacity = 0.1; DispEngine.SetViewToHomeView(); DispEngine.ImageRequestAfterBufferSwapped += DispEngine_ImageRequestAfterBufferSwapped; // Set initial size and start the rendering engine this.Size = new System.Drawing.Size(500, 300); DispEngine.Start(this.ClientSize.Width, this.ClientSize.Height); } Rendering Pipeline The rendering pipeline processes images from DispEngine and displays them: private unsafe void DispEngine_ImageRequestAfterBufferSwapped(byte* bgra_unsignedbyte_pixels, int w, int h) { // Create a bitmap from the raw pixel data provided by DispEngine Bitmap bitmap; bitmap = new Bitmap(new Bitmap(w, h, w * 4, PixelFormat.Format32bppArgb, new IntPtr(bgra_unsignedbyte_pixels))); // Update the background image and dispose the previous one Image pre = this.BackgroundImage; this.BackgroundImage = bitmap; pre?.Dispose(); } Input Handling Windows Message Handling for Touch WinForm implementation intercepts Windows touch messages and forwards them to DispEngine: /// <summary> /// Processes Windows messages, handling touch input and forwarding other messages to the base class. /// </summary> /// <param name=\"m\">The Windows message to process.</param> protected override void WndProc(ref Message m) { if (m.Msg == WM_TOUCH) { HandleTouchInput(m.WParam, m.LParam); return; } base.WndProc(ref m); } private void OnHandleCreated(object sender, EventArgs e) { // Register window to receive touch messages RegisterTouchWindow(this.Handle, 0); } private void HandleTouchInput(IntPtr wParam, IntPtr lParam) { int inputCount = wParam.ToInt32(); TOUCHINPUT[] inputs = new TOUCHINPUT[inputCount]; if (!GetTouchInputInfo(lParam, inputCount, inputs, Marshal.SizeOf(typeof(TOUCHINPUT)))) return; try { for (int i = 0; i < inputCount; i++) { TOUCHINPUT ti = inputs[i]; int touchId = ti.dwID; // Convert touch coordinates to client coordinates Point touchPoint = PointToClient(new Point(ti.x / 100, ti.y / 100)); if ((ti.dwFlags & TOUCHEVENTF_DOWN) != 0) { // Touch down event DispEngine.TouchDown(touchId, touchPoint.X, touchPoint.Y); this.Focus(); } else if ((ti.dwFlags & TOUCHEVENTF_MOVE) != 0) { // Touch move event DispEngine.TouchMove(touchId, touchPoint.X, touchPoint.Y); } else if ((ti.dwFlags & TOUCHEVENTF_UP) != 0) { // Touch up event DispEngine.TouchUp(touchId); } } } finally { CloseTouchInputHandle(lParam); } } The key aspect is mapping Windows touch events to DispEngine's touch API: // Inside HandleTouchInput method if ((ti.dwFlags & TOUCHEVENTF_DOWN) != 0) { // Touch down event - delegate to DispEngine DispEngine.TouchDown(touchId, touchPoint.X, touchPoint.Y); this.Focus(); } else if ((ti.dwFlags & TOUCHEVENTF_MOVE) != 0) { // Touch move event - delegate to DispEngine DispEngine.TouchMove(touchId, touchPoint.X, touchPoint.Y); } else if ((ti.dwFlags & TOUCHEVENTF_UP) != 0) { // Touch up event - delegate to DispEngine DispEngine.TouchUp(touchId); } Mouse Events private void RenderingCanvas_MouseMove(object sender, MouseEventArgs e) { // Update mouse position and handle drag transforms DispEngine.MouseMove(e.Location.X, e.Location.Y); DispEngine.MouseDragTransform(e.Location.X, e.Location.Y, new mouse_button_table__transform_view_by_mouse_drag_t() { LEFT_BUTTON = (long)MouseButtons.Left, RIGHT_BUTTON = (long)MouseButtons.Right }); } private void RenderingCanvas_MouseDown(object sender, MouseEventArgs e) { // Handle mouse button press DispEngine.MouseButtonDown((long)e.Button); this.Focus(); } private void RenderingCanvas_MouseUp(object sender, MouseEventArgs e) { // Handle mouse button release DispEngine.MouseButtonUp((long)e.Button); } private void RenderingCanvas_MouseWheel(object sender, MouseEventArgs e) { // Handle mouse wheel for zoom operations DispEngine.MouseWheel(0, e.Delta / 120); DispEngine.MouseWheelTransform(0, e.Delta / 120); } Keyboard Events /// <inheritdoc/> protected override bool IsInputKey(Keys keyData) { //since in default, arrow does not trigger key event(keyDown and keyUp). return true; } /// <summary> /// Convert WinForms Keys to W3C KeyboardEvent.key string. /// </summary> static string WinFormsKeyToW3C(Keys key) => (key & Keys.KeyCode) switch { Keys.Home => \"Home\", Keys.End => \"End\", Keys.PageUp => \"PageUp\", Keys.PageDown => \"PageDown\", Keys.Left => \"ArrowLeft\", Keys.Right => \"ArrowRight\", Keys.Up => \"ArrowUp\", Keys.Down => \"ArrowDown\", Keys.LShiftKey or Keys.RShiftKey or Keys.ShiftKey => \"Shift\", Keys.LControlKey or Keys.RControlKey or Keys.ControlKey => \"Control\", Keys.LMenu or Keys.RMenu or Keys.Menu => \"Alt\", Keys.Return => \"Enter\", Keys.Escape => \"Escape\", Keys.Back => \"Backspace\", Keys.Tab => \"Tab\", Keys.Delete => \"Delete\", Keys.Insert => \"Insert\", Keys.Space => \" \", Keys.F1 => \"F1\", Keys.F2 => \"F2\", Keys.F3 => \"F3\", Keys.F4 => \"F4\", Keys.F5 => \"F5\", Keys.F6 => \"F6\", Keys.F7 => \"F7\", Keys.F8 => \"F8\", Keys.F9 => \"F9\", Keys.F10 => \"F10\", Keys.F11 => \"F11\", Keys.F12 => \"F12\", >= Keys.A and <= Keys.Z => ((char)('a' + ((key & Keys.KeyCode) - Keys.A))).ToString(), >= Keys.D0 and <= Keys.D9 => ((char)('0' + ((key & Keys.KeyCode) - Keys.D0))).ToString(), _ => \"Unidentified\" }; private void RenderingCanvas_KeyDown(object sender, KeyEventArgs e) { Focus(); string key = WinFormsKeyToW3C(e.KeyData); DispEngine.KeyDown(key); DispEngine.KeyDownTransform(key, new key_table__transform_view_by_key_pressing_t() { HOME = \"Home\", PAGE_UP = \"PageUp\", PAGE_DOWN = \"PageDown\", F1 = \"F1\", F2 = \"F2\", F3 = \"F3\", F4 = \"F4\", SHIFT = \"Shift\", ARROW_LEFT = \"ArrowLeft\", ARROW_RIGHT = \"ArrowRight\", ARROW_DOWN = \"ArrowDown\", ARROW_UP = \"ArrowUp\" }); } private void RenderingCanvas_KeyUp(object sender, KeyEventArgs e) { DispEngine.KeyUp(WinFormsKeyToW3C(e.KeyData)); } Lifecycle Management Window event handling ensures proper state management: private void RenderingCanvas_Resize(object sender, EventArgs e) { // Notify DispEngine of size changes DispEngine.Resize(this.ClientSize.Width, this.ClientSize.Height); } private void RenderingCanvas_VisibleChanged(object sender, EventArgs e) { // Update visibility state in DispEngine DispEngine.IsVisible = this.Visible; } Resource Cleanup /// <summary> /// Clean up any resources being used. /// </summary> /// <param name=\"disposing\">true if managed resources should be disposed; otherwise, false.</param> protected override void Dispose(bool disposing) { if (disposing && (components != null)) { // Dispose the DispEngine to free resources DispEngine.Dispose(); components.Dispose(); } base.Dispose(disposing); } WPF Implementation Details The WPF implementation uses WPF-specific controls and mechanisms but follows the same core pattern. Core Properties /// <summary> /// The DispEngine instance that handles rendering and user interactions /// </summary> public DispEngine DispEngine { get; } = new DispEngine(); /// <summary> /// Internal container for rendering content /// </summary> private UserControl DisplayerPane { get; } /// <summary> /// Dictionary to store touch point information /// </summary> private Dictionary<int, Point> TouchingPointsMap { get; } = new Dictionary<int, Point>(); /// <summary> /// Dictionary to store previous positions of touch points /// </summary> private Dictionary<int, Point> PreviousTouchingPointsMap { get; } = new Dictionary<int, Point>(); Initialization /// <summary> /// Initializes a new instance of the RenderingCanvas /// </summary> public RenderingCanvas() { DispEngine.BackgroundColor = new Vec3d(0.1, 0.1, 0.5); DispEngine.BackgroundOpacity = 0.1; // Configure the main control properties HorizontalAlignment = HorizontalAlignment.Stretch; VerticalAlignment = VerticalAlignment.Stretch; Focusable = true; KeyboardNavigation.SetDirectionalNavigation(this, KeyboardNavigationMode.Cycle); DataContextChanged += CanvasDataContextChanged; // Create and configure the display pane DisplayerPane = new UserControl(); DisplayerPane.HorizontalAlignment = HorizontalAlignment.Stretch; DisplayerPane.VerticalAlignment = VerticalAlignment.Stretch; DisplayerPane.Focusable = true; DisplayerPane.IsTabStop = true; // Connect event handlers for user input and window events DisplayerPane.SizeChanged += RenderingCanvas_SizeChanged; DisplayerPane.MouseMove += RenderingCanvas_MouseMove; DisplayerPane.MouseDown += RenderingCanvas_MouseDown; DisplayerPane.MouseUp += RenderingCanvas_MouseUp; DisplayerPane.MouseWheel += RenderingCanvas_MouseWheel; DisplayerPane.KeyDown += RenderingCanvas_KeyDown; DisplayerPane.KeyUp += RenderingCanvas_KeyUp; DisplayerPane.Loaded += RenderingCanvas_Loaded; DisplayerPane.Unloaded += RenderingCanvas_Unloaded; DisplayerPane.IsVisibleChanged += DisplayerPane_IsVisibleChanged; // Add touch event handlers DisplayerPane.TouchDown += RenderingCanvas_TouchDown; DisplayerPane.TouchMove += RenderingCanvas_TouchMove; DisplayerPane.TouchUp += RenderingCanvas_TouchUp; // Enable touch support this.IsManipulationEnabled = true; // Initialize power management InitializePowerManagement(); // Add the display pane to this control's content Content = DisplayerPane; } Rendering Pipeline /// <summary> /// Handles the buffer swapped event from DispEngine /// </summary> private unsafe void RenderingCanvas_BufferSwapped(byte* data, int w, int h) { if (data == null) return; Span<byte> bgra = new Span<byte>(data, w * h * 4); // Copy pixel data from DispEngine int n = w * h * 4; byte[] arr = new byte[n]; for (int i = 0; i < n; i++) arr[i] = data[i]; // Update UI on the UI thread DisplayerPane.Dispatcher.InvokeAsync(() => { BitmapSource bitmap = BitmapSource.Create(w, h, 1, 1, PixelFormats.Bgra32, null, arr, w * 4); DisplayerPane.Background = new ImageBrush(bitmap); }); } /// <summary> /// Handles the size changed event /// </summary> private void RenderingCanvas_SizeChanged(object sender, SizeChangedEventArgs e) { // Notify DispEngine of size changes DispEngine.Resize((int)DisplayerPane.RenderSize.Width, (int)DisplayerPane.RenderSize.Height); } /// <summary> /// Handles visibility changes /// </summary> private unsafe void DisplayerPane_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e) { // Update visibility state in DispEngine DispEngine.IsVisible = IsVisible; } Mouse and Keyboard Handling /// <summary> /// Helper method to get mouse button mask /// </summary> internal static HiMouseButtonMask GetMouseButtonMask(MouseDevice device) { HiMouseButtonMask mouseButtonMask = 0; mouseButtonMask.SetLeftPressed(device.LeftButton == MouseButtonState.Pressed); mouseButtonMask.SetMiddlePressed(device.MiddleButton == MouseButtonState.Pressed); mouseButtonMask.SetRightPressed(device.RightButton == MouseButtonState.Pressed); mouseButtonMask.SetXButton1Pressed(device.XButton1 == MouseButtonState.Pressed); mouseButtonMask.SetXButton2Pressed(device.XButton2 == MouseButtonState.Pressed); return mouseButtonMask; } /// <summary> /// Handles the mouse wheel event /// </summary> private void RenderingCanvas_MouseWheel(object sender, MouseWheelEventArgs e) { // Handle mouse wheel for zoom operations DispEngine.MouseWheel(0, e.Delta / 120); DispEngine.MouseWheelTransform(0, e.Delta / 120); } /// <summary> /// Handles the mouse up event /// </summary> private void RenderingCanvas_MouseUp(object sender, MouseButtonEventArgs e) { // Handle mouse button release DispEngine.MouseButtonUp((long)e.ChangedButton); (sender as UIElement)?.ReleaseMouseCapture(); } /// <summary> /// Handles the mouse down event /// </summary> private void RenderingCanvas_MouseDown(object sender, MouseButtonEventArgs e) { // Handle mouse button press DispEngine.MouseButtonDown((long)e.ChangedButton); DisplayerPane.Focus(); (sender as UIElement)?.CaptureMouse(); } /// <summary> /// Handles the mouse move event /// </summary> private void RenderingCanvas_MouseMove(object sender, MouseEventArgs e) { // Update mouse position and handle drag transforms Point p = e.GetPosition(DisplayerPane); DispEngine.MouseMove((int)p.X, (int)p.Y); DispEngine.MouseDragTransform((int)p.X, (int)p.Y, new mouse_button_table__transform_view_by_mouse_drag_t() { LEFT_BUTTON = (long)MouseButton.Left, RIGHT_BUTTON = (long)MouseButton.Right }); } /// <summary> /// Convert WPF Key to W3C KeyboardEvent.key string. /// </summary> static string WpfKeyToW3C(Key key) => key switch { Key.Home => \"Home\", Key.End => \"End\", Key.PageUp => \"PageUp\", Key.PageDown => \"PageDown\", Key.Left => \"ArrowLeft\", Key.Right => \"ArrowRight\", Key.Up => \"ArrowUp\", Key.Down => \"ArrowDown\", Key.LeftShift or Key.RightShift => \"Shift\", Key.LeftCtrl or Key.RightCtrl => \"Control\", Key.LeftAlt or Key.RightAlt => \"Alt\", Key.Return => \"Enter\", Key.Escape => \"Escape\", Key.Back => \"Backspace\", Key.Tab => \"Tab\", Key.Delete => \"Delete\", Key.Insert => \"Insert\", Key.Space => \" \", Key.F1 => \"F1\", Key.F2 => \"F2\", Key.F3 => \"F3\", Key.F4 => \"F4\", Key.F5 => \"F5\", Key.F6 => \"F6\", Key.F7 => \"F7\", Key.F8 => \"F8\", Key.F9 => \"F9\", Key.F10 => \"F10\", Key.F11 => \"F11\", Key.F12 => \"F12\", >= Key.A and <= Key.Z => ((char)('a' + (key - Key.A))).ToString(), >= Key.D0 and <= Key.D9 => ((char)('0' + (key - Key.D0))).ToString(), _ => \"Unidentified\" }; /// <summary> /// Handles the key up event /// </summary> private void RenderingCanvas_KeyUp(object sender, KeyEventArgs e) { DispEngine.KeyUp(WpfKeyToW3C(e.Key)); } /// <summary> /// Handles the key down event /// </summary> private void RenderingCanvas_KeyDown(object sender, KeyEventArgs e) { string key = WpfKeyToW3C(e.Key); DispEngine.KeyDown(key); DispEngine.KeyDownTransform(key, new key_table__transform_view_by_key_pressing_t() { HOME = \"Home\", PAGE_UP = \"PageUp\", PAGE_DOWN = \"PageDown\", F1 = \"F1\", F2 = \"F2\", F3 = \"F3\", F4 = \"F4\", SHIFT = \"Shift\", ARROW_LEFT = \"ArrowLeft\", ARROW_RIGHT = \"ArrowRight\", ARROW_DOWN = \"ArrowDown\", ARROW_UP = \"ArrowUp\" }); } Lifecycle Management /// <summary> /// Handles window state changes (maximize, minimize, etc.) /// </summary> private unsafe void RenderingCanvas_StateChanged(object sender, EventArgs e) { switch ((sender as Window).WindowState) { case WindowState.Maximized: DispEngine.IsVisible = true; break; case WindowState.Minimized: DispEngine.IsVisible = false; break; case WindowState.Normal: DispEngine.IsVisible = true; break; } } /// <summary> /// Handles data context changes /// </summary> private unsafe void CanvasDataContextChanged(object sender, DependencyPropertyChangedEventArgs e) { DispEngine pre = e.OldValue as DispEngine; DispEngine cur = e.NewValue as DispEngine; //child's binding event is triggered after IsVisible event and Load event. if (pre != null) //this section will never occur if the datacontext not set twice. { pre.Terminate(); pre.ImageRequestAfterBufferSwapped -= RenderingCanvas_BufferSwapped; } if (cur != null) { cur.ImageRequestAfterBufferSwapped += RenderingCanvas_BufferSwapped; cur.Start((int)DisplayerPane.RenderSize.Width, (int)DisplayerPane.RenderSize.Height); cur.IsVisible = IsVisible; } } /// <summary> /// Reference to the current window containing this control /// </summary> private Window currentWindow; /// <summary> /// Gets or sets the current window, connecting or disconnecting state change events /// </summary> Window CurrentWindow { get => currentWindow; set { if (currentWindow != null) currentWindow.StateChanged -= RenderingCanvas_StateChanged; currentWindow = value; if (currentWindow != null) currentWindow.StateChanged += RenderingCanvas_StateChanged; } } /// <summary> /// Handles the loaded event /// </summary> private unsafe void RenderingCanvas_Loaded(object sender, RoutedEventArgs e) { // Get the window containing this control CurrentWindow = Window.GetWindow(this); // Set up DispEngine rendering DispEngine.ImageRequestAfterBufferSwapped -= RenderingCanvas_BufferSwapped; DispEngine.ImageRequestAfterBufferSwapped += RenderingCanvas_BufferSwapped; DispEngine.Start((int)DisplayerPane.RenderSize.Width, (int)DisplayerPane.RenderSize.Height); DispEngine.IsVisible = IsVisible; } /// <summary> /// Handles the unloaded event /// </summary> private unsafe void RenderingCanvas_Unloaded(object sender, RoutedEventArgs e) { DispEngine.IsVisible = IsVisible; DispEngine.ImageRequestAfterBufferSwapped -= RenderingCanvas_BufferSwapped; CurrentWindow = null; } Resource Cleanup /// <summary> /// Flag to track disposed state /// </summary> private bool disposedValue; /// <summary> /// Disposes managed resources /// </summary> protected virtual void Dispose(bool disposing) { if (!disposedValue) { if (disposing) { // Unsubscribe from power events SystemEvents.PowerModeChanged -= SystemEvents_PowerModeChanged; // Dispose the DispEngine to free resources DispEngine.Dispose(); } disposedValue = true; } } /// <summary> /// Public dispose method to free resources /// </summary> public void Dispose() { // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method Dispose(disposing: true); GC.SuppressFinalize(this); } Core DispEngine Integration Patterns 1. Initialization Sequence // Create DispEngine (optionally with displayees) var engine = new DispEngine(displayees); // Set up image buffer callback engine.ImageRequestAfterBufferSwapped += OnBufferSwapped; // Initialize with canvas size engine.Start(width, height); // Set initial view (optional) engine.SetViewToHomeView(); 2. Render Loop The rendering process follows this pattern: DispEngine processes IDisplayee objects Buffer is swapped and callback is triggered UI framework renders the buffer to screen User input triggers view updates Process repeats 3. Complete User Input Mapping All user interactions must be mapped to DispEngine methods: User Action DispEngine Method Mouse move MouseMove(int, int) Mouse drag MouseDragTransform(int, int, mouse_button_table__transform_view_by_mouse_drag_t) Mouse button MouseButtonDown(long) / MouseButtonUp(long) Mouse wheel MouseWheel(int, int) and MouseWheelTransform(int, int, double) Key press KeyDown(string) / KeyUp(string) and KeyDownTransform(string, key_table__transform_view_by_key_pressing_t) Touch events TouchDown(int, int, int) / TouchMove(int, int, int) / TouchUp(int) 4. Proper Resource Cleanup Resource management is critical for proper operation: // In dispose method DispEngine.ImageRequestAfterBufferSwapped -= OnBufferSwapped; DispEngine.Terminate(); DispEngine.Dispose(); Advanced Implementation Considerations When creating custom implementations, consider these aspects: View Manipulation Use SketchView to directly access or modify the view matrix: // Get current view matrix Mat4d currentView = engine.SketchView; // Apply custom rotation Mat4d rotation = Mat4d.RotateX(Math.PI/4); engine.SketchView = currentView * rotation; See Also DispEngine IDisplayee Vec2d Mat4d Using RenderingCanvas with DispEngine — the shipped controls this guide reimplements"
  },
  "technique/rendering/drawing.html": {
    "href": "technique/rendering/drawing.html",
    "title": "Using Hi.Disp.Drawing | HiAPI-C# 2025",
    "summary": "Using Hi.Disp.Drawing The Drawing class is the most fundamental and efficient rendering unit that allows you to draw points, lines, and surfaces within the DispEngine. Understanding Drawing Structure Looking at the constructor Drawing(double[], Stamp, int) helps explain its structure: The double[] array contains batch data for rendering, composed of one or more data groups of consistent length Each data group's length is determined by the Stamp parameter Each data group describes a single vertex Data Components A data group can contain up to four types of information: Information Abbreviation Description Size Vertex V The position of the point (x, y, z) 3 doubles Normal N The normal vector affecting light reflection (Nx, Ny, Nz) 3 doubles Color C RGB color values ranging from 0 to 1 3 doubles Pick ID P A single double value converted from an integer for selection operations 1 double The Stamp enumeration combines these abbreviations to create these possible stamps: {V, NV, CV, CNV, PV, PNV, PCV, PCNV}. Important Notes: The Vertex (V) is mandatory, which is why V appears in every Stamp option Normal vectors (N) are typically used for 3D graphics to create a sense of depth through lighting Color (C) uses three double values (R, G, B) in the range of 0 to 1 Pick ID (P) is used for graphical selection operations Data Structure Example If Stamp is V, each data group consists of 3 double values (x, y, z) If Stamp is PCV, each data group consists of 1(P) + 3(C) + 3(V) = 7 double values Rendering Mode The glPrimitive parameter is an OpenGL constant that specifies the drawing mode, and the same value stays settable afterwards through the GlPrimitive property. Illustrations of the available modes are published under the name “OpenGL Primitives”. Example Usage // Creating a simple line strip with three vertices double[] vertices = new double[] { 0, 0, 0, // First point at origin 1, 0, 0, // Second point along X-axis 0, 0, 1 // Third point along Z-axis }; // Create drawing object using the vertices var drawing = new Drawing(vertices, Stamp.V, (int)OpenGL.GL_LINE_STRIP); This example creates three vertices with only position information (V), so each vertex has just xyz coordinates. The drawing mode is set to LineStrip. Performance Considerations Note After a Drawing object is created, its source data is stored in GPU memory. Regardless of the amount of data, the CPU processing load when calling Display(Bind) remains consistent. This means displaying 100 points with one Drawing object is approximately 100 times faster than using 100 separate Drawing objects to display 100 individual points. Composing Multiple IDisplayee Objects A common pattern is to combine multiple IDisplayee objects, including Drawing objects: public class MyCompositeDisplayee : IDisplayee { private readonly List<IDisplayee> _displayees = new List<IDisplayee>(); public MyCompositeDisplayee() { // Create a grid drawing _displayees.Add(CreateGridDrawing()); // Create an axes drawing _displayees.Add(CreateAxesDrawing()); // Add other custom drawings _displayees.Add(CreateCustomDrawing()); } private Drawing CreateGridDrawing() { // Code to create a grid double[] gridVertices = new double[/* grid data */]; return new Drawing(gridVertices, Stamp.CV, (int)OpenGL.GL_LINES); } private Drawing CreateAxesDrawing() { // Create colored axes double[] axesData = new double[] { // Red X-axis (with color) 1, 0, 0, 0, 0, 0, // Red color, origin 1, 0, 0, 1, 0, 0, // Red color, x-axis end // Green Y-axis (with color) 0, 1, 0, 0, 0, 0, // Green color, origin 0, 1, 0, 0, 1, 0, // Green color, y-axis end // Blue Z-axis (with color) 0, 0, 1, 0, 0, 0, // Blue color, origin 0, 0, 1, 0, 0, 1 // Blue color, z-axis end }; return new Drawing(axesData, Stamp.CV, (int)OpenGL.GL_LINES); } public void Display(Bind bind) { // Render all contained displayees foreach (var displayee in _displayees) { displayee.Display(bind); } } public void ExpandToBox3d(Box3d box) { // Update bounding box based on all displayees foreach (var displayee in _displayees) { displayee.ExpandToBox3d(box); } } } Creating Common Shapes Here are some examples of creating common shapes using the Drawing class: Creating Points // Create an array of points double[] pointData = new double[] { 0, 0, 0, // Point 1 1, 1, 1, // Point 2 2, 0, 0, // Point 3 0, 2, 0 // Point 4 }; // Create a Drawing for points var pointDrawing = new Drawing(pointData, Stamp.V, (int)OpenGL.GL_POINTS); Creating Lines // Create line segments (pairs of vertices) double[] lineData = new double[] { 0, 0, 0, 1, 1, 0, // Line 1: (0,0,0) to (1,1,0) 2, 0, 0, 2, 2, 0 // Line 2: (2,0,0) to (2,2,0) }; // Create a Drawing for lines var lineDrawing = new Drawing(lineData, Stamp.V, (int)OpenGL.GL_LINES); Creating Triangles // Create triangles (triplets of vertices) double[] triangleData = new double[] { // Triangle 1 0, 0, 0, // Vertex 1 1, 0, 0, // Vertex 2 0, 1, 0 // Vertex 3 }; // Create a Drawing for triangles var triangleDrawing = new Drawing(triangleData, Stamp.V, (int)OpenGL.GL_TRIANGLES); See Also DispEngine IDisplayee DispList Using RenderingCanvas with DispEngine — the control that hosts the engine these drawings are rendered by Color Guide System — deciding the colour and priority a drawn step comes out with"
  },
  "technique/rendering/index.html": {
    "href": "technique/rendering/index.html",
    "title": "Rendering | HiAPI-C# 2025",
    "summary": "Rendering How HiAPI puts geometry on a screen. The whole system rests on one relationship — a DispEngine renders IDisplayee objects — so every page here is either a way to host the engine in a UI framework, a way to produce something for it to render, or a way to decide what colour the result comes out. Ordered from hosting the engine to feeding it: the canvas first, then what is drawn on it. Hosting the Engine Using RenderingCanvas with DispEngine — The shipped canvas controls for Windows Forms and WPF, the DispEngine surface they expose, and the input and camera operations that come with it Building Your Own Rendering Canvas — What a canvas has to implement to host a DispEngine on a framework HiAPI ships no control for, shown against both reference implementations What Gets Drawn Using Hi.Disp.Drawing — The primitive rendering unit for points, lines and surfaces, and how to compose displayees without paying for each one Color Guide System — Assigning colour and rendering priority per machining step, and what priority decides when many steps land in one pixel See Also Mechanism — the topology that decides where a displayee is drawn API Foundations — the packages, geometry types and services this sits on HiAPI Packages and Sample Code — which package a Windows Forms or WPF application needs"
  },
  "technique/rendering/rendering-canvas.html": {
    "href": "technique/rendering/rendering-canvas.html",
    "title": "Using RenderingCanvas with DispEngine | HiAPI-C# 2025",
    "summary": "Using RenderingCanvas with DispEngine The RenderingCanvas is the primary UI component for displaying and interacting with 3D content across different platforms. This section explains how to use it with the DispEngine to create cross-platform applications. Overview The RenderingCanvas class is available in frameworks: Hi.WinForm for Windows Forms applications Hi.WpfPlus for WPF applications All implementations share a common architecture centered around the DispEngine class, enabling consistent rendering and interaction across platforms. Core Concept: DispEngine and IDisplayee At the heart of the rendering system is the relationship between DispEngine and IDisplayee: DispEngine: The rendering engine that manages the OpenGL context and handles user interaction IDisplayee: The interface that defines objects that can be rendered by the DispEngine This relationship is fundamental - the purpose of DispEngine is to render IDisplayee objects. graph TD A[IDisplayee Objects] -->|Rendered by| B B[DispEngine] <--> C[RenderingCanvas UI Component] Working with IDisplayee Objects implementing IDisplayee define what gets rendered. Typically, you'll use Drawing objects or compose multiple IDisplayee objects together: // Create a composite displayee public class MyCompositeDisplayee : IDisplayee { private List<IDisplayee> _displayees = new List<IDisplayee>(); public MyCompositeDisplayee() { // Add various displayees _displayees.Add(new AxesDisplayee()); _displayees.Add(new ModelDisplayee()); } public void Display(Bind bind) { // Render all contained displayees foreach (var displayee in _displayees) { displayee.Display(bind); } } public void ExpandToBox3d(Box3d box) { // Update bounding box based on all displayees foreach (var displayee in _displayees) { displayee.ExpandToBox3d(box); } } } For more detailed information on creating displayees with Drawing, see the Drawing section. Basic Usage Apply Hi.WinForm // Create a new instance with displayee objects using Hi.WinForm.Disp; // Create displayee object var displayee = new MyCompositeDisplayee(); // Initialize canvas with the displayee var canvas = new RenderingCanvas(displayee); // Access the DispEngine for direct manipulation DispEngine engine = canvas.DispEngine; // Add to a form myForm.Controls.Add(canvas); Apply Hi.WPF // Create a new instance using Hi.WpfPlus.Disp; // Create displayee object var displayee = new MyCompositeDisplayee(); // Initialize the canvas var canvas = new RenderingCanvas(); // Set displayee objects through the DispEngine canvas.DispEngine.Displayee = displayee; // Add to a container myGrid.Children.Add(canvas); Switching Displayees at Runtime You can dynamically change what's being displayed: // Switch to a different displayee renderingCanvas.DispEngine.Displayee = alternativeDisplayee; // Or update a DispList var displayList = new DispList(); if (showModel) displayList.Add(modelDisplayee); if (showGrid) displayList.Add(gridDisplayee); renderingCanvas.DispEngine.Displayee = displayList; Key Features of DispEngine The DispEngine provides cross-platform support for: Handles buffer swapping and image generation Mouse/pointer events Keyboard navigation Touch gestures Zoom, pan, and rotate operations Resize and Visibility changed. Camera positioning and orientation Standard views (front, top, isometric, etc.) Renders IDisplayee implementations Touch and Gesture Support The DispEngine centralizes touch handling across all platforms with a unified API that supports: Single-finger pan Two-finger rotate and scale Multi-finger specialized operations The touch API is designed to be simple for UI implementations to use. Platform-specific UI components only need to capture touch events and forward them to the DispEngine. Common Operations // Accessing DispEngine (works on all platforms) var engine = renderingCanvas.DispEngine; // Set to standard views engine.SetViewToHomeView(); engine.SetViewToFrontView(); // Manual camera manipulation engine.Translate(dx, dy); engine.Rotate(deltaX, deltaY); // Resize handling engine.Resize(width, height); Implementation Details For detailed implementation information, including: Full source code examples Implementation details for each platform Advanced touch handling Custom implementation guidance See the Building Your Own Rendering Canvas guide. See Also DispEngine IDisplayee DispList Building Your Own Rendering Canvas — what a canvas has to implement to host the engine itself Drawing — producing the displayees this canvas renders"
  },
  "technique/scripting/cutter-location-playback.html": {
    "href": "technique/scripting/cutter-location-playback.html",
    "title": "Cutter-Location (CL) Playback | HiAPI-C# 2025",
    "summary": "Cutter-Location (CL) Playback PlayClFile replays a CAM cutter-location file — an NX CLSF (.cls) / APT-source toolpath — directly as tool motion, without a post-processor. Use it to verify the programmed toolpath itself (gouge, overcut, engagement) before it is post-processed for any particular machine. The same file can also be played onto a real machine-tool chain, and a played CL program can be written back out as Fanuc NC — see Two chains, two questions and Converting CL to NC. CL vs. NC — two different inputs PlayNcFile (NC / G-code) PlayClFile (CL / CLSF) Source Post-processed G-code for one specific machine CAM cutter-location output, before post-processing, machine-independent Content Axis moves (G01 X.. Y.. Z..), work offsets, canned cycles Cutter locations (GOTO), arcs (CIRCLE), tool axis vectors Drives A machine-tool chain (X/Y/Z/A/B/C axes) through kinematics Either chain — see below Answers “What does this machine do with this program?” “Is the programmed path correct?” — or, on a machine chain, both questions at once A cutter location is a point plus a tool-axis direction in workpiece coordinates. PlayClFile places the tool at each location in turn and sweeps the removed material between them. Two chains, two questions The chain configured in project setup decides what a CL play means. On a ClMillingDevice the cutter location is applied straight to the tool: no inverse kinematics, no work-coordinate offsets, no controller dialect. This is the machine-independent check — it answers whether the CAM output itself is correct, and it is the right chain when you do not yet know which machine will run the job. On a machine-tool chain every CLSF motion endpoint is inverse-solved at parse time and expressed in the same program-to-machine transform vocabulary the NC pipeline uses — a tool-height entry from the active tool, a pivot entry anchored to the workpiece frame, and the solved rotary axes — so the shared machine-coordinate and rotary-wrap handling is reused unchanged. This answers what a particular machine would do with the path, including reach and rotary behaviour, without a post-processor in between. Note A machine-chain play needs the project's kinematics to resolve to a live solver. Where an endpoint cannot be solved, the motion is reported rather than silently dropped — watch for ClToMc--EndpointIkFailed and ClToMc--NoToolOffset in the diagnostics. Converting CL to NC ConvertClToNcFiles writes a played CL program back out as Fanuc NC, one file per source file, template-substituting [NcName] (default Output/[NcName].nc). It requires a prior play on a machine chain — a ClMillingDevice leaves no machine-solved data to serialize — and reports ConvertClToNc--NoPlay otherwise. A mission can declare the writeback through EnableConvertClToNcFiles and ClToNcFileTemplate. File format The reader parses NX CLSF records (the APT-source language): Record Effect GOTO Cutter location — first one positions the tool (rapid teleport); subsequent ones cut a straight CL path CIRCLE / MOVARC Arms an arc; the following GOTO closes it into a true circular CL path RAPID Marks the next move as a non-cutting rapid FEDRAT Feed rate (MMPM / IPM) SPINDL Spindle speed and direction COOLNT Coolant mode (ON / FLOOD / MIST / OFF) TLDATA Tool geometry (diameter, corner radius, length, angles) LOAD/TOOL Tool change to a tool id Comments ($$ to end of line) and line continuation (trailing $) are honored. Records outside this set (PAINT, TOOLNO, TOOL PATH, …) are skipped. Note “APT” here means the APT toolpath language (GOTO, CIRCLE, …). This is a different use of the word from the Cutter Geometry page, which defines cutter geometry. A CL file's TLDATA feeds that same tool-geometry model — see below. The dialect parsed is Siemens NX (.cls). Other CAM systems emit the same APT record family under different names (CATIA APTSOURCE, Creo CL files); those dialects are not yet parsed. Tools from the file A CL file usually carries its own tool definitions. On LOAD/TOOL,<id>, if the tool house has no matching id, the preceding TLDATA geometry is used to create the tool automatically. An id already present in the tool house keeps its configured tool — so you can pre-configure tools for accuracy, or let simple files be self-contained. Example // The machining chain must be a ClMillingDevice (set in project setup). MachiningResolution_mm = 0.125; EnablePhysics = false; // geometry-only check first PlayClFile(\"CL/part-op10.cls\"); // replay the CAM cutter-location file Diff(\"target/part-op10.stl\"); // compare the cut against the design target The project keeps a dedicated CL runner suit (ClsfRunnerSuit) alongside its NC and CSV suits; the parser itself is the NxClRunner preset. See Also PlayClFile — the script command ClMillingDevice — the cutter-location-driven chain Cutter Geometry — cutter geometry (the other meaning of “APT”) Script Commands — what is a script command"
  },
  "technique/scripting/index.html": {
    "href": "technique/scripting/index.html",
    "title": "Scripting | HiAPI-C# 2025",
    "summary": "Scripting How a HiNC session is driven from C#: the command surface a script is written against, the step objects a run produces, and the message stream it reports through. The same commands run from the app's script panels, from inside an NC comment, and from a hosted session, so this section describes the surface rather than the screen. Ordered the way a script meets them — the language and its global scope first, then what a run produces and how it reports, then the one input that is not G-code. Writing a Script Script Command — The C# syntax, the session lifecycle a command runs inside, ;@ commands embedded in NC, and the [NcName] output template SessionShell — The global scope every command resolves against, mapped family by family onto the work each family does What a Run Produces Step — The computation unit, one spindle revolution by default: its custom variables, and how a script reads and exports it Step Field Reference — What each group of per-step output covers, and the two values that are most often misread ShellProgress — The four message severities, tag filtering, and exporting a session log Playing Something Other Than G-code Cutter-Location (CL) Playback — Replaying a CAM cutter-location file before it is post-processed, and what the chain choice decides See Also Milling Physics — what the per-step values a script exports are measuring NC Optimization — the optimizer that the Opt* settings on this surface drive"
  },
  "technique/scripting/script-command.html": {
    "href": "technique/scripting/script-command.html",
    "title": "Script Commands | HiAPI-C# 2025",
    "summary": "Script Commands What Is a Script Command? A script command is a C# statement executed by the HiNC scripting engine. Scripts directly reference members and methods of SessionShell, which serves as the global scope — no explicit object reference is needed. // These are all SessionShell members used directly as globals EnablePhysics = true; MachiningResolution_mm = 0.125; PlayNcFile(\"NC/file1.nc\"); Message(\"Done\"); Script Syntax Basics Scripts use native C# syntax: Feature Syntax Statement terminator ; End-of-line comment // comment String interpolation $\"Value is {variable}\" Positive infinity double.PositiveInfinity Negative infinity double.NegativeInfinity Bitwise OR (for flags) Fx|Fy|Fz All standard C# language features (variables, loops, conditionals, LINQ, etc.) are available. Execution Model Session Lifecycle Scripts execute in order on the Task page A PacePlayer(API) controls playback — script commands like PlayNcFile(API) block until the NC program completes Player control commands (Pace()(API), Pause()(API), Reset()(API)) interact with the PacePlayer(API) ResetRuntime(API) clears event handlers, buffers, and runtime state Event-Driven Execution Events like SessionStepBuilt(API) fire during simulation and allow per-step logic: SessionStepBuilt += (preStep, curStep) => { if (curStep != null) Message($\"Step: ToolId={curStep.ToolId}\"); }; PlayNcFile(\"NC/file1.nc\"); Events are cleared by ResetRuntime. Script Commands in NC Code Script commands can be embedded inside NC code comments. Lines starting with ;@ execute before that NC line runs: The marker is read inside the line's comment, so the comment character is the controller's own. Where ; opens a comment: T01 M06 ;@MachiningResolution_mm=0.03125; S1270 M03 G43 Z10. H01 For controllers that do not support ; as a comment character (FANUC and the other ( ) dialects), the same marker goes inside the parentheses: T01 M06 (;@MachiningResolution_mm=0.03125;) S1270 M03 G43 Z10. H01 File Path Templates Commands that output files support the [NcName] token, which is replaced with each NC file name: PlayNcFile(\"NC/file1.nc\"); PlayNcFile(\"NC/file2.nc\"); WriteShotFiles(\"Output/[NcName].shot.csv\", 1); // Produces: Output/file1.nc.shot.csv, Output/file2.nc.shot.csv All file paths are relative to the project directory unless an absolute path is given. Important Warnings The following operations can corrupt simulation state or produce incorrect results: Do not save the project during simulation. System-internal configuration (e.g., training-specific resolution overrides) may overwrite your settings. Do not reset the player during milling coefficient training. Close the project instead of pressing the reset button to avoid unexpected errors. Do not modify resolution, tool, or controller settings during training. Changing these mid-training invalidates the results. Do not combine UpdateNcOptOption in SessionStepBuilt(API) with NC-embedded optimization commands. Parallel computation may cause undefined behavior. Do not write NaN into a per-step NcOptOption. A NaN feed-per-tooth boundary is refused when the step is solved: that step keeps its simulated feed rate and is reported as an error naming the option values, and the rest of the run is optimized normally. See When a Step Cannot Be Solved. Global Variables Global provides a key-value dictionary for sharing data across scripts: Global[\"material\"] = \"Steel\"; var material = Global[\"material\"]; Full API Reference For the complete list of available commands, properties, and events, see: SessionShell — full API documentation SessionShell — the command families, and which workflow uses each See Also SessionShell — the command families this syntax reaches Step — machining step data model Workflow: Basic Machining Simulation — using scripts in a simulation workflow Cutter-Location (CL) Playback — replaying a CL toolpath from a script ShellProgress — the message stream a running script writes to NC Optimization — what a per-step optimization option does, and how a step that fails to solve is reported"
  },
  "technique/scripting/session-shell.html": {
    "href": "technique/scripting/session-shell.html",
    "title": "SessionShell | HiAPI-C# 2025",
    "summary": "SessionShell SessionShell is the global scope of the HiNC scripting engine: a script names its members directly, with no object reference and no using. Everything a script does to a session — start a playback, set a resolution, export a file, train a coefficient, read a step — is a member of this one type. The complete and current list of commands, properties and events is the generated SessionShell reference. This page is the map onto it — which family does what, and which workflow reaches for it. The members are deliberately not re-listed here: a hand-copied index of an API drifts the moment the API changes, and nothing in the build can catch it. Command Families Family What it does Where it is used Playback Runs a program — NC files and NC strings, CSV-driven playback, cutter-location files, and tool teleports. Parse-only variants return the action sequence without pacing it. Workflow: Basic Machining Simulation, Cutter-Location (CL) Playback Player control Paces, pauses and resets the running player: the checkpoints a script inserts into a playback. Workflow: Basic Machining Simulation Resolution and cache Workpiece entity resolution, motion resolution mode, display cache size. The largest single influence a script has on run time. Workflow: Basic Machining Simulation, CPU Usage During Simulation Physics switches Whether milling force, wear effect and collision detection are evaluated; angular divisions per revolution; initial spindle temperature; whether a failure or a collision pauses the run. Workflow: Milling Force Parameter Training, Workflow: Geometry Validation Data export Step-level CSV and waveform (shot) CSV, both accepting the [NcName] template. Workflow: Basic Machining Simulation, Workflow: Milling Force Parameter Training Sensor mapping Puts measured data alongside the simulated run: one-to-one and series mapping from CSV, time-range selection written into NC comments, and clearing what was mapped. Workflow: Sensor Data Mapping Training Trains milling coefficients from mapped data, calibrates existing ones, and loads cutting parameters into the workpiece. Workflow: Milling Force Parameter Training Optimization The optimizer's file output and its whole settings surface — feed-rate and re-interpolation switches, feed and acceleration limits, the four safety factors, the target force, the preserve ranges that exempt lines, and the per-step log. Workflow: NC Optimization Geometry Reads, writes and exports meshed geometry (STL / OBJ / PLY), compares the cut against a target, removes disconnected residual material, and scans for defects. Workflow: Geometry Validation Messages The four message severities and the file export, all routed through ShellProgress. all workflows Step access Reads a step by index, reports the step count, and registers custom step variables. Step Events Per-step hooks that fire as a step is built or selected. Workflow: NC Optimization Runtime management Clears event handlers, buffers and runtime state, and carries data between scripts through the Global dictionary. Script Commands Tool setup Adjusts contour shift angle and smart-holder observation height at run time. Smart Tool Holder Coefficient Training What the Generated Reference Does Not Say Tool setup is for a mismatch, not for configuration. Those members exist for the case where the actual installation differs from the configured tool. Where the two agree, set the value in the tool configuration file instead — a script that sets it is silently overriding what everyone else reads. The geometry family answers to hidden legacy names. WriteRuntimeGeom / ReadRuntimeGeom / ExportRuntimeGeomTo* / ScanRuntimeGeomInfDefect still run in existing player scripts as aliases of the MeshedGeom names; new scripts use the new names. The full mapping is in Renames with no shim. Resetting the runtime does not clear the record. Event handlers, buffers and runtime state go; messages already recorded stay — see ShellProgress. See Also SessionShell — the generated reference this page maps Script Commands — the syntax and lifecycle a command runs inside Step — the data model the step-access family returns ShellProgress — the message host the message family writes to"
  },
  "technique/scripting/shell-progress.html": {
    "href": "technique/scripting/shell-progress.html",
    "title": "ShellProgress | HiAPI-C# 2025",
    "summary": "ShellProgress What Is ShellProgress? ShellProgress (ShellProgress) is the message host object that manages all messages generated during a HiNC scripting session. It serves as the central hub for logging, filtering, and exporting diagnostic information. Note This host was previously named SessionProgress (and earlier SessionMessageHost); those names are superseded by ShellProgress. Message Types HiNC provides four message types, each with a distinct severity and typical display behavior: Type Command Description Typical Display Message Message General informational message Message panel ProgressMessage ProgressMessage Progress-related status update Progress bar / status area WarningMessage WarningMessage Warning (does not interrupt execution) Message panel (yellow) ErrorMessage ErrorMessage Error (may affect execution flow) Message panel (red) Usage Examples Message(\"Starting simulation\"); ProgressMessage(\"Loading workpiece...\"); WarningMessage(\"No cutting engagement detected in this segment\"); ErrorMessage(\"Workpiece does not exist\"); Message Tags Messages can be tagged for filtering. Standard tags include \"Error\" and \"Warning\". When exporting messages, you can filter by one or more tags. Displaying Messages All messages are automatically recorded in the session message host and appear in the HiNC UI message panel. Progress messages additionally update the progress bar. Accessing the Message Host var messageHost = ShellProgress; Exporting Messages AppendMessagesToFile writes messages to a text file, with optional tag-based filtering: // Export all messages AppendMessagesToFile(\"Output/messages.txt\"); // Export only errors and warnings AppendMessagesToFile(\"Output/errors.txt\", \"Error\", \"Warning\"); Tip Export messages after simulation to create a persistent log for debugging or reporting. Common Patterns Logging Simulation Progress Message(\"Simulation started\"); PlayNcFile(\"NC/file1.nc\"); Message($\"Simulation complete. Total steps: {StepCount}\"); AppendMessagesToFile(\"Output/log.txt\"); Conditional Warnings if (StepCount == 0) { WarningMessage(\"No steps were executed\"); } Error Guard if (Workpiece == null) { ErrorMessage(\"Workpiece does not exist\"); return; } Per-Step Logging via Events SessionStepBuilt += (preStep, curStep) => { if (curStep != null) Message($\"Step {curStep.StepIndex}: ToolId={curStep.ToolId}\"); }; PlayNcFile(\"NC/file1.nc\"); Step Selection Logging MachiningStepSelected += (step) => { if (step != null && step.ToolId == 1) ProgressMessage($\"Tool 1 step selected at line {step.LineNo}\"); }; Message Lifecycle Messages are generated during script execution via the four message commands All messages are stored in the ShellProgress host object Messages persist until the session ends or the runtime is reset ResetRuntime() clears event handlers but does not clear previously recorded messages Messages can be exported at any point using AppendMessagesToFile See Also Script Commands — script command basics SessionShell — SessionShell quick-reference Workflow: Basic Machining Simulation — using messages in a simulation workflow Message Management — the three application-level channels this session-scoped host is one face of"
  },
  "technique/scripting/step-fields.html": {
    "href": "technique/scripting/step-fields.html",
    "title": "Step Field Reference | HiAPI-C# 2025",
    "summary": "Step Field Reference Every simulated step carries a row of output: the NC line it came from, the kinematics, the load, and what that load did to the cutter. The field-by-field definitions are generated — MachiningStep is the complete and current list, and it is not copied here. This page states what each group covers, how the numbers are to be read, and the two readings that are most often misread. How a Step's Numbers Are Formed A step's data covers the time interval between two consecutive steps — from the previous step to this one — not an instant. Most fields are therefore a simplification over that period, and the prefix says which: Avg (average), Min / Max (extremes), Delta (range) and MaxAbs (maximum absolute value). A field that depends on a frame carries the frame in its name: [W] workpiece, [TR] tool running, [SR] spindle rotation. The frames themselves are defined in Milling Physics Coordinates. Field Groups Group What it covers Source The file, line, line text and flags of the NC command that produced the step, its index in the run, and the active tool id Time and motion End-of-step timecode, step duration (one spindle revolution in the default per-revolution mode), spindle angle at the start, the cutter location with its IJK normal, the machine coordinates, the displacement in program coordinates, and the feed / spindle-speed / cutting-speed / per-tooth family Engagement and removal Whether the cutter was engaged at all, radial and axial engagement (ae, ap), material removal rate, and the program-side cusp height and its distribution Chip Chip thickness, volume and mass Force and torque Average and maximum force on the tool, torques about the tool tip and about the sensor point in each frame, and the mapping-comparison fields that put a measured signal beside the simulated one — error ratios and symbolic error correlation Power and energy Spindle input power (what enters the spindle) and output power (what reaches the cut after spindle losses; the ratio between them is the spindle's configured EnergyEfficiency(API)), the instantaneous and continuous power and torque ratios against the spindle capability curve, and accumulated energy consumption Thermal Cutter body, cutter surface, workpiece surface and chip temperatures, cutter subsurface temperature at a given depth, and thermal stress with its yield ratio Wear and deflection Instantaneous and accumulated crater wear, accumulated flank wear depth and width, tool tip and bottom-edge deflection, and re-cut depth For what the thermal yield ratio implies about breakage risk see Evaluating Process Machinability; for the wear model behind the wear fields see Tool Life and Wear. Note EndTimecode was named AccumulatedTime before the rename, and step CSVs written with the legacy header are still read. Two Readings That Are Usually Misread A cusp spike is usually a rapid-move collision, not a finish result The program-side cusp is computed from the ideal program feedrate while the cutter is engaged with the workpiece. A rapid traverse is not meant to touch material; when it does, the cusp formula is fed the (very high) rapid feedrate, so the value spikes far above any real cutting cusp. Treat an isolated cusp peak at a rapid / G00 line as a likely gouge or collision to investigate. The same engagement-during-rapid usually shows up beside it as spikes in the availability ratios — yielding stress, spindle torque, spindle power. A power or torque ratio over 100% is load damage, and it is read by duration A ratio above 100% means the spindle cannot supply the demanded load at the commanded rpm, so it droops: with feed held, rpm drops, feed-per-tooth rises, and forces climb further — a runaway loop that, left unchecked, grows the chip until the cutter breaks and the spindle and drive are overstressed. That is load damage, not a tool-versus-workpiece collision (see NC optimization). Read it by duration, not just by height. A one-revolution overshoot usually still completes the pass, leaving a slightly insufficient cut there; a ratio that stays above 100% across many consecutive spindle revolutions is a genuine overload to fix. A high-load step typically also shows large cutter–workpiece engagement, large tip deflection, and more vibration and noise. Because the ratio is normalized by the spindle-capability curve, a placeholder or guessed spindle skews it — confirm against the real spindle's speed–power and speed–torque curves before calling a cut overloaded. See Also Step — what a step is, and when one is produced Spindle Capability — the curves that normalize the power and torque ratios above Milling Physics Coordinates — what the [W] / [TR] / [SR] marks on these fields mean"
  },
  "technique/scripting/step.html": {
    "href": "technique/scripting/step.html",
    "title": "Step | HiAPI-C# 2025",
    "summary": "Step What Is a Step? A MachiningStep (MachiningStep) is a single computation unit in the HiNC simulation. By default, one step corresponds to one spindle revolution, but this interval is configurable via the Basic Simulation workflow. Each step contains data for the time interval between two consecutive steps (from the previous step to the current step). Since this represents a period rather than an instant, many fields are simplified representations using prefixes like Average (Avg), Extremes (Min, Max), Range (Delta), and Maximum Absolute Value (MaxAbs). Registering Custom Step Variables Beyond default properties, you can register custom step variables using RegisterStepVariable: RegisterStepVariable( \"ChipVolume\", // key \"Chip Volume\", // display name \"mm3\", // unit \"F2\", // format string (step) => step.ChipVolume_mm3 // value function ); PlayNcFile(\"NC/file1.nc\"); Parameters: key: Unique identifier name: Display name (shown in UI) unit: Physical unit (can be null) formatString: .NET numeric format string (can be null) variableFunction: Lambda that computes the value from a step (can be null) Registered variables appear in the UI and in output files from WriteStepFiles. Indexer Access Use the this[string] indexer to read/write custom data on a step: SessionStepBuilt += (preStep, curStep) => { if (curStep != null) curStep[\"MyCustomField\"] = someCalculation(); }; Accessing Step Data GetMillingStep GetMillingStep retrieves a step by index: var step = GetMillingStep(100); if (step != null) { Message($\"ToolId={step.ToolId}, Force={step.MaxAbsForce_N} N\"); } StepCount StepCount returns the total number of steps: Message($\"Total steps: {StepCount}\"); Iterating All Steps for (int i = 0; i < StepCount; i++) { var step = GetMillingStep(i); // process step... } Step Output Files Steps can be exported to CSV using WriteStepFiles: WriteStepFiles(\"Output/[NcName].step.csv\"); The CSV contains all default properties plus any registered custom variables. The file can be read back with PlayCsvFile. For waveform-level data (sub-step time resolution), use WriteShotFiles: WriteShotFiles(\"Output/[NcName].shot.csv\", 1); // 1 ms time resolution Dynamically Registered Variables (Training) After executing TrainMillingPara or ReTrainMillingPara, two additional step variables are automatically registered for steps within the training region: Variable Description TrainingErrRatio Error metric between simulation and measurement for each step AngleOffset Cutter rotation phase difference between measured and simulated data See Also Step Field Reference — complete field reference SessionShell — SessionShell quick-reference Workflow: Basic Machining Simulation — simulation workflow producing steps Workflow: Milling Force Parameter Training — training workflow that adds step variables Script Commands — the script command that drives a session"
  },
  "technique/simulation-performance/cpu-usage.html": {
    "href": "technique/simulation-performance/cpu-usage.html",
    "title": "CPU Usage During Simulation | HiAPI-C# 2025",
    "summary": "CPU Usage During Simulation Simulation Computation Threads Time-series data is computed on a single thread (using only one CPU core at a time); other data can be computed in parallel. Geometry Removal Geometry removal is single-threaded because sequential cutting is required to obtain the correct CWE (Cutter-Workpiece Engagement). The workpiece geometry surface after removal appears in light pink, which typically indicates that the physics for that region have not yet been computed. Physics Computation Cutting force computation begins after CWE is obtained. Since it is independent of computation order, it runs in multi-threaded mode under normal conditions. Torque and other physical quantities are also computed in parallel during this stage. Temperature computation must follow time-series order, so it converges back to a single thread. The entire machining simulation alternates between these modes. Once a step is fully computed, it is colored according to the designated indicator. Two Independent Cost Drivers Total simulation time comes from two largely independent parts: Per-step physics (force, torque, power, temperature, wear) — computed once per step. The total physics cost scales with the number of steps, which is set by the machining motion resolution together with the spindle revolutions along the toolpath. It does not depend on the mesh resolution, and it does not depend on the overall workpiece size. Geometry removal (voxel subtraction) — its cost is set by the mesh resolution (MachiningResolution_mm). A finer mesh (smaller value) is more expensive; a coarser mesh (larger value) is cheaper. Removal work is localized to the tool–workpiece contact region, so it is roughly area-scaled and, again, largely independent of the bulk workpiece size. MachiningResolution_mm genuinely controls the removal resolution — it is not clamped away or ignored. But because removal and physics run concurrently, the larger of the two costs governs wall-clock time: When geometry removal dominates — the common case at the fine resolutions real NC machining needs — a finer mesh is much slower, and a coarser mesh reduces total time. When the mesh is coarse enough that geometry removal is already cheap, several fixed per-step costs (physics, thermal/wear, per-step bookkeeping) dominate instead. Coarsening further — e.g. raising MachiningResolution_mm from 1.0 to 2.0 mm — then barely changes total time; to speed up, reduce the number of steps with a coarser motion resolution. (Note: 1–2 mm is already very coarse for NC machining.) CPU Usage Coarse Mesh — Physics-Bound When the mesh is coarse (a large MachiningResolution_mm), geometry removal is faster than physics computation, so a large area of light pink follows behind the tool during simulation. There is a cap on the number of unfinished steps; geometry removal only proceeds when the count is within that limit. When physics computation cannot keep up with geometry removal, the number of pink steps stays constant. In this scenario, the workload is primarily multi-core (physics computation), and you are more likely to see high multi-core CPU utilization. Making the mesh even coarser will not reduce total time — the step count (physics) is the limit. Fine Mesh — Geometry-Bound When the mesh is fine (a small MachiningResolution_mm), geometry removal is slower than physics computation, so the light pink area is barely visible. In this scenario, the workload is primarily single-core (geometry computation), and a coarser mesh will reduce total time. Balanced State If the geometry resolution is such that geometry and physics computation do not bottleneck each other, the light pink area appears and fluctuates within a certain range. In this case, physics computation does not hold back geometry computation, and geometry computation is typically the performance bottleneck. Optimization — One Burst, Then One Core An NC optimization is not the play loop, and its CPU trace has a different shape. Exactly one of its stages is parallel: the per-step feed solve, which spreads the played steps across a private pool of workers running at below-normal thread priority, so it stays behind interactive work on the same machine. Every stage announced after it — the two feed constraints, the compensation build, the NC regeneration and the file write — runs on a single thread. So an optimization shows one multi-core burst and then a single-core tail. A CPU sitting near one core's worth of load for the rest of the run is the expected shape, not a stalled run. The host setting HiNC:OptCoreNum sizes that one parallel stage. The shipped value 0 gives it one worker per logical processor; any other value caps it at that many workers, which leaves more of the machine for other work and lengthens the burst. It changes nothing else: not the single-threaded stages that follow, and not the simulation loop above. CPU Not Fully Utilized Possible reasons why the CPU is not fully utilized include: The operating system reserves headroom to ensure the GUI remains responsive. For example, Windows desktop applications (such as WPF) lower the priority of non-GUI threads by one level. The software/hardware throughput has reached its limit for the process. The reported CPU usage may not reach 100%, but other resources such as cache and bus bandwidth may be saturated. System-level factors like branch misprediction are also not reflected in the reported CPU usage. There is no setting that changes either of these. A CPU that looks idle during an NC optimization is a different question, and it is answered by the stage shape above rather than by this list. See Also Process Machinability — the mesh-quantization ripple a finer mesh removes, and what that costs in removal time Spindle Capability — the other throughput ceiling in the loop: what the spindle can deliver, rather than what the workstation can compute Mesh Resolution — choosing the value that decides which of the two cost drivers above is in the way"
  },
  "technique/simulation-performance/index.html": {
    "href": "technique/simulation-performance/index.html",
    "title": "Simulation Performance | HiAPI-C# 2025",
    "summary": "Simulation Performance What the simulation costs to run, and what it gives up when it is made cheaper. Two settings account for nearly all of it — the mesh resolution and the number of steps — and they bottleneck independently, so making a run faster starts with knowing which of the two is currently in the way. Ordered from the machine doing the work to the setting chosen before the run starts. CPU Usage During Simulation — Why a run is slow while the CPU is not saturated: single-threaded geometry removal against multi-threaded physics, and the two independent cost drivers Mesh Resolution — Choosing a mesh width: what it costs in run time, how little it moves the physics, and the one kind of geometry it can make disappear See Also Machine Capability — the ceilings of the machine being simulated, as opposed to the workstation simulating it"
  },
  "technique/simulation-performance/mesh-resolution.html": {
    "href": "technique/simulation-performance/mesh-resolution.html",
    "title": "Mesh Resolution | HiAPI-C# 2025",
    "summary": "Mesh Resolution MachiningResolution_mm is the edge length of the cubes the workpiece is built from, and it is the single largest lever on how long a simulation takes. It is also the setting most often set once and forgotten, which is expensive in both directions: too fine and a run that should take minutes takes hours, too coarse and a feature the program is supposed to cut is not there to be cut. Choosing a Value Work coarse first. An early run answers questions — does the path collide, is the force roughly where it should be, does the optimizer have room — that do not need a fine mesh, and it answers them in a fraction of the time. Refine only for the final optimization pass, where the geometry that comes out is the deliverable. As a planning figure, a simulation run takes somewhere between 2% and 150% of the actual machining time, spanning that whole range depending on the mesh and the step count. That is wide because it is genuinely a choice, not a property of the machine. Where the time actually goes, and which of the two costs is currently the bottleneck, is in CPU Usage During Simulation. The short version: at the fine resolutions real NC work needs, geometry removal dominates and a finer mesh is much slower; once the mesh is coarse enough that removal is cheap, the per-step costs dominate and coarsening further buys nothing. What Value You Actually Get The number you type is a request, not the width. The workpiece is carved out of a cube grid that starts from one fixed root cube and is halved level by level, so every width the engine can actually build is a power of two in millimetres: ... 2 - 1 - 0.5 - 0.25 - 0.125 - 0.0625 - 0.03125 ... A request that is not one of those is rounded to the next finer one, never to a coarser one, so the mesh you get is never worse than the mesh you asked for. The consequence worth knowing is that a value chosen off the ladder buys nothing: Requested Actually built 0.5 0.5 0.4 0.25 0.3 0.25 0.25 0.25 0.2 0.125 0.125 0.125 0.4 mm and 0.25 mm produce the same mesh, at the same cost. 0.4 is 0.25 wearing a misleading label: it reads as a coarse, cheap setting and runs as a fine, expensive one. If 0.25 mm is finer than the run needs, the next value that changes anything is 0.5 mm — and going the other way, 0.125 mm is another eight times the voxels, not a small step. The ladder bottoms out at 0.001953125 mm. A finer request is clamped to it, so the finest entry offered in the workpiece's Initial Resolution list builds the same mesh as the one above it. The width only ever goes finer A mesh that exists cannot be coarsened. Every cut takes the finer of the width already built and the width being asked for, so raising Machining Resolution above the mesh the workpiece was built at does not simplify anything — the request is dropped and the run keeps the mesh it has. This is why the two settings are not interchangeable. The workpiece's Initial Resolution is what builds the mesh and is therefore the memory setting; Machining Resolution gates how fine a newly cut surface may go, and can only ever refine. To make a run cheaper in memory, coarsen the Initial Resolution — coarsening Machining Resolution alone changes nothing about the stock that is already there. It still changes the time, and by a lot, because the same number sizes two other things: the tessellation of the cutter's own solid, and the number of engagement layers per step. Both are per-step work that is thrown away again, so a coarser Machining Resolution can cut the run time several-fold while the memory figure does not move at all. A run that got faster without getting smaller is this, not a mystery. Pick from the ladder and the number shown in the mission row is the number the run used. That matters beyond tidiness: a recorded mesh is built at whatever resolution is in force when the record runs, so an off-ladder value is silently baked into the cache as its rounded neighbour. What It Costs in Memory Far less than it costs in time, which is the opposite of what four rungs of the ladder — sixteen times finer, and so four thousand times the voxels — leads most people to expect. Measured by sweeping one case across five rungs with the program and the step count held fixed — a cylindrical blank, one roughing program, 199,242 steps every run: Mesh width Play time Process memory outside the managed heap 2 mm 10.5 s 665 MB 1 mm 15.3 s 688 MB 0.5 mm 31.2 s 722 MB 0.25 mm 76.6 s 826 MB 0.125 mm 242.9 s 1,456 MB Sixteen times finer costs 23 times the time and 2.2 times the memory. Two things flatten that second column, and it is worth separating them: Most of the figure is a baseline the mesh does not set. The coarsest run in the sweep already sits at 665 MB, and the whole sixteen-fold refinement adds 791 MB on top of it. Read the column as increments rather than as totals: the ratio at the bottom of the table is diluted by everything in the figure that would be there at any mesh width. The increments grow slowly at coarse widths and then accelerate. Halving the width added 23 MB, then 34, then 104, then 630 — each increment about 1.5, then 3.1, then 6.1 times the one before it, a local exponent climbing from roughly 0.6 to 2.6. A cube stops subdividing as soon as the surface inside it is a single flat facet, so while the mesh is coarser than the part's facets and curvature, refining mostly buys nothing. The volume-scaling intuition is not wrong; it only arrives once the width is below the feature scale, and by then it arrives fast. A big workpiece moves the same curve up: where the stock is a large imported solid rather than a small procedural blank, there is far more surface to subdivide and the mesh-dependent part dominates much earlier. Do not judge the mesh by the process's peak memory. On a long run most of that figure is the per-step data the run accumulates, which lives on the managed heap, scales with the number of steps and not with the mesh at all — and it moves the other way when the mesh is refined, because a slower run allocates more slowly and the collector commits less. The two cancel: measured on a larger case across a four-fold refinement, peak memory fell slightly while the mesh's own footprint grew by nearly 40%. Read the two apart before concluding anything. What the Mesh Does Not Change For a representative test case — downward circular slot milling with varying width and depth — the physical values move within about 20% across the full range of mesh widths. The simulated forces, torques and temperatures from a coarse first pass are therefore already informative; they do not become a different answer when the mesh is refined. The visible geometry is a different matter, and it is what the three runs below show. Workpiece 70 × 50 × 50 mm: Mesh width 0.125 mm Mesh width 0.5 mm Mesh width 1 mm The Failure Mode Worth Knowing A thin shell thinner than the mesh width can disappear entirely. The test case above has no thin shell, which is why its physical values are so insensitive; a part that does have one behaves differently, because the material the cutter should be meeting is not represented at all. Where the workpiece has a wall, web or floor thinner than the mesh width, the mesh must be finer than that feature before the run says anything about it. The related and much smaller effect is quantization ripple in the per-step ratios, which a finer mesh reduces — see Process Machinability. See Also CPU Usage During Simulation — which of the two cost drivers a given mesh width puts in the way Process Machinability — the mesh-quantization ripple in the availability ratios, and why it is an artifact rather than a signal Workpiece — where the initial resolution is set, on the branch carrying the stock it applies to"
  },
  "technique/validation/anomaly-cases.html": {
    "href": "technique/validation/anomaly-cases.html",
    "title": "Cutting Force Anomaly Cases | HiAPI-C# 2025",
    "summary": "Cutting Force Anomaly Cases Both cases below cost a customer yield, and in both the cause was invisible on the machine and unmistakable in simulation. They are worth reading together, because they fail the same way: an intermittent force spike far outside normal cutting, at a location that moves. Case I — Face Milling Into a Thin Workpiece A face milling operation, not fully entering from the side, produced forces 10 to 30 times normal cutting. The engineers first suspected the clamping setup. The cause was in the NC: one face milling operation, inside an extensive program, moved straight down in a way that let the flute rotate into the workpiece at a critical moment. Because the impact depended on rotational phase, some runs completed cleanly, which is exactly what made the clamping hypothesis look plausible. The result was severe clamping instability and significant yield loss, and the impact was too brief to catch by watching. Case II — Impeller, Medium Milling A toolpath interference where the front and back blades connect produced 40 times normal cutting force, and a high probability of tool breakage. Here too the root cause resisted diagnosis on the floor: the error occurred at inconsistent locations, so no single operation looked guilty. Why Simulation Finds Them The forces involved — tens of times average — are an order of magnitude outside the 10%–25% error band the simulation carries between tool types. That gap is what makes these detectable rather than debatable: nothing about model accuracy could produce a 40× reading. The pattern to recognise, in both cases: intermittent, phase-dependent, and located where a person is not looking. Those are precisely the properties that make a problem survive on a shop floor, and precisely the ones a per-step simulation is indifferent to. See Also Cutting Force and Torque Validation — the error ranges these forces sit far outside Evaluating Process Machinability — the ratios that flag a step like these before it runs"
  },
  "technique/validation/cutting-force.html": {
    "href": "technique/validation/cutting-force.html",
    "title": "Cutting Force and Torque Validation | HiAPI-C# 2025",
    "summary": "Cutting Force and Torque Validation Cutting force is the quantity everything else is derived from — torque, power, deflection, heat, wear — so it is the one whose agreement with measurement matters most. The comparisons below are against dynamometer data on real cuts. Correlation Against Measurement For a new tool, the correlation coefficient between simulated and measured force typically falls between 0.90 and 0.999. Homogeneous brittle materials sit at the high end, usually above 0.95, because there is less in the material itself to disagree about. Two error ranges are worth carrying into a decision: Across tool types on the same material, expect 10%–25% error — a ball mill and an end mill trained on the same material do not land equally close. A different hone radius produces a similar range, though in rare cases it reaches 40%. Abnormal cutting, of the kind that loses yield on the floor, produces forces on the order of tens of times the average. That is far outside any of the error ranges above, which is what makes it detectable rather than arguable — see Cutting Force Anomaly Cases. The waveform agrees as well as the magnitude. In the run below the machine shows Y-axis vibration that does not diverge, and the simulated waveform stays correlated with the measurement through it. What Torque Predicts About the Surface Torque is not only a load figure — its gradient along the surface predicts visible tool marks. When torque changes abruptly, spindle output power lags the power needed to hold speed, and the resulting speed dip leaves a mark. Cutting force deflecting the tool leaves marks by a second, independent route. Reading the figure, where blue through red is low through high: A — a high torque gradient across the surface; the tool mark is obvious. B — marks on both sides. C — a low torque gradient; the mark is faint. The same physics detects the failure before it happens. Torque overload — the spindle unable to supply the demanded load — is reported per step, alongside the marks it will leave. A Worked Maximum Feed Rate The minimum tool-breakage stress follows from the cutting parameters, and a maximum feed rate follows from that. For FDAC at HRC 41–44, a 6 mm four-flute cutter, a full slot at 3 mm depth, 6000 rpm and a safety factor of 2, the maximum feed rate works out at 880 mm/min. The safety factor is doing real work in that number: it is where the condition of the specific machine enters — see Machine Condition and Safety Factors. See Also Cutting Force Anomaly Cases — what forces tens of times the average look like in production Temperature and Wear — the quantities derived from the force validated here Evaluating Process Machinability — the ratios these forces are turned into Machine Condition and Safety Factors — the factor that turns the worked feed rate above into a value for a particular machine"
  },
  "technique/validation/index.html": {
    "href": "technique/validation/index.html",
    "title": "Validation | HiAPI-C# 2025",
    "summary": "Validation What has been checked against measurement, how closely it agreed, and where the agreement stops. A simulation is only worth acting on to the extent someone has held it against a real cut, so these pages are the record of those comparisons rather than a claim about accuracy in general. Ordered from the quantity that everything else is derived from, outward to the results a customer sees. Cutting Force and Torque — The correlation against dynamometer measurement, the error ranges to expect by tool type, and the two things torque predicts about the finished surface Temperature and Wear — Simulated cutter and chip temperature against thermal imaging, and the wear model behind the depth figures Cutting Force Anomaly Cases — Two production failures whose cause was invisible on the floor and obvious in simulation Optimization Results — Measured before-and-after on a hardened mould and a five-axis titanium roughing job Spindle power has its own validation page under Machine Capability — Spindle Power Evaluation holds the comparison against Fanuc ServoGuide TCMD data, because what it validates is the spindle model rather than the cut. See Also Milling Physics — the model these comparisons are testing Machine Capability — the equipment ceilings the same measurements calibrate"
  },
  "technique/validation/optimization-results.html": {
    "href": "technique/validation/optimization-results.html",
    "title": "Optimization Results | HiAPI-C# 2025",
    "summary": "Optimization Results Two measured before-and-after comparisons. Both were run on real machines with the same cutter and the same geometry, changing only the feed rates in the NC program. Hardened Mould, 3-Axis — FDAC Bull nose cutter Fixed feed Optimized feed Feed rate 120 mm/min variable Expected machining time 303 min 95 min (31%) Tool breakage at 217 min none The time figure is the headline, but the breakage row is the result worth having: the fixed-feed run did not complete. An optimized program that finishes is not comparable to an unoptimized one that does not. Ball cutter Fixed feed Optimized feed Feed rate 220 mm/min variable Machining time 125 min 74 min (59%) Measured wear depth 50 µm 20 µm (40%) The wear depth here is measured on the cutter, not simulated: Fixed feed Optimized feed Free-Form Roughing, 5-Axis — Ti6Al4V Simulated comparison on a five-axis free-form roughing program in titanium: Original NC Optimized NC Machining time 181 s 79 s (56% reduction) Tool wear 13.1 µm 8.9 µm (32% reduction) Breakage risk high, from overcut; low yield overcut breakage eliminated Both figures here are simulated rather than measured, and should be read as such — the comparison is sound because both sides come from the same model, which is the same argument that applies to the quoted times. Reading These Numbers The times are ideal-feed estimates and omit controller dynamics on both sides of every comparison, so the ratio is the trustworthy part and the absolute is not — see Machining Time Estimation. See Also NC Optimization Principles — what the optimizer changed to produce these reductions Machining Time Estimation — why the ratio in these tables is sounder than the absolute"
  },
  "technique/validation/temperature-and-wear.html": {
    "href": "technique/validation/temperature-and-wear.html",
    "title": "Temperature and Wear Validation | HiAPI-C# 2025",
    "summary": "Temperature and Wear Validation Temperature and wear sit two steps downstream of cutting force, so their agreement with measurement is a test of the whole chain rather than of one model. Both have been checked against instruments rather than against expectation. Temperature, Against Thermal Imaging Infrared thermography (IRT) of a running cut was compared against the simulated temperatures. Three things the comparison establishes: A — the IRT-measured temperature aligns with the simulated cutter temperature at 0.5 mm depth. That depth matters: the surface reading and the body reading are different numbers, and the simulation reports both. B — the high temperature on the blur is an unescaped chip, and the IRT reading there matches the simulated chip temperature. What looks like a hot cutter is often a hot chip that has not left. C — the temperature peak in the trace originates from that blur, not from the cutting edge. The practical consequence: a thermal measurement of a cut is not automatically a measurement of the tool. Chip evacuation has to be accounted for before an IRT reading and a simulated cutter temperature can be compared at all. Wear, From the Same Thermal Model Wear per revolution is computed from temperature, pressure, friction length and hardness: \\[ W(T)=k(T)\\frac{L P}{H(T)} \\] Both the temperature and the hardness terms are temperature-dependent, which is why the wear figure is only as good as the thermal chain above it. Measured against a real cutter, the depth figures hold up well enough to be used as a comparison between two programs — the 50 µm against 20 µm result in Optimization Results is a measured wear depth, not a simulated one. See Also Cutting Force and Torque Validation — the quantity this chain is derived from Tool Life & Wear — the wear model itself, its three reported quantities, and where flank-wear width stops being valid"
  },
  "workflows/basic-simulation.html": {
    "href": "workflows/basic-simulation.html",
    "title": "Workflow: Basic Machining Simulation | HiAPI-C# 2025",
    "summary": "Workflow: Basic Machining Simulation This workflow walks through setting up and running a machining simulation from scratch, including project configuration, option tuning, NC execution, and result inspection. For the method of assembling one — build order, how to shape the mission, and the replay-and-read-the-messages acceptance test that says the project is finished — see Project Construction. flowchart TD Equipment[\"Set machine tool &<br>controller brand/type\"] Job[\"Set workpiece, fixture,<br>tool house, NC files,<br>controller offsets\"] Option[\"Tune simulation options<br>(resolution, physics, etc.)\"] Run[\"Run simulation\"] View[\"View results\"] Equipment --> Job --> Option --> Run --> View Starting from Client Deliverables A real project usually starts from a bundle a customer hands over: NC programs, part/blank CAD, a tool sheet, sometimes a machine model and a few words about how the part is clamped and zeroed. Before building anything, reconcile that bundle against the Project Data Checklist, then map each item to the steps below: Client deliverable Maps to Setup page NC programs (.nc, .anc, …) NC files + controller brand General NC Code Support Tool sheet (diameters, corner radius, flute count, stick-out) Tool House Cutter Geometry Part CAD + blank/stock CAD Workpiece IdealGeom + InitGeom Anchor Machine model + axis layout (3-axis, 3+1, 5-axis) Machine tool kinematic chain Machine Tool “Where is program zero?” notes, work-offset list Program zero + work-offset table Program Zero Alignment Material name Workpiece material + cutting parameters Project Data Checklist Note CAD geometry commonly arrives as STEP (.step / .stp). The workpiece and machine bodies are consumed as STL (or parametric primitives), so convert STEP to STL before import. The tool sheet's diameter and corner radius are authoritative; flute length, tooth count, helix, and stick-out are often missing and may have to be estimated from the spec string and confirmed with the client. Tip When deliverables are incomplete (no blank CAD, unknown work offsets, unverified machine model), you can still stand up a rough project: use the NC tool diameters, the named material, a placeholder stock box that encloses the tool path, and an identity work offset — then run a coarse pass (see §3.1) to catch gross overcut/collision while you wait for the missing data. Record every assumed value so it can be confirmed later. 1. Set Machine Tool and Controller The machine tool and controller are fixed equipment that define the physical simulation environment. Machine Tool The machine tool (.mt file) provides the kinematic model and STL bodies. Once selected it rarely changes between simulations. Controller Select the controller brand and type (e.g., Fanuc, Heidenhain, Siemens). This determines how NC code is interpreted. See Heidenhain Support and General NC Code Support for details. GUI Operation Open or create a project in the HiNC application and configure machine tool and controller through the corresponding panels before setting up the job. 2. Set Job Components With equipment fixed, configure the job-specific components that change between simulations. Tip For the full list of data to collect before building a project (and a customer-facing checklist), see Project Data Checklist. Job Components Component Description Workpiece Geometry (STL or parametric), material, and coordinate frame Fixture (optional) Fixture geometry that participates in collision detection Tool House One or more cutting tools with geometry and flute definitions NC Files The NC programs to simulate Controller Offsets Tool offset tables, work offset tables, and other controller-specific presets Tip All file paths used in script commands are relative to the project directory unless an absolute path is given. Script Access The workpiece and fixture objects are available through Workpiece(API) and Fixture(API). var workpiece = Workpiece; var fixture = Fixture; GUI Operation Configure each component through the corresponding panels (Workpiece, Fixture, Tool House windows). 3. Tune Simulation Options Simulation options control the trade-off between accuracy and speed. 3.1 Workpiece Entity Resolution MachiningResolution_mm(API) sets the smallest cube width of the workpiece mesh. MachiningResolution_mm = 0.125; Valid values are powers of 2 (e.g., 4, 2, 1, 0.5, 0.25, 0.125). If you supply a non-power-of-2 value the system rounds to the nearest power of 2. Warning Each halving of mesh width can increase computation time and RAM by up to 8x. Start with a coarser resolution and refine only when needed. Note Going finer is what costs the 8x — and at the fine resolutions real NC machining needs, geometry removal is usually the bottleneck. Going coarser only saves time while geometry removal is the bottleneck. Once the mesh is coarse enough that geometry removal is already cheap (1–2 mm is already very coarse for NC), the fixed per-step costs dominate and raising MachiningResolution_mm further barely changes total time (this is why 1.0 mm and 2.0 mm can run at nearly the same speed). To speed up in that regime, reduce the step count via Machining Motion Resolution. See CPU Usage During Simulation. 3.2 Display Cache DispCache_Mb = 260; The display resolution depends on the cache size. Recommended value should not exceed 1000 Mb. 3.3 Machining Motion Resolution Machining motion resolution determines the interval of each simulation step. Options: Mode Command Description Feed Per Cycle MachiningMotionResolution = FeedPerCycle; One step per spindle revolution (default) Scaled Feed Per Cycle MachiningMotionResolution = ScaledFeedPerCycle(2); One step per (revolution × scale): scale > 1 → fewer steps (faster); scale < 1 → more steps (finer) Feed Per Tooth MachiningMotionResolution = FeedPerTooth; One step per tooth pass (revolution ÷ flute count) Fixed Pace MachiningMotionResolution = FixedPace(1, 15); Fixed linear (mm) and rotary (deg) resolution; cuts by sweeping between steps Important Total simulation time is governed by whichever is slower: geometry removal or the per-step fixed costs. Geometry-removal cost is set by mesh resolution; the per-step fixed costs (physics, thermal/wear, per-step bookkeeping) are set by the number of steps — the motion-resolution mode plus the spindle revolutions along the toolpath, independent of mesh resolution and of workpiece size. At the fine resolutions real NC machining needs, geometry removal is usually the bottleneck (finer = much slower). Only once the mesh is coarse enough that geometry removal is already cheap do the fixed per-step costs dominate — then raising MachiningResolution_mm further will not speed things up (this is why 1.0 mm and 2.0 mm can run at nearly the same speed); reduce the step count instead — e.g. ScaledFeedPerCycle(2) takes one step per 2 revolutions, halving the steps, at the cost of sparser force-curve sampling. See CPU Usage During Simulation. Warning Do not use scaled model dimensions as a substitute for adjusting mesh width. Scaling model dimensions causes internal algorithm thresholds (minimum cuttable amount, floating-point-to-fraction range) to become invalid, producing irregular geometry artifacts. Adjust resolution settings instead. 3.4 XML Configuration Resolution can also be set in the .hincproj file or changed mid-simulation via NC code comments: T01 M06 (;@MachiningResolution_mm=0.03125;) 4. Run Simulation There are four ways to drive the simulation, plus player controls. 4.1 PlayNcFile — Execute from a File PlayNcFile(API) reads and executes an NC file. PlayNcFile(\"NC/file1.nc\"); 4.2 PlayNc — Execute from a String PlayNc(API) executes NC code directly from a string, useful for programmatic or dynamically generated commands. double x = 10.0; PlayNc($\"G01 X{x} Y20 F100\", \"Generated Command\"); 4.3 PlayCsvFile — Drive from CSV Data PlayCsvFile(API) drives the simulation from a CSV file containing axis positions, spindle speed, and feed rate. PlayCsvFile(\"Data/file1.csv\"); Required CSV columns (default headers): MC.X, MC.Y, MC.Z, ToolId, SpindleSpeed_rpm, Feedrate_mmdmin. Optional: MC.A, MC.B, MC.C, ActualTime, StepDuration. Headers and timestamp values may be wrapped in double quotes; the parser strips them. ActualTime accepts either HH:mm:ss.fff or an absolute yyyy-MM-dd HH:mm:ss.ffffff form (the absolute form is required when chaining with MapSeriesByCsvFile(API), which matches by TimeTag): \"ActualTime\",\"Feedrate_mmdmin\",\"MC.X\",\"MC.Y\",\"MC.Z\",\"SpindleSpeed_rpm\",\"ToolId\" \"2026-03-16 15:57:45.559000\",10000.0,-351.745,-244.799,-215.799,1270,1 \"2026-03-16 15:57:45.705000\",10000.0,-351.745,-244.799,-215.799,1270,1 When a real-world controller log includes extra columns (e.g., t_receive, cnc_delay_s, status) or uses alternative column names (X/Y/Z, feedrate, spindle_speed), preprocess the file to drop or rename columns before passing it to PlayCsvFile(API). Tip CSV files exported by WriteStepFiles(API) can be directly read back with PlayCsvFile(API). 4.4 PlayClFile — Drive from a Cutter-Location File PlayClFile(API) replays an NX cutter-location file (CLSF / APT-source, .cls) directly as tool motion — the machine-independent CAM toolpath, before it is post-processed for a specific machine. PlayClFile(\"CL/part-op10.cls\"); Note Unlike the file players above, CL playback drives a ClMillingDevice chain — the cutter location is applied straight to the tool — not the machine-tool chain from §1. Use it to verify the programmed path itself, independent of machine and post-processor. See Cutter-Location (CL) Playback for the supported record set, tool creation from TLDATA, and the chain requirement. 4.5 Player Control Command Purpose Pace()(API) Insert a pausable checkpoint Pause()(API) Pause execution Reset()(API) Reset player state PlayNcFile(\"NC/file1.nc\"); if (someCondition) Pause(); 5. View Results 5.1 Meshed Geometry After simulation the workpiece geometry is a Meshed Geometry (cubic mesh). You can save and reload it to avoid re-computing the initial shape: WriteMeshedGeom(\"Cache/file1.wct\"); ExportMeshedGeomToStl(\"Output/file1.stl\"); To reload a saved geometry for a subsequent run: ReadMeshedGeom(\"Cache/init.wct\"); PlayNcFile(\"NC/file1.nc\"); 5.2 Step Data Inspection Each simulation step carries rich data (force, torque, power, thermal, wear). Access individual steps: var step = GetMillingStep(100); Message($\"ToolId={step.ToolId}, Force={step.MaxAbsForce_N} N\"); Total step count: var total = StepCount; Message($\"Total steps: {total}\"); 5.3 Export Data Export step-level CSV: WriteStepFiles(\"Output/[NcName].step.csv\"); Export waveform (shot) CSV: WriteShotFiles(\"Output/[NcName].shot.csv\", 1); 5.4 Messages Use messages to log and track simulation progress: Message(\"Simulation complete\"); AppendMessagesToFile(\"Output/messages.txt\"); Troubleshooting Symptom Likely Cause Fix Very slow simulation, large pink trail behind the tool Geometry removal is the bottleneck (mesh too fine) Increase MachiningResolution_mm (coarser mesh) Very slow simulation, but a coarser mesh doesn't help Limited by step count (per-step physics) Reduce steps via MachiningMotionResolution (e.g. ScaledFeedPerCycle(2)) Irregular bumps on geometry Scaled model dimensions instead of resolution Use resolution settings only; see warning above Display lag DispCache_Mb too large Reduce display cache (< 1000 Mb recommended) Empty step data Simulation not run or tool not engaging workpiece Verify tool path intersects the workpiece See Also Heidenhain Support — controller configuration General NC Code Support — ISO NC support Cutter-Location (CL) Playback — replay a CAM cutter-location file with PlayClFile Step — what a step is, accessing and outputting step data Step Field Reference — step field reference Script Commands — script command basics SessionShell — SessionShell quick-reference"
  },
  "workflows/dynamometer-experiment-sop.html": {
    "href": "workflows/dynamometer-experiment-sop.html",
    "title": "Dynamometer Experiment SOP | HiAPI-C# 2025",
    "summary": "Dynamometer Experiment SOP Capture three-axis force data using a dynamometer and calculate the milling force coefficients. Dynamometer Setup Photography After setting up the experimental equipment, push in the X, Y, and Z directions by hand while observing whether the dynamometer output is correct. This process must be photographed or recorded on video. The frame should simultaneously show the dynamometer output and the hand pushing. Ensure the dynamometer wiring is correct and the sign conventions are correct, so the experimental setup can be traced back later. Tool Use a square-end (non-corner-radius) end mill. Recommended tool parameters: D10 Flute4 Helix35 Flute count and rake angle are unrestricted, and all three of flute count, helix angle and rake angle must be accurately recorded along with the tool brand and model. The helix angle is the one that is not free. A cut set whose cutters all share one helix angle leaves a combination of the shear coefficients unobservable in the bending-moment channel, whatever the data quality, so a training that reads Mx/My needs at least two clearly different helix angles among its cutters — see Designing a Training Cut Set. Two stock cutters ground at different helix angles are enough; nothing custom is required. A 10 mm diameter is used to avoid tool breakage when cutting difficult materials. The 10 mm standard was established based on Inconel 718 as the safety baseline for this experiment. Workpiece / Toolpath Workpiece dimensions: dynamometer length × width × convenient clamping height (50 mm) Cutting depth is 0.5 mm. Toolpath categories are identified by keywords: low, high, through. “low” denotes low spindle speed, “high” denotes high spindle speed, and “through” denotes a through-pass. There are 8 cuts in total: low1, low2, low3, high1, high2, high3, through1, through2. If material is limited, low2 and low3 alone are sufficient to complete the training. low1 intentionally cuts along the edge so that through1 can smoothly enter the cutting zone. The high series uses the same feed per tooth as the low series but at different spindle speeds, primarily to observe whether spindle speed affects cutting forces. If constrained by material, machine, or other factors, high2 and high3 can be omitted first. through1 and through2 maintain a constant CWE and serve as validation passes. If the material is too hard, the cutting depth can be reduced for the experiment. Experiment Results The dynamometer data must be retained."
  },
  "workflows/examples/index.html": {
    "href": "workflows/examples/index.html",
    "title": "Example Projects | HiAPI-C# 2025",
    "summary": "Example Projects Complete project-level examples demonstrating full workflows with real data. Dynamometer Milling Training — Train milling coefficients using Kistler dynamometer measurements on S50C material Cascading Controller & Sensor Data — Cascade controller and sensor data into the simulation toolpath and update milling coefficients"
  },
  "workflows/examples/mapping-demo.html": {
    "href": "workflows/examples/mapping-demo.html",
    "title": "Example Project: Mapping Controller and Sensor Data to Simulated NC Toolpaths and Updating Milling Coefficients | HiAPI-C# 2025",
    "summary": "Example Project: Mapping Controller and Sensor Data to Simulated NC Toolpaths and Updating Milling Coefficients The example project can be downloaded here: https://superhightech-gitea.webredirect.org/HiNC-Deploy/DemoMapping This project uses MapSingleByCsvFile(API) and MapSeriesByCsvFile(API) to map controller data and sensor data to the virtual environment, and then update the milling coefficients. Related Pages Workflow: Sensor Data Mapping — sensor data mapping workflow Workflow: Milling Force Parameter Training — milling force parameter training workflow"
  },
  "workflows/examples/milling-training-dynamometer.html": {
    "href": "workflows/examples/milling-training-dynamometer.html",
    "title": "Example Project: Training Milling Coefficients with a Dynamometer | HiAPI-C# 2025",
    "summary": "Example Project: Training Milling Coefficients with a Dynamometer The example project for training milling coefficients using a dynamometer can be downloaded here: https://superhightech-gitea.webredirect.org/HiNC-Deploy/Demo-Para-Training-S50C-202501 This project uses Kistler dynamometer measurement data to train milling coefficients for S50C material via the one-to-many local mapping (anchor-based) method. Tip The toolpath and cutting conditions can be freely modified to suit your specific setup. Related Pages Workflow: Milling Force Parameter Training — milling force parameter training workflow Workflow: Sensor Data Mapping — sensor data mapping workflow"
  },
  "workflows/force-training.html": {
    "href": "workflows/force-training.html",
    "title": "Workflow: Milling Force Parameter Training | HiAPI-C# 2025",
    "summary": "Workflow: Milling Force Parameter Training This workflow covers the end-to-end process of training milling force coefficients from sensor data, including data mapping, coefficient training, quality evaluation, and application of the trained parameters. Milling coefficients are essential parameters for calculating milling forces. Training derives these coefficients from experimental sensor data (dynamometer or smart tool holder) mapped to simulated toolpaths. flowchart TD Prereq[\"Prerequisites<br>(sensor data, project setup)\"] Resolution[\"Configure resolution & enable physics\"] Mapping[\"Configure data mapping\"] Simulate[\"Run simulation with NC file\"] Export[\"Export simulation data<br>(WriteShotFiles, WriteStepFiles)\"] Map[\"Map sensor data to simulation\"] Train[\"Train milling parameters\"] Evaluate[\"Evaluate training quality\"] Apply[\"Load trained parameters\"] Prereq --> Resolution --> Mapping --> Simulate --> Export Simulate --> Map --> Train --> Evaluate --> Apply 1. Prerequisites Tip For the complete data-collection checklist behind a project, see Project Data Checklist. Before training you need: Item Description HiNC project Machine tool, workpiece, fixture, tool house configured NC file The NC program used during the physical cutting experiment Sensor data CSV Time-stamped force/torque data from a dynamometer or smart tool holder Controller data CSV (optional) Machine controller log with FileNo, LineNo, ActualTime for two-layer mapping Important Before training, the workpiece + fixture must be correctly placed relative to the work offset, otherwise the simulated engagement (and therefore the trained coefficients) is wrong. See Program Zero Alignment — particularly the high-fidelity caution that the G54 used must reflect the real machine offset, and the rough-resolution check for catching a wrong setup at the opening plunge. Sensor Data File Format The CSV must contain a header row with a time column and at least one force/torque channel. Each channel accepts more than one spelling, so a file written for an older release still reads: Source Headers Time ActualTime, or ActualDateTime for the absolute instant. TimeTag and Time are read for compatibility with older files. Dynamometer Fx or Workpiece.Fx (same for y, z) Smart tool holder Mx or Holder.Mx (same for y, z). Spindle.Mx is an obsolete spelling, read but not written. Accelerometer (optional) Ax, Ay, Az — one spelling only ActualTime,CH1,CH2,Mx,My,Mz 18:23:54.703,-0.00398,-0.00034,-0.02923,0.10733,0.00409 18:23:54.704,-0.00194,0.00285,0.04155,-0.04457,0.00448 ... Tip Keep the completed training project archived. When the HiNC training algorithm is updated, you can re-run training from the same project. 2. Configure Resolution and Enable Physics Resolution Use a finer resolution than normal operation for training accuracy: MachiningResolution_mm = 0.0625; // half or less of production resolution MachiningMotionResolution = FeedPerTooth; Tip Training resolution should be ≤ 0.5× the production resolution for better accuracy. Enable Physics EnablePhysics must be enabled for force calculation: EnablePhysics = true; Milling Force Cycle Division MillingCycleDivisionNum is the number of angular divisions per spindle revolution used by the force evaluation. The default is 36, which is intended for normal simulation — force playback does not benefit from a finer division, and raising it only slows the physics down. Training is the exception: phase alignment and coefficient quality improve with a finer division, so set it in the training script: MillingCycleDivisionNum = 180; // training only; default 36 is for normal simulation Note This must be set before the simulation run that TrainMillingPara consumes. How much is enough — measured (2-flute D8, Al6061-T6, MachiningResolution_mm 0.03125, sensor series sampled at 0.1 ms): MillingCycleDivisionNum R Fc error @ t=0.2 Fn error @ t=0.2 ploughing coefficients 36 (default) 91.5 % −6.7 % −8.8 % badly off (Kpc +40 %) 180 95.2 % −6.6 % −6.1 % Kpc +10 % 720 95.2 % −6.9 % −6.3 % Kpc +11 % 180 is the sweet spot: the default 36 is genuinely too coarse for training (the ploughing coefficients degrade badly), and 720 buys nothing while costing 4× the physics. Do not assume “larger is always better”. Warning The value is process-wide, not per-project: it is not saved into the .hincproj, and it survives ResetRuntime() and project switches. Two consequences: (a) a training script must always set it explicitly — a fresh service instance starts at 36; (b) after training, the same instance keeps the large value, so subsequent normal simulations run slower until you set it back (or restart the instance). 3. Configure Data Mapping Depending on your data, choose one of the mapping strategies below. 3.1 Local Mapping (Anchor-Based) For mapping sensor data to specific NC path segments: Step A — Specify input data: ClearTimeMappingData(); AddTimeDataByFile(\"lineA\", \"Mapping/sensor1.csv\", \"18:25:51.7100\", \"18:26:12.9910\"); AddTimeDataByFile(\"lineB\", \"Mapping/sensor1.csv\", \"18:26:30.5750\", \"18:27:12.2880\"); Step B — Specify NC paths (embedded in NC code comments): X13. F20 ;@LineSelection(\"lineA\", FirstTouch, ShiftTime_s(2), LineEnd, ShiftDistance_mm(-1)); X25. F10 ;@LineSelection(\"lineB\", FirstTouch, null, LastTouch, null); Anchor options: LineBegin, LineEnd, FirstTouch, LastTouch. Offset options: null, ShiftTime_s(<seconds>), ShiftDistance_mm(<mm>). 3.2 Two-Layer Chained Mapping (Controller + Sensor) When you have both controller data and sensor data: PlayNcFile(\"NC/machining.nc\"); MapSingleByCsvFile(\"Data/controller.csv\"); // maps FileNo/LineNo → ActualTime MapSeriesByCsvFile(\"Data/sensor.csv\"); // ActualTime → sensor series Note Why two-layer mapping? Running the NC through the system interpreter produces more accurate simulation paths than direct CSV playback. The controller data bridges simulation steps to real time via FileNo/LineNo, and the sensor data bridges real time to force/torque readings. ⚠ Train on the steady part of the cut — it is the largest single lever MapSeriesByCsvFile pairs each step with a window of sensor samples. The window is anchored at the step's end time and runs forward for one cycle period, so the samples a step is fitted against are the ones its neighbours produced, never its own. While the cut is steady, that costs nothing. A neighbouring step cutting the same arc at the same chip load produces, at a given rotation angle, the same force this step would have produced, so the borrowed samples are extra data rather than extra error. The pairing turns into a systematic bias only where the cutter–workpiece engagement changes across the window — cutter entry, pass exit, corners, depth changes. Measured on the D8 2-flute Al6061-T6 case (one source file at a 1 ms sampling period; only the training set and the CycleSamplingMode window vary): training set window Fc error @ t=0.2 Fn error @ t=0.2 R whole path (1076 cutting steps) SpindleCycle (default) −9.3 % −9.9 % 94.3 % whole path FluteCycle −7.1 % −8.1 % 95.7 % steady part only (~800 steps) SpindleCycle (default) −3.3 % −2.3 % 98.5 % steady part only (~800 steps) FluteCycle −3.2 % −2.4 % 98.6 % Two things to read off it. First, restricting training to the steady part is worth more than any other setting — here it more than halved the error, and did so at the coarsest sampling period. Second, once the transient is gone the window choice stops mattering (0.06 percentage points between the two modes, versus 2.2 on the whole path): FluteCycle's advantage on the whole path was only ever a shorter exposure to the entry and exit ramps. Keep the SpindleCycle default and its larger sample count. In this case the transient was 272 of the 1076 cutting steps: the entry ramp, where the radial engagement builds from 0.09 mm to the nominal 2 mm, and the pass exit, where it climbs to 5 mm as the cutter runs off the far corner. Select the training section by requiring the engagement to be constant — CuttingWidth_mm and CuttingDepth_mm steady across neighbouring steps — rather than by eyeballing the toolpath. Note Gaps in the sensor data are handled. A step whose pairing window contains no measured row — an acquisition dropout, or rows removed to keep the steady section only — is excluded from the mapping, and a single Map-ShotGap--StepsSkipped warning reports how many steps were skipped. A window-edge row is only interpolated when the rows bracketing the edge span at most two spindle revolutions; rows farther apart sit across a gap, and no value is fabricated from them. Watch for that warning after mapping measured data: a large count means the acquisition and the play do not overlap the way you think they do. Warning MachiningResolution_mm must not be too coarse for training: at 1/16 of the cutter diameter and coarser (D8 case: 0.0625 and 0.125), usable samples dropped by half and the phase pairing degraded badly — at 0.0625 it failed to recognise one of the six cutting passes outright, and coefficients came out wildly wrong (Fc −12 % to −33 %). Around 1/256 of the diameter (0.03125 here) the result saturates; refining further showed no benefit. 4. Run Simulation PlayNcFile(\"NC/file1.nc\"); Warning During training, do not: Adjust workpiece, tool, or controller resolution settings Use the NC player reset button (close the project instead) Save the project (system training configuration may overwrite tool resolution settings) 5. Export Simulation Data Export step data and waveform data for analysis: WriteStepFiles(\"Output/[NcName].step.csv\"); WriteShotFiles(\"Output/[NcName].shot.csv\", 0.1); // 2nd arg = sampling period in ms The shot file opens with FileNo, LineNo, Time and the mission's M-codes, then carries the time-resolved force columns: Tool.Fx/Fy/Fz, Workpiece.Fx/Fy/Fz, Holder.Mx/My/Mz — the same holder spelling the reader writes, not the obsolete Spindle.M*. A play driven from a controller CSV appends ActualDateTime; an NC-simulated play has no controller instant to stamp and omits that column. ⚠ The shot sampling period is the dominant accuracy lever The second argument of WriteShotFiles is the sampling period in milliseconds, and when a simulated shot file is fed back into training it — not the angular division count, not the machining resolution — sets the accuracy ceiling. Each row is interpolated from the per-division force waveform, so the information per revolution is min(MillingCycleDivisionNum, samples per revolution), where samples per revolution = 60000 / (rpm × samplingPeriod_ms) Measured on the same case (2-flute D8, Al6061-T6, MachiningResolution_mm 0.03125, S1270 → one revolution = 47.2 ms): sampling period samples / rev R Fc error @ t=0.2 Fn error @ t=0.2 1 ms 47 94.2 % −9.3 % −9.9 % 0.1 ms 472 95.2 % −6.6 % −6.1 % At 1 ms the waveform is sampled only ~47×/rev, and raising MillingCycleDivisionNum from 180 to 720 changes nothing because the extra grid points are pure interpolation of the same data. Pick the sampling period first: for training on simulated data use a period at or below the division period (60000 / (rpm × MillingCycleDivisionNum) ms); when comparing against a real measurement, match the sampling period to the physical DAQ rate, otherwise the two sides carry different information densities and the comparison is biased. Note A fine period makes large files — the case above went from 13 MB at 1 ms to 128 MB at 0.1 ms for a 6-cut program. Budget disk accordingly, and do not commit such files to a repository. For coordinate system explanations, see Milling Physics Coordinates. 6. Train Milling Parameters TrainMillingPara (New Training) TrainMillingPara trains new coefficients independently of any existing workpiece parameters. TrainMillingPara(Fx|Fy|Fz, \"StainlessSteel.mp\"); ReTrainMillingPara (Calibration) ReTrainMillingPara calibrates existing coefficients (10% original weight, 90% new sample weight). ReTrainMillingPara(Fz|Mx|My|Mz, \"StainlessSteel.mp\"); Sample Flag Requirements Command Minimum Data Types Feed Per Tooth Requirement TrainMillingPara Fx\\|Fy\\|Fz (dynamometer) or Fz\\|Mx\\|My\\|Mz (smart tool holder) At least one sample with different feed per tooth ReTrainMillingPara No restriction No restriction Warning Using only Mx|My|Mz without Fz loses one degree of freedom (torque = r × F loses the r-direction), making coefficient training unreliable. Always include Fz when using torque data. The feed-per-tooth entry above is what the command refuses to run without, not what a usable training needs. One sample at a different feed satisfies it; separating the shear coefficients from the ploughing ones takes a range of chip loads across the passes. Training Conditions Samples should have stable, repeatable waveforms for at least two spindle revolutions Under unstable conditions, plowing coefficients tend to be over-estimated Stable samples are necessary and not sufficient. Whether the coefficients can be recovered from a cut set at all is decided by what that set spans, not by how clean it is: a set with one helix angle leaves a combination of the shear coefficients exactly unobservable, and a set with a narrow feed-per-tooth range cannot separate shear from ploughing. Design the set before cutting — see Designing a Training Cut Set 7. Evaluate Training Quality After training, the system reports three quality metrics: Correlation Coefficient (R) A single value for the overall result. Ranges from 0 to 1; for new tools, expect 0.95–0.999. Training Error Ratio (TrainingErrRatio) A per-step variable registered automatically after training. Lower values indicate better step-level quality: \\[ \\text{TrainingErrRatio} = \\sqrt{\\frac{\\sum_{i} e_i^2}{\\sqrt{\\sum_{i} y_i^2 \\cdot \\sum_{i} \\hat{y}_i^2}}} \\] Angle Offset (AngleOffset) A per-step variable representing the cutter rotation phase difference between measured and simulated data: \\[ \\theta_{offset} = \\frac{2\\pi \\cdot i_{min}}{N_{div}} \\] Tip If AngleOffset varies significantly across segments in the same training batch, the spindle may have experienced speed changes, data gaps, or the system could not accurately analyze the samples. 8. Load Trained Parameters After training, load the new coefficients into the workpiece: LoadCuttingParaByFile(\"StainlessSteel.mp\"); Warning If the training output file path is the same as the tool's existing cutting parameter file, reload the project after training to ensure the new parameters take effect. XML Configuration (GUI Workflow) When using the GUI-based training workflow, configure the .hincproj file: <MillingParaGridTrainingDestinationFile>MillingPara/trainedPara.mp</MillingParaGridTrainingDestinationFile> <MillingParaTraining> <IsMzEnabled>false</IsMzEnabled> <ForceOutlierRatio>2</ForceOutlierRatio> <LeadParaTemplate> <RakeFaceCuttingParaMap> <FluteFormNum>1</FluteFormNum> <NAngleDivisionNum>0</NAngleDivisionNum> <EcAngleDivisionNum>0</EcAngleDivisionNum> </RakeFaceCuttingParaMap> </LeadParaTemplate> <ResultParaTemplate> <RakeFaceCuttingParaMap> <FluteFormNum>1</FluteFormNum> <NAngleDivisionNum>0</NAngleDivisionNum> <EcAngleDivisionNum>0</EcAngleDivisionNum> </RakeFaceCuttingParaMap> </ResultParaTemplate> </MillingParaTraining> Set IsMzEnabled to true if mapped data contains axial spindle torque from a smart tool holder. Complete Script Example MachiningResolution_mm = 0.0625; EnablePhysics = true; MillingCycleDivisionNum = 180; // training only; default 36 suits normal simulation, 720 buys nothing ClearTimeMappingData(); AddTimeDataByFile(\"lineA\", \"Mapping/sensor1.csv\", \"18:25:51.7100\", \"18:26:12.9910\"); AddTimeDataByFile(\"lineB\", \"Mapping/sensor1.csv\", \"18:26:30.5750\", \"18:27:12.2880\"); PlayNcFile(\"NC/file1.nc\"); TrainMillingPara(Fx|Fy|Fz, \"MillingPara/trained.mp\"); LoadCuttingParaByFile(\"MillingPara/trained.mp\"); WriteStepFiles(\"Output/[NcName].step.csv\"); WriteShotFiles(\"Output/[NcName].shot.csv\", 0.1); See Also Milling Physics Coordinates — coordinate system reference Sensor Mapping Workflow — detailed mapping workflow Workflow: Basic Machining Simulation — basic simulation setup Workflow: NC Optimization — optimization after training Step — step data reference SessionShell — SessionShell quick-reference Training with a Dynamometer (Example) Cascading Mapping (Example)"
  },
  "workflows/geometry-validation.html": {
    "href": "workflows/geometry-validation.html",
    "title": "Workflow: Geometry Validation | HiAPI-C# 2025",
    "summary": "Workflow: Geometry Validation This workflow covers the suite of tools for validating machining geometry after simulation, including collision detection, geometry difference comparison, defect scanning, and flying piece removal. flowchart TD Simulate[\"Run simulation\"] Collision[\"Collision detection\"] Diff[\"Geometry difference comparison\"] Defect[\"Geometry defect scanning\"] FlyPiece[\"Flying piece removal\"] Simulate --> Collision Simulate --> Diff Simulate --> Defect Simulate --> FlyPiece 1. Collision Detection Collision detection monitors whether the tool, holder, or spindle collides with the workpiece, fixture, or machine during simulation. Enable it before running the simulation. Script Commands EnableCollisionDetection = true; EnablePauseOnCollision = false; // set true to pause on collision Property Description EnableCollisionDetection Enables collision checking during simulation EnablePauseOnCollision Pauses execution when a collision is detected Combined with Pause on Failure EnablePauseOnFailure provides a broader pause-on-error mechanism: EnablePauseOnFailure = true; EnableCollisionDetection = true; PlayNcFile(\"NC/file1.nc\"); // pauses if a collision occurs GUI Operation Enable collision detection in the main options panel before simulation. Tip Collision detection adds computation overhead. For exploratory simulations where speed matters, you can disable it and re-enable for final validation. 2. Geometry Difference Comparison The Diff command compares the simulated workpiece shape against a target (design) shape to identify over-cut and under-cut regions. Script Command Diff(<DetectionRadius_mm>); Detection Radius is the surface extension distance for the target shape. Deviations beyond this distance are not computed. Larger values take longer. Diff(1); // detection radius = 1 mm Interpreting Results After comparison, the workpiece surface is color-coded: Green: Within tolerance Red (positive): Over-cut exceeding the threshold Blue (positive): Under-cut exceeding the threshold Note The path index on the workpiece surface is invalidated after running Diff. If you need to inspect individual step paths, do so before calling Diff. Case Study: Reciprocating Slope Interference CAM-generated NC code may contain subtle errors that are invisible without geometric comparison. Common issues found through Diff: Issue Description Right-angle wall under-cut Under-cut near walls where target geometry has sharp corners Inconsistent Z plunging Over-cut from inconsistent Z values in reciprocating plunge regions Insufficient radius clearance Under-cut at reciprocating edges where the tool hasn't moved out by its radius Zebra-pattern under-cut Under-cut stripes from excessive reciprocating path spacing Tip Without software comparison, these issues can only be discovered after physical machining, significantly impacting precision manufacturing. 3. Geometry Defect Scanning Geometry defect scanning helps debug abnormal workpiece or tool geometry. This is typically used only when geometry construction problems are suspected. ScanMeshedGeomInfDefect ScanMeshedGeomInfDefect scans for infinite edge cut defects in the meshed geometry. After scanning, defect areas are rendered with colored markers. ScanMeshedGeomInfDefect(); Return values: true — defects detected false — no defects null — unable to execute (e.g., workpiece does not exist) Workflow: Scan Before Simulation ScanMeshedGeomInfDefect(); Pause(); // visually inspect defects ClearDefectDisplayee(); // clear markers PlayNcFile(\"NC/file1.nc\"); ClearDefectDisplayee ClearDefectDisplayee removes defect markers from the workpiece: ClearDefectDisplayee(); Note Defect markers are automatically cleared when the workpiece is reloaded or the meshed geometry is reset. During workpiece initialization, if construction defects are detected, markers are automatically displayed. 4. Flying Piece Removal During five-axis cutting, small disconnected residual material fragments (“flying pieces”) may appear. Use RemoveFlyPiece to clean them up. Script Command RemoveFlyPiece(); Tip Run RemoveFlyPiece after simulation and before geometry export (ExportMeshedGeomToStl) to produce a clean output. Combined Validation Script Example // Configure and run simulation with collision detection EnableCollisionDetection = true; EnablePauseOnCollision = false; EnablePhysics = true; MachiningResolution_mm = 0.125; PlayNcFile(\"NC/file1.nc\"); // Remove any flying pieces RemoveFlyPiece(); // Compare against target geometry (1 mm detection radius) Diff(1); // Scan for geometry defects var hasDefects = ScanMeshedGeomInfDefect(); if (hasDefects == true) { WarningMessage(\"Geometry defects detected\"); } // Export final geometry ExportMeshedGeomToStl(\"Output/final.stl\"); WriteStepFiles(\"Output/[NcName].step.csv\"); See Also Workflow: Basic Machining Simulation — basic simulation setup SessionShell — SessionShell quick-reference"
  },
  "workflows/index.html": {
    "href": "workflows/index.html",
    "title": "Workflows | HiAPI-C# 2025",
    "summary": "Workflows End-to-end task guides. Each page carries one job from the data you have to the result you want and is meant to be read start to finish, so a guide stays whole rather than being split into a procedure half and a knowledge half. Where a guide rests on durable theory it cites the Technique page instead of restating it. Ordered as a project goes: collect the data, stand the project up, run it, then the jobs that build on a run that has finished. Guides Project Data Checklist — The canonical list of what to collect from the machine owner before a project can be built, with formats, tolerances and worked examples Basic Simulation — Set up and run a machining simulation from scratch: project configuration, option tuning, NC execution and result inspection Project Construction — How to build a project so that it is actually finished: the build order that avoids rework, how to shape the mission, and the acceptance test Milling Force Parameter Training — Train milling force coefficients from measured sensor data, evaluate their quality, and apply them NC Optimization — Generate an optimized NC file by adjusting feed rates against power, torque, thermal and force limits Sensor Data Mapping — Map dynamometer, smart tool holder or accelerometer data onto simulation toolpaths so a step can index a real measurement Geometry Validation — Collision detection, geometry difference comparison, defect scanning and flying-piece removal after a run Simulation Report — Turn a completed session into a focused set of result captures, keeping the panels that carry information and leaving out the chrome Dynamometer Experiment SOP — The bench procedure for capturing three-axis force data and calculating milling force coefficients Example Projects — Complete project-level examples that run the guides above against real data"
  },
  "workflows/nc-optimization.html": {
    "href": "workflows/nc-optimization.html",
    "title": "Workflow: NC Optimization | HiAPI-C# 2025",
    "summary": "Workflow: NC Optimization This workflow describes how to generate optimized NC files from a physics-based simulation. The optimizer adjusts feed rates to keep physical quantities (spindle power, torque, thermal stress, cutting force) within specified safety limits while maximizing machining efficiency. flowchart TD Prereq[\"Prerequisites<br>(simulation with physics,<br>cutting parameters)\"] Config[\"Configure optimization options\"] Simulate[\"Run simulation\"] Output[\"Generate optimized NC files\"] Verify[\"Verify optimization results\"] Prereq --> Config --> Simulate --> Output --> Verify 1. Prerequisites NC optimization requires a simulation environment with physics enabled and valid cutting parameters: EnablePhysics = true; LoadCuttingParaByFile(\"Material.mp\"); Prerequisite Description Physics enabled EnablePhysics must be true Cutting parameters Workpiece must have loaded milling coefficients (see Workflow: Milling Force Parameter Training) Valid tool definitions Tool geometry, flute count, and material properties configured Note Optimization is based on an ideal geometric model. If the workpiece is a casting or has installation errors, configure a conservatively larger workpiece geometry to prevent misidentification of cutting vs. non-cutting regions. 2. Configure Optimization Options Feed Rate Control Property Description Default OptEnableFeedrate Enable sequential feed rate optimization true OptEnableInterpolation Re-interpolation for smoother acceleration/deceleration — OptRapidFeed_mmdmin Feed rate for non-cutting regions (mm/min) — OptMinFeedrate_mmdmin Minimum cutting-region feed rate (mm/min) — OptMaxFeedrate_mmdmin Maximum cutting-region feed rate (mm/min) — OptMaxAcceleration_mmds2 Acceleration/deceleration limit (mm/s²) — OptFeedrateAssignmentRatio Re-interpolation trigger threshold — Extended Distance Property Description OptExtendedPreDistance_mm Pre-distance for equivalent calculation of cutting regions (mm) OptExtendedPostDistance_mm Post-distance for equivalent calculation of cutting regions (mm) Safety Factors (Physics-Based Constraints) Property Description OptSpindlePowerSafetyFactor Spindle power safety factor (0 = ignore) OptSpindleTorqueSafetyFactor Spindle torque safety factor (0 = ignore) OptThermalYieldSafetyFactor Thermal yield safety factor (0 = ignore) OptPreferedForce_N Target cutting force (N) Note Target value = 100% / Safety factor. For example, a safety factor of 1.5 means the physical quantity targets ~67% of the limit. Constraint Priority In cutting regions, constraints are applied in this order: Direct feed rate constraints (min/max feed rate, min/max feed per tooth from tool settings) Acceleration/deceleration constraints (OptMaxAcceleration_mmds2) Physics-based constraints (spindle power, torque, thermal yield, preferred force) When constraints at the same priority conflict, the lowest feed rate is used. A floor above the ceiling neither fails nor lowers the feed: where the composed minimum feed per tooth exceeds the composed maximum — a minimum feed rate, a minimum feed per tooth or the cutter's minimum uncut chip thickness sitting above the maximum — the boundary collapses onto the minimum, and the step is solved there. Script Command Example OptEnableFeedrate = true; OptEnableInterpolation = true; OptRapidFeed_mmdmin = 4000; OptMinFeedrate_mmdmin = 100; OptMaxFeedrate_mmdmin = 4000; OptMaxAcceleration_mmds2 = 10; OptExtendedPreDistance_mm = 3; OptExtendedPostDistance_mm = 2; OptSpindlePowerSafetyFactor = 1.5; OptSpindleTorqueSafetyFactor = 1.5; OptThermalYieldSafetyFactor = 0; OptPreferedForce_N = double.PositiveInfinity; XML Configuration (NC Code Inline) Optimization settings can be embedded in NC code comments: N0110 X-3.064 Y6.378 (;@OptMaxAcceleration_mmds2=10;) N0150 G01 X-3.068 Y40.776 (;@OptMaxAcceleration_mmds2=100; OptMaxFeedrate_mmdmin=12000;) 3. Run Simulation Configuration can be interleaved between NC files. Settings apply to the files that follow: OptRapidFeed_mmdmin = 4000; PlayNcFile(\"NC/file1.nc\"); OptRapidFeed_mmdmin = 8000; PlayNcFile(\"NC/file2.nc\"); Excluding Lines from Optimization To preserve specific NC lines unchanged: N0140 G03 X-2.66 Y38.193 I-103.796 J7.172 (;@Preserve();) To exclude a range: N0140 G03 X-2.66 Y38.193 (;@BeginPreserve();) N0150 G01 X-3.068 Y40.776 N0160 X-3.555 Y43.338 (;@EndPreserve();) Warning Do not combine UpdateNcOptOption inside the SessionStepBuilt event with NC-embedded optimization commands. This may cause undefined behavior due to parallel computation. 4. Generate Optimized NC Files OptimizeToFiles writes the optimized NC programs: OptimizeToFiles(\"Cache/Opt-[NcName]\"); The [NcName] template is replaced with each input NC file name. What the Run Reports An optimization reports itself to the Shell tab of the Session Messages panel, as a fixed sequence of rows: Row Stage Start NC optimization. the pass opens Computing Optimized Feed by indivisual step.. the per-step feed solve Optimization Feedrate built. the feed solve closed Constrain feedrate By expaneded segment.. the extended-distance constraint Constrain Feedrate By Acceleration.. the acceleration constraint Build Compensation.. the compensation build Regenerate NC commands.. the NC text is rewritten File optimized: <path> one row per written file Total N files optimized. the pass is over optimization cache cleared. the step cache is released Two of those stages tick while they work, and they are the only instrument for telling a slow optimization from a stopped one. The feed solve adds Computing Optimized Feed by indivisual step.. FileNo:<n>, LineNo:<m> every thousand steps solved — StepIndex:<i> instead, for a step that carries no source line — and the writer adds Now optimizing to: FileNo.<n>, LineNo.<m> every thousand lines written. Each names the source file and line the run has reached, so a ladder whose last row keeps advancing is a run still moving through the program, and one that has gone quiet without reaching Total N files optimized. is not. A stage with fewer than a thousand steps or lines to get through announces its start and then says nothing until it ends, so a short program crosses the whole ladder in near-silence. Stop reaches inside an optimization. The transport's Stop is tested between every pair of stages, inside the per-step feed solve, and once per destination piece while files are written, so a stopped optimization halts at the next step or piece boundary rather than running to the end. The Shell ladder says so twice: the feed solve closes with Optimization Feed Process canceled. in place of Optimization Feedrate built., and an optimization canceled. row is added before the pass ends. Important A stopped optimization still ends on the green Total N files optimized. row a completed one ends on. That row is not a statement that the optimization finished — read the row above it. N counts the files the run had begun writing, so a Stop during the feed solve ends on Total 0 files optimized., and a Stop during writing counts the file it was in the middle of, which is left short. 5. Verify Optimization Results Optimization Logs The per-step log is written by default. Every optimization drops one .IndependentStepAdjustment.log beside each optimized NC file that had steps to solve, named after that optimized file, and it records which constraint limited each step. EnableIndividualStepAdjustmentLog is the switch that stops it being written: EnableIndividualStepAdjustmentLog = false; A stopped or failed optimization leaves that file short. Its buffered tail is written out only when the feed solve runs to completion; when the pass is cut off, the lines still in the buffer are dropped, and so is any step line held back in the ordering window waiting for a lower step index that never arrived. Batches reach the file at most once a second, so the missing tail can cover the last second of solving as well as the steps that were never reached. Read the log as a complete record only for a run whose feed solve closed with Optimization Feedrate built. Each row of the .IndependentStepAdjustment.log file opens with the source NC file and line, the step index and the cutter location, then lists the feed per tooth every active criterion allowed: Field Criterion FrtByPreferedForce_mm target cutting force FrtByYieldingStressRatio_mm yielding stress FrtBySpindleTorqueRatio_mm spindle torque FrtBySpindlePowerRatio_mm spindle power FrtByThermalYieldingRatio_mm thermal yield FrtByCustom_mm(n) the n-th custom criterion the script registered FrtByReliefAngle_mm relief-face contact — see Relief Face Avoidance The step's feed per tooth is the lowest of the first six; the relief-angle pass then runs on that value, so its row is the last word rather than one vote among the others. Every row carries the solver's status for that criterion in brackets: Solved when the binary solve converged, Singular / OverIteration / Iterating when it did not, and — on the relief-angle row only — Acceptable, which means the relief face was clear at the feed already chosen, so that row states the feed instead of a limit on it. A criterion with no row at all was switched off (its safety factor is 0) or was not evaluable for that tool. Three rows replace that list rather than joining it: Field Meaning FrtByUnTouched: inf the step cuts nothing, so no physical criterion applies FeedrateByNoData_mmdmin: <feed> no tool or no milling coefficients on the step; it keeps its feed StepFailed: <exception> the solve threw; the step keeps its simulated feed and is reported as an error — see When a Step Cannot Be Solved Embedded Log Comments Control embedded log verbosity with EmbeddedLogMode: Mode Description None No log comments SimpleLog StepIndex on re-interpolated lines; LineNo on last interpolated line per original line FullLog StepIndex and LineNo on all lines Important The mode is read by the legacy optimization path. While EnableSoftNcRunner is on and the session holds played NC — the default — the optimizer writes the SimpleLog shape whatever the mode says: every re-interpolated fragment carries its StepIndex, the last fragment of each source line adds that line's LineNo, and a line the optimizer did not split carries no note. The note is written in the controller's comment grammar, so the optimized file stays legal for the control that reads it. On the Fanuc family it is parenthesized: G01 X10.0 Y20.0 F500 (src(LineNo: 140, StepIndex: 256)) On Heidenhain it is a ; comment, because a TNC reads parentheses as code: 120 L X+35 Y-11.7 R0 F500 ;src(LineNo: 140, StepIndex: 256) On a Heidenhain project a feed word the optimizer has to insert is also placed in the element order a TNC enforces — after the coordinate words, after the rotation direction DR+ / DR-, and after the radius compensation RL / RR / R0. A block that read L X+10 Y+20 RL comes back as L X+10 Y+20 RL F500. Tracking Individual Step Constraints To isolate which physical quantity limits each step, disable smoothing: OptMaxAcceleration_mmds2 = double.PositiveInfinity; OptFeedrateAssignmentRatio = 0; OptExtendedPreDistance_mm = 0; OptExtendedPostDistance_mm = 0; The four smoothing settings are what this block changes. The per-step log is already on, and EmbeddedLogMode does not reach the pipeline that runs by default — see above. Post-Optimization Simulation Differences Optimized feed rates produce different interpolation points, causing: Different simulation mesh errors Surface morphology changes at the surface roughness level (more pronounced at corners) Simulated physical quantities after optimization may be slightly above target values due to these differences. Tip For abnormally low optimized feed rates at corners, refer to Corner Feed Rate Optimization. Tool Breakage Solutions If the simulation shows yielding stress ratio, max spindle torque ratio, or max spindle power ratio above 100%, consider: Modify the toolpath to reduce cutting width/depth Use HiNC optimization to adjust feed rates, bringing these ratios below 100% For thermal edge chipping, reduce the spindle speed to allow heat dissipation. Complete Script Example EnablePhysics = true; LoadCuttingParaByFile(\"Material.mp\"); OptEnableFeedrate = true; OptEnableInterpolation = true; OptRapidFeed_mmdmin = 4000; OptMinFeedrate_mmdmin = 100; OptMaxFeedrate_mmdmin = 4000; OptMaxAcceleration_mmds2 = 10; OptExtendedPreDistance_mm = 3; OptExtendedPostDistance_mm = 2; OptSpindlePowerSafetyFactor = 1.5; OptSpindleTorqueSafetyFactor = 1.5; OptThermalYieldSafetyFactor = 0; OptPreferedForce_N = double.PositiveInfinity; PlayNcFile(\"NC/file1.nc\"); OptimizeToFiles(\"Cache/Opt-[NcName]\"); WriteStepFiles(\"Output/[NcName].step.csv\"); See Also NC Optimization (Concepts) — theory and objectives Corner Feed Rate Optimization Workflow: Milling Force Parameter Training — prerequisite: training cutting parameters Workflow: Basic Machining Simulation — basic simulation setup SessionShell — SessionShell quick-reference"
  },
  "workflows/project-construction.html": {
    "href": "workflows/project-construction.html",
    "title": "Workflow: Constructing a Project through the Web API | HiAPI-C# 2025",
    "summary": "Workflow: Constructing a Project through the Web API Basic Simulation describes what a project contains. This page describes how to build one so that it is actually finished — the ordering that avoids rework, how to shape the mission, and the acceptance test that tells you the project is complete rather than merely populated. It is written for whoever assembles a .hincproj from a customer's deliverables — a person driving the browser UI, or an agent driving the same operations over the HTTP API. flowchart TD New[\"1 · New project<br>(self-contained root)\"] Assets[\"2 · Place assets<br>NC, STL, resource files\"] Equip[\"3 · Equipment<br>chain, spindle\"] Job[\"4 · Job<br>stock, ideal geom, material\"] Ctrl[\"5 · Controller<br>brand + its own tables\"] Tools[\"6 · Tool house\"] Mission[\"7 · Mission<br>grouped, per-group resolution\"] Replay[\"8 · Replay and read<br>every message\"] Cross[\"9 · Numeric cross-checks\"] Assume[\"10 · Record every assumption\"] New --> Assets --> Equip --> Job --> Ctrl --> Tools --> Mission --> Replay --> Cross --> Assume Replay -->|any warning| Ctrl Build through the API, not by editing the XML Create and modify projects through the service's HTTP API. It is the same code path the UI uses, so a project built that way is on the supported create/load/save route. Hand-authoring the .hincproj XML is a fallback for fields the API cannot yet reach — and when you hit one, the better fix is to add the endpoint. 1. One self-contained root The .hincproj and every asset it references live under one folder — the project's own directory — and every reference is relative to it with no ../. <project>/ ├── <name>.hincproj ├── NC/ the programs, copied in ├── Geom/ workpiece / fixture STL ├── MachineTool/ the kinematic chain ├── SpindleCapability/ ├── WorkpieceMaterial/ ├── CuttingParameter/ ├── CutterMaterial/ └── README.md what was assumed, and why Two things do not move themselves, so bring them in by hand before you wire anything: NC files. A program-file command stores a plain relative path; nothing copies the file. Machine-tool side files. A chain that externalises its mechanism references the side file and its STL bodies by bare name, relative to the .mt's own folder — keep the whole folder together. Resource files (chain, spindle, cutting parameters, workpiece material, cutter material) are pre-prepared data loaded by reference. Stage a copy inside the project and load it from there, so the saved reference points inside the project rather than at a shared library. 2. Order the build to avoid rework Later steps read earlier ones, so this order costs the least: New project at its final path. Machine tool, then spindle capability. Workpiece: stock geometry, ideal (target) geometry, resolution, the geometry-to-program-zero and geometry-to-fixture transforms, then material and cutting parameters. Controller: brand first — switching brand later resets brand-specific tables — then the controller's own tables (§4). Tool house: per tool, shaper profile → fluting → exposed height → holder → upper beam → cutter material. Then refresh the offset tables from the tool house. Program zero: with the workpiece placed and the chain loaded, derive the work offset from the model rather than typing a number. See Program Zero Alignment. Mission (§3). Save, then load the saved file back and re-check. A project that cannot be reloaded cleanly is not built. Important Verify the axis set after loading a machine tool. A kinematic chain binds each axis transformer by branch name (X/Y/Z/A/B/C); a branch left at its authoring default name yields no transformer, and that axis silently does not exist. The trap is that the controller preset already seeds the linear axes, so a chain missing its Z branch still reports a Z — only a missing rotary gives it away. Compare the reported axes against the mechanism you expect. 3. Shape the mission around the process, not the file list A flat list of program files runs correctly but reads badly and gives you one knob for the whole job. Group the programs into one List command per operation family, in the order the process actually runs: Machining Motion Resolution Collision Detection [Off] Pause on Failure [Off] Physics [On] ▸ 1 · Drilling Machining Resolution 0.5 mm centre drill, drill ▸ 2 · Outside roughing Machining Resolution 0.5 mm roughing 1 … 5 ▸ 3 · Outside finishing Machining Resolution 0.2 mm finishing 1 … 7 ▸ 4 · Pocket roughing Machining Resolution 0.5 mm ▸ 5 · Pocket finishing Machining Resolution 0.2 mm ▸ 6 · Rest milling Machining Resolution 0.2 mm ▸ 7 · Rib machining Machining Resolution 0.2 mm ▸ 8 · Deburring Machining Resolution 0.2 mm Post-Execution geometry diff on Why this shape: Grouping must not reorder. The stock evolves from one operation to the next, so the sequence is load-bearing. Group adjacent operations; never sort the list into tidy families if that moves an operation past another one. Each group carries its own machining resolution. Roughing is about force, not surface, so a coarse resolution is enough and runs quickly. Finishing, rib and deburring passes leave the final surface with small and ball cutters and deserve a finer one. Setting the resolution mid-mission only changes the value the act runner cuts with — the workpiece is not rebuilt, and the geometry container is adaptive — so alternating coarse and fine between groups is safe. A group is a switch. Disabling one List skips a whole phase, which is how you re-run just the finishing passes without deleting anything. Budget the fine groups. Machining resolution drives the cost of subtracting material, not the number of simulation steps — the step count follows the motion resolution and does not change. On one 33-operation job, refining the finishing groups from 0.5 mm to 0.2 mm left the step count identical and multiplied wall-clock time by about 2.8. Decide the finish resolution with that trade-off in view, and say what it costs in the project's README so nobody is surprised. Setup commands are granular. Machining resolution, motion resolution, collision detection, pause-on-failure and physics are separate commands, so each can sit exactly where it should take effect — global ones at the top, per-phase ones inside a group. Tip A project that loads an ideal (target) geometry and never compares against it is unfinished. Turn on the geometry diff in the Post-Execution command so a full replay ends by measuring the machined stock against the finished part. 4. Fill the controller's own tables The tool house describes the physical tool. The controller has its own record of the same tool, and the NC program reads the controller's copy. Both must exist. For a Siemens-style controller that is two tables: Table Holds If empty Tool name → tool number the names a T=\"…\" call uses the tool never mounts, and the program produces no machining steps at all Tool edge offsets per (tool, edge): length along the tool axis, radius every edge call falls back to the generic offset table and logs a warning Take the values from the tool house and assert they match before writing. When the warning disappears and the cut does not move at all, that is the proof the rows carry the right numbers — if the geometry shifts, one of the two tables was wrong. Note Not every controller parameter has a consumer. Some, such as the maximum spindle speed, are recorded machine data that nothing in the pipeline reads today. Filling them is good hygiene, but do not report it as fixing a defect, and remember that copying a guessed value (an assumed spindle, say) into a second place means both must move when the real datum arrives. 5. The finish line is a clean replay, not a filled form Replay the whole mission and inventory the messages by id. Every warning is an item on the to-do list. Resist writing one up as an acceptable fallback: a fallback firing means the project never supplied the data the fallback exists to cover. Read messages at a low severity so nothing hides. The severities are Message, Success, Progress, Warning, Error — note there is no Info, and an unrecognised name is rejected in the response body rather than by an HTTP error, which reads exactly like “no messages”. Stop when only declared informational messages remain — the ones that state a known, deliberate limitation. Typical survivors: one per NC file, reporting the line count; machine M-codes that the runner recognises and consumes but does not model (OEM auxiliary functions such as coolant valves), which are announced rather than silently ignored. Anything else is work. 6. Two numeric cross-checks — and what they do not prove Messages catch what the runner noticed. These two catch datum errors that produce no message at all. Depth of cut against the programmed layer depth. On a roughing pass whose step-down you can read from the NC, the peak cutting depth must equal it. This pins the Z datum: if program zero is wrong, the tool cuts a different amount and the peak does not land on the programmed number. Cycle time against the post-processor's own estimate. Many post-processors write a per-operation machining time into the program as a comment. Sum them and compare with the simulated time. Warning Scope the cycle-time check honestly. It confirms that feed rates and path length are consumed correctly. It is not a comparison against the real machine, because both sides ignore the same things: there is no acceleration model (time is path length over feed rate, with no ramps — which costs the most on finishing passes made of thousands of short segments), tool-change time defaults to zero, and the tool-change and home positions come from the chain rather than from machine data. For the same reason, a customer's “total machining time” running well above the sum of the per-operation comments is usually not a contradiction — the comments are cutting time, the total is wall clock including tool changes and inter-operation moves. Two different quantities. 7. Record every assumption Real deliverables are incomplete. Build with sensible values, and write each one down in a README.md beside the .hincproj — what was assumed, what it was inferred from, and what changes when the real value arrives. Recurring items: work offsets, blank size and material, tool helix angle, stick-out, holder dimensions, the spindle's power–torque curve, fixture geometry, and the cycle-time inputs above. Cross-reference: Project Data Checklist is the list to hand the customer before building; this section is what you hand back after."
  },
  "workflows/project-data-checklist.html": {
    "href": "workflows/project-data-checklist.html",
    "title": "Project Data Checklist | HiAPI-C# 2025",
    "summary": "Project Data Checklist A HiNC project (.hincproj) is a digital twin of a real machining setup: machine, spindle, workpiece, fixture, tooling, controller, and the NC program. To build one, you must first collect the data that describes the physical setup. This page is the single, canonical list of that data. Hand it to the machine owner / customer as a data-collection checklist before a project is built. The product site shows the same grouping in short form for orientation; the formats, tolerances and worked examples below are here and only here. You do not need a strict form — write the items here up as a short free-text note and hand it over with the CAD and NC files; that is what a HiNC engineer needs to build the .hincproj (see the worked examples below). This page is the list to collect before a project is built. For what the engineer then does with it — build order, mission structure, and how completeness is verified — see Project Construction. Important Identifiers beat half-remembered numbers. Customers rarely have every detail. Where a value is missing, give an identifier — cutter brand + product ID, spindle/machine make + model — and the HiNC engineer sources the rest (cutter geometry from the catalog, the power–torque chart from the spindle datasheet). Capture what you can; the engineer fills the gaps. graph TD subgraph Equipment[\"Equipment (one-time, fixed)\"] M[\"Machine Configuration\"] S[\"Spindle Capability\"] E[\"Environment\"] end subgraph Job[\"Job (per part)\"] W[\"Workpiece\"] F[\"Fixture\"] T[\"Tooling\"] C[\"Controller + NC Program\"] end Equipment --> P[\".hincproj\"] Job --> P At a Glance Each item is marked: Required — a project cannot be built without it. Optional — improves realism but the project still runs without it. Conditional — only needed for a specific check beyond the core cutting-force simulation (e.g. collision detection, geometry validation, spindle-overload analysis), noted in Used for. Category Item Required? Used for Detail Machine Kinematic model & axis configuration (3-/5-axis, motion methods) Required Toolpath, collision Machine Tool Machine Simplified component CAD/STL (table, column, spindle housing…) Conditional Collision detection Machine Tool Machine Travel/stroke limits Conditional Stroke-overrun check — Machine Rapid feedrate, max spindle & rotary speeds Optional Feedrate precision → tighter optimization & physics/timing estimates — Spindle Brand/model + product description (so the chart can be sourced) Conditional Power/torque & overload analysis — a default spindle capability is applied if omitted (fine for light cuts in small/soft stock) — Spindle Speed–power–torque diagram (kW & Nm vs RPM, duty ratings) Conditional (sourced from the brand/model above) Power/torque & overload analysis Spindle Capability Environment Coolant type (other thermal values keep their defaults) Optional Thermal / wear analysis — a default is applied if omitted Coolant Workpiece Material (named or property set) Required Force, thermal — Workpiece Initial (stock) CAD + Finished CAD (STL or parametric) Required (stock) Cut simulation; finished = geometry check Geometry Validation Workpiece Program-zero position in plain words (e.g. “G54 = top centre”) Required Correct engagement Program Zero Alignment Fixture Fixture CAD/STL Optional Collision detection — Tooling Per tool: geometry + cutter & coating material (ideally via cutter brand + product ID) Required Force, deflection, geometry Cutter, Cutter Geometry Tooling Per tool: holder brand+ID (or rough height/radius) Conditional Collision check; how deep the tool reaches — Controller CNC brand/type (Fanuc, Heidenhain, Siemens…) Required NC interpretation Controllers Controller NC / CL program(s) Required The process to simulate ISO / General NC Controller Work offsets (G54…) and tool offset table Optional Estimated/relative values work for evaluation; HiNC can set an assumed offset Program Zero Alignment 1. Machine Configuration The machine is one-time, fixed data: collected once, reused across every job on that machine. Kinematic model & axis configuration — number of axes and how each axis moves (the motion chain from ground → table and ground → spindle). Required. On a multi-axis machine the rotary configuration matters most: name each rotary axis and its pivot location (e.g. table-C / spindle-B). The pivot defines the entire kinematic chain, rotary swings are the most collision-prone motions, and the rotary bodies' geometry makes that motion intelligible — so describe it carefully. Simplified component CAD/STL — table, column, spindle housing, and other bodies, exported from a single coordinate system. Only needed for collision detection — though on a multi-axis machine the rotary bodies (table, cradle, tilt head) are especially worth including, as their geometry also makes the machine's motion intelligible. Keep the mesh simplified; too many triangles slow loading and collision checks. Travel/stroke limits — from the machine spec sheet. Conditional. Only matters when a stroke-overrun check is the goal — and the operator has usually already confirmed the program fits the machine, so it is not needed unless that is the specific thing you want to test. Rapid feedrate, max spindle & rotary speeds — from the machine spec sheet. Optional. Real values let the simulation use a more accurate achievable feedrate, which tightens the optimization and the physics / timing estimates. Helpful but not essential — defaults still produce a valid run. See Machine Tool for how the kinematic chain and anchors are built, and Anchor for coordinate anchors. 2. Spindle Capability Spindle brand / model + product description — name the spindle (or the machine) make and model, with a short description or catalog link, so the chart can be sourced and verified by whoever builds the project. Conditional — needed only when spindle power/torque/overload could matter. Omit it and a default spindle capability is applied; light cuts in small or soft stock rarely stress the spindle, so the default is fine. Speed–power–torque diagram — the spindle's power (kW) and torque (Nm) against RPM, including duty ratings (e.g. S1 continuous / S6 / 15-minute). From the machine or spindle spec sheet. Required for power, torque, and spindle-overload analysis. This is the kind of chart needed — power and torque vs spindle speed, with the continuous (S1) and short-duration (S3) ratings: Tip Easier than transcribing: photograph the spindle motor nameplate. The same ratings are printed on the spindle motor's spec nameplate, usually attached to the machine (on the spindle or motor body). A clear photo of it is enough — the model, type, and the S1/S2/S3 rating table (kW and speeds) recover the power–torque behaviour. Example (a FANUC αiI 6/12000 plate, unit serial removed): See Spindle Capability. 3. Environment Coolant type — which coolant is used. Optional — if omitted, a default coolant setting is applied. The remaining coolant/thermal values (temperature, convection, background temperature) keep their defaults too; they only affect thermal and wear results. See Coolant. 4. Workpiece Material — a named material from the database, or its mechanical/thermal properties. Required. Raw (stock) geometry — STL or simple parametric dimensions (e.g. block 120 x 80 x 40 or round billet Ø65 x 50). Used for the starting shape and size. Required. For a casting or forging, give the as-cast shape as an STL and note its casting tolerance (the stock scatters part-to-part). Finished/design CAD is optional, used to compare the simulated shape against the target (geometry validation). Program-zero position, in plain words — where each work offset (G54, G55…) sits on the part, e.g. “G54 = top centre of the stock; Z0 at the top face, X0/Y0 on the axis”. Required. Note Describe the program zero by position on the part, not the machine-coordinate offset numbers — for evaluation/planning a relative or assumed alignment is fine and HiNC aligns it for you. See Program Zero Alignment. 5. Fixture Fixture CAD/STL — optional, only needed when the fixture participates in collision detection. 6. Tooling For each tool used by the program, collect: Cutter brand + product ID — the maker and catalog number (with datasheet/link if handy). The single most useful field, when the cutter has one: from it the engineer looks up the geometry, flute count, helix, and grade, so give it even if the geometry below is incomplete. Off-brand cutters with no brand, manual, or traceable vendor are common (it depends on the shop) — then skip this and provide the geometry below directly, measured if needed. Cutter geometry — Required (or derivable from the brand + product ID above): type (flat-end / ball / corner-radius / insert), diameter D, corner radius R flute (cuttable) length — the cutting portion overall tool length / stick-out — how far the cutter reaches from the holder to the flute tip; this sets where the holder grips and affects deflection and reach. A plain cylindrical cutter can use a small default exposed length (~5 mm); a cutter that is not a simple cylinder — a stepped or necked shank, or a body wider than the cutting diameter — needs a longer stick-out so the wider non-cutting part clears the workpiece. flute count, helix angle, rake angle (relief angle if known) Cutter & coating material — body material and coating layers. Required. Holder — give the brand + product ID, or at least a rough height + radius (e.g. Ø40 x 60 mm). Full CAD is optional and only needed for collision detection; the rough size is enough to see whether the holder would hit the workpiece and how deep the tool can reach. Where the holder grips the tool comes from the cutter's stick-out above, so the tool can be placed even without holder geometry. Tip The cutter brand + product ID (or a datasheet image) is usually faster and more reliable than transcribing every dimension — the engineer reads the geometry off the catalog. See Cutter, Cutter Geometry and Smart Tool Holder. 7. Controller CNC brand/type — determines how the NC code is interpreted. Required. NC / CL program(s) — the actual programs that run on the machine. Required. Work offsets (G54…) and tool offset table — not required for evaluation/planning. Relative or estimated values work; HiNC can set a workable assumed tool offset for you. Provide the real values only when a high-fidelity match is needed. Stroke limits and machine-specific configuration parameters — optional. See ISO / General NC and Heidenhain Support. Delivery Formats Data Preferred format Machine / fixture geometry STL, all exported from the same coordinate system (see Machine Tool best practices) Workpiece geometry STL (stock + finished) or parametric dimensions Cutter Brand + product ID (best), or geometry parameters / datasheet image Holder Brand + product ID, or rough height + radius Spindle capability Brand + model, plus spec-sheet table or chart image (power & torque vs RPM) NC program The original .nc / .cl files Examples The examples below show how to write it. Provide the item values together with the CAD and NC files; mark estimates, and give the spindle model and cutter brand + product ID where you can, so the engineer can fill any gap. These files include spindle chart photos, cutter catalog pages (e.g. cmtec-CEXCRSH3120005.pdf), CAD (STL/STEP), and NC programs; note the filename next to the matching item. Example 1 — Pocketed plate, 3-axis, steel # Cover plate — TMV-720A 3-axis Pocketed S50C cover plate roughed and finished on a 3-axis vertical machining center (VMC). Goal: verify spindle load on the deep pocket and trim cycle time. ## Machine Model: TongTai TMV-720A, 3-axis VMC Tool mount: (0, 0, 0) mm (where the tool is equipped; taken as the reference point) Table mount: (-450, -340, -630) mm (fixture & workpiece, relative to the tool mount) Controller: Fanuc Strokes: X720 Y420 Z460 mm ; rapid 20000 mm/min ; max spindle 8000 rpm ## Spindle Brand/model: TongTai TMV-720A standard 8000 rpm spindle (BT40) Source: TMV-720A catalog power–torque chart — attachment fanuc-at12-12000i.png (15-min rating below; with the image you need not transcribe these) Power (kW vs rpm): 0@0, 7.5@1500, 7.5@4500, 4@8000 Torque (Nm vs rpm): 50@1500, 37@2000, 30@2600, 19@4000, 12@6000, 8@8000 ## Workpiece Raw stock: block 140 x 90 x 50 mm Design: cover-plate.stl Material: S50C ## Program zero G54 = top centre of the block — Z0 at the top face, X0/Y0 at the block centre. ## Fixture Machine vise — vise.stl, clamps below the part top (collision only). ## Coolant Water-soluble emulsion (flood) ## Tools T1 face mill brand NTM, product TXE1000 (D50, exact P/N missing) D50 6 inserts flute 6 tool length 60 holder Ø60 x 50 mm stick-out 80 T2 flat end brand cmtec, product CEXCRSH3120005 (catalog: cmtec-CEXCRSH3120005.pdf) D12 R0 4 flutes helix 30° rake 10° flute 30 tool length 90 holder Ø40 x 63 stick-out 95 T3 flat end brand cmtec (no exact P/N) D6 R0 4 flutes helix 30° flute 20 tool length 70 holder Ø25 x 60 stick-out 75 ## NC Files (folder `NC/`) O0010.NC face + rough the pocket with T1/T2 — watch spindle load near the deep pocket O0020.NC profile + floor finish with T3 Example 2 — Relief part, 5-axis, aluminum # Airplane relief — 5-axis VMC Airplane + logo lettering milled from a round Al6061T6 billet on a 5-axis vertical machining center (VMC). Goal: check the 5-axis toolpath for collisions/gouges, then optimize feed. ## Machine Model: 5-axis VMC (example machine) (machine file: MachineTool/Vmc5x/Vmc5x.mt) Config: table-C / spindle-B (C rotary on the table, B tilt on the spindle head) Pivots: C at (0, 0, 0), B at (-70, -180, 220) mm (relative to the C pivot) Tool mount: (-70, 70, 175) mm (where the tool is equipped) Controller: Fanuc Strokes: unbounded for this study ; rapid 20000 mm/min ; max spindle 8000 rpm ## Spindle Brand/model: built-in 8000 rpm spindle, ~5.5 kW (BT30 class) Source: machine builder spindle datasheet (power–torque chart; attachment b1-spindle-chart.png) Power (kW vs rpm): 0@0, 5.5@1500, 5.5@4500, 3@8000 Torque (Nm vs rpm): 50@1500, 30@2000, 20@3000, 15@4000, 8@6000, 5@8000 ## Workpiece Raw stock: round billet Ø65 x 50 mm Design: airplane.stl Material: Al6061T6 ## Program zero G54 = top centre of the billet — Z0 at the top face, X0/Y0 on the axis. (G55+ unused.) ## Fixture Round fixture Ø100 x 10 mm under the billet (collision only). ## Coolant Air blast (dry) ## Tools <!-- brand given but NO product ID, so the engineer recovers the exact geometry and grade by measurement — slower and more error-prone. A brand + product ID is very helpful when the tool has one; off-brand tools without one must be measured. --> (all: brand cmtec, aluminum grade — product ID not given; carbide, 3 flutes, helix 37°, rake 15°, relief 5° [helix/rake estimated]; holder Ø25 x 60 mm, 8 mm flute-to-nose clearance) T1 flat end D6 R0 flute 20 tool length 75 T2 ball end D6 flute 20 tool length 75 T3 ball end D3 flute 20 tool length 75 T4 ball end D2 flute 8 tool length 75 ## NC Files (34 programs in folder `NC/`; actual filenames below) 01-ED6L20.NC, 02-ED6L20.NC … 10-ED6L28.NC roughing with T1 (flat D6) 11-R3L25.NC … 22-R3L25.NC semi-finish with T2 (ball D6) 23-R2L25.NC … 30-R2L25.NC finishing airplane-R1L12.NC, logo1-R1L12.NC, logo2-R1L12.NC, logo3-R1L12.NC detail airplane + logo with T4 (ball D2) (filename = seq-toolcode+cutlength; ED6 = flat end mill D6, R3/R2/R1 = ball, digit = nose radius) Note Example 2 mirrors a real .hincproj (machine name anonymized); Example 1 is representative with estimated values. The spindle model and the cutter brand + product ID are the anchors from which the engineer recovers the geometry and the power–torque chart. See Also Workflow: Basic Machining Simulation — set up and run a simulation once the data is collected Cutter — create the tools this list collects data for Machine Tool — build the kinematic model from CAD Program Zero Alignment — how HiNC aligns the program zero Spindle Capability — the speed–power–torque model"
  },
  "workflows/sensor-mapping.html": {
    "href": "workflows/sensor-mapping.html",
    "title": "Workflow: Sensor Data Mapping | HiAPI-C# 2025",
    "summary": "Workflow: Sensor Data Mapping This workflow covers mapping external sensor data (dynamometer, smart tool holder, accelerometer) to simulation toolpaths so that simulation steps can index real-world measurement data. flowchart TD Prepare[\"Prepare sensor CSV data\"] Configure[\"Configure time mapping\"] Simulate[\"Run simulation\"] Map[\"Map data to simulation steps\"] View[\"View mapped results\"] Prepare --> Configure --> Simulate --> Map --> View Overview Data mapping associates external sensor measurements with simulated machining steps. After mapping, each step can reference real-world force, torque, and acceleration data for: Inspecting machining states Training milling coefficients (see Workflow: Milling Force Parameter Training) Calibrating milling coefficients Comparing simulated vs. measured forces Depending on data volume and application, mapping is either one-to-one (each step maps to one data point) or one-to-many (each step maps to multiple data points from high-sampling-rate sensors). 1. Prepare Sensor CSV Data Sensor Data Format The CSV file must have a header row with ActualTime and sensor channels: Source Headers Aliases Dynamometer Fx, Fy, Fz Workpiece.Fx, Workpiece.Fy, Workpiece.Fz Smart tool holder Mx, My, Mz Holder.Mx, Holder.My, Holder.Mz Accelerometer Ax, Ay, Az — ActualTime,Mx,My,Mz 18:23:54.703,-0.02923,0.10733,0.00409 18:23:54.704,0.04155,-0.04457,0.00448 ... The time format is <hours>:<minutes>:<seconds>.<fractional seconds>. Additional fields (e.g., CH1, CH2) may be included and will be available after mapping. Controller Data Format (for Two-Layer Mapping) The controller CSV must contain FileNo, LineNo and one of three time columns: FileNo,LineNo,ActualTimecode,ActualDateTime,MC.X,MC.Y,MC.Z,... 1,6,00:00:00.030,2026-03-16 15:57:45.559000,0,0,0.37,... Time column What it carries ActualTimecode The run-relative timecode written by WriteStepFiles(API). ActualDateTime, the absolute controller instant, rides beside it and is optional. ActualTime The legacy single column, still read. A bare timecode cell is used as-is; an absolute date-time cell is rebased through the mapping anchor's converter. EndTimecode The simulated end timecode, used as a fallback when neither of the above parses. Files written before that rename carry AccumulatedTime, which is also accepted. A header row with none of the three is refused by name rather than mapped to nothing. A file this product exported carries the first pair, not the legacy column — which is why a step file plays back and maps without editing its headers. 2. Configure Time Mapping Strategy A: One-to-One Mapping (MapSingleByCsvFile) MapSingleByCsvFile reads a CSV file and uses time interpolation to map each data point to one simulation step. PlayNcFile(\"NC/file1.nc\"); MapSingleByCsvFile(\"Data/sensor.csv\"); Strategy B: One-to-One via PlayCsvFile PlayCsvFile can drive the simulation directly from CSV data, where each row becomes one step. Custom fields in the CSV are automatically available on each step. PlayCsvFile(\"Data/controller.csv\"); Strategy C: One-to-Many Global Mapping (MapSeriesByCsvFile) For high-sampling-rate data, first establish ActualTime via one-to-one mapping, then map the series: PlayNcFile(\"NC/file1.nc\"); MapSingleByCsvFile(\"Data/controller.csv\"); // establishes ActualTime MapSeriesByCsvFile(\"Data/sensor.csv\"); // maps high-rate series Strategy D: One-to-Many Local Mapping (Anchor-Based) For mapping sensor data to specific NC path segments using anchors. Step 1 — Specify input data and time ranges: ClearTimeMappingData(); AddTimeDataByFile(\"lineA\", \"Mapping/sensor1.csv\", \"18:25:51.7100\", \"18:26:12.9910\"); AddTimeDataByFile(\"lineB\", \"Mapping/sensor1.csv\", \"18:26:30.5750\", \"18:27:12.2880\"); Step 2 — Specify NC path anchors (embedded in NC code): X13. F20 ;@LineSelection(\"lineA\", FirstTouch, ShiftTime_s(2), LineEnd, ShiftDistance_mm(-1)); X25. F10 ;@LineSelection(\"lineB\", FirstTouch, null, LastTouch, null); For range mapping across multiple NC lines, use BeginSelection / EndSelection: ;@BeginSelection(\"region1\", LineBegin, null); ... ;@EndSelection(\"region1\", LineEnd, null); Anchor Flags: Flag Description LineBegin Motion start point of the line LineEnd Motion end point of the line FirstTouch First contact with the workpiece LastTouch Last contact with the workpiece Offset Options: Offset Description null No offset ShiftTime_s(<seconds>) Time-based offset (positive = forward) ShiftDistance_mm(<mm>) Distance-based offset (positive = forward) Note For FANUC controllers that do not support ; as a comment character, enclose the script command in a comment block: X13. F20 (;@LineSelection(\"lineA\", FirstTouch, null, LineEnd, null);) Map on Selection End EnableMapOnSelectionEnd controls automatic mapping when a selection ends (default: true): EnableMapOnSelectionEnd = true; // EndSelection triggers Map automatically Clearing Mapping Data Mapping data persists across player resets. To clear: ClearTimeMappingData(); 3. Run Simulation PlayNcFile(\"NC/file1.nc\"); Note Why interpret NC code instead of playing CSV directly? The system NC interpreter produces more accurate simulation paths than direct controller CSV playback, which has limited sampling resolution that distorts tool paths. 4. Map Data After simulation, apply the mapping strategy chosen in step 2. For the two-layer chained approach: // Chain 1: Controller data → simulation steps (via FileNo/LineNo → ActualTime) MapSingleByCsvFile(\"Data/controller.csv\"); // Chain 2: Sensor data → simulation steps (via ActualTime → sensor readings) MapSeriesByCsvFile(\"Data/sensor.csv\"); The chaining works because: Simulation steps and controller data share FileNo/LineNo anchors Controller data and sensor data share ActualTime anchors After chaining, simulation steps can index sensor data Tip Due to machine acceleration/deceleration, simulation time and actual time diverge over longer durations. Anchor-based linear projection corrects for this drift. 5. View Mapped Results After mapping, sensor data is available on each step. Use the UI to: View color gradient maps on the workpiece geometry Inspect time-series charts Click-to-track specific data channels Export mapped results: WriteStepFiles(\"Output/[NcName].step.csv\"); WriteShotFiles(\"Output/[NcName].shot.csv\", 1); Complete Two-Layer Mapping Example // Configure resolution MachiningResolution_mm = 0.125; EnablePhysics = true; // Clear any previous mapping data ClearTimeMappingData(); // Run simulation using NC interpreter for accurate paths PlayNcFile(\"NC/machining.nc\"); // Map controller data (contains FileNo, LineNo, ActualTime) MapSingleByCsvFile(\"Data/controller.csv\"); // Map high-rate sensor data (contains ActualTime and force/torque) MapSeriesByCsvFile(\"Data/sensor.csv\"); // Export results WriteStepFiles(\"Output/[NcName].step.csv\"); See Also Workflow: Milling Force Parameter Training — using mapped data for coefficient training Workflow: Basic Machining Simulation — basic simulation setup Step — step data model SessionShell — SessionShell quick-reference Example Project: Mapping Controller and Sensor Data to Simulated NC Toolpaths and Updating Milling Coefficients — mapping demo example project Example Project: Training Milling Coefficients with a Dynamometer — dynamometer training example project"
  },
  "workflows/simulation-report.html": {
    "href": "workflows/simulation-report.html",
    "title": "Workflow: Building a Simulation Report | HiAPI-C# 2025",
    "summary": "Workflow: Building a Simulation Report After a simulation has run, a report communicates the result: what the finished part looks like, how the machining loads evolved over the program, and whether the run was clean. This workflow covers how to turn a completed player session into a focused set of report captures — keeping the panels that carry result information and leaving out the navigation chrome. flowchart TD Build[\"Build project<br>(equipment, job, options)\"] Run[\"Run simulation\"] Capture[\"Capture focused views<br>(canvas · strip charts · messages)\"] Assemble[\"Assemble report\"] Build --> Run --> Capture --> Assemble 1. Build and Run Stand up and run the project first — see Basic Machining Simulation for equipment, job, options, and the Play* run commands. A report is built from a completed run: the workpiece geometry is final and the strip charts span the whole program. 2. What to Capture — and What to Leave Out The player screen carries more panels than a report needs. A good report keeps the panels that hold result information and drops the navigation chrome: Panel In a report? Why Main 3D canvas Keep The finished part — the headline image Strip Charts Keep Machining loads / availability over the whole program Session Messages Keep (optional) The run log — proof the run was clean Control Tree column Drop Navigation only; no result content Selected-Step Info column Drop Single-step detail; not a whole-run summary Use the three region quick-toggles in the top toolbar to collapse the columns you are not capturing, so each kept panel gets the full width/height. 3. Main 3D Canvas — Several Views Capture the finished part from several angles. Use the View menu on the Rendering Canvas Tool Bar to switch between the orthographic and isometric presets (Isometric, Front, Back, Left, Right, Top, Bottom). Isometric + Top are the most informative for most parts. Add Front / Right for thin or shallow parts, where the side profile carries the wall thickness. Tip The tool-path overlay carries information too — capture both. The machined tool-path overlay (the CL strip) shows the machining coverage and the retract/plunge motion, but it can be dense enough to obscure the part shape underneath. It is worth capturing each view both ways: with the tool path on (machining coverage) and off (clean part). Toggle it with the Tool Path button on the Execution Extended RenderingCanvas Tool Bar (and Path Points off with it). The workpiece geometry is a separate display flag, so it stays visible when the tool path is off. 4. Strip Charts — Capture Wide The strip charts read best wide: at full width the whole-program time axis is legible and the per-series peaks are distinct. Before capturing, widen the right dock (drag its divider, or collapse the Selected-Step Info column so the charts fill the dock). See Strip Charts for the chart types (Availability, Roughness, Color-Index) and their legends. 5. Session Messages — the Run Log The Session Messages panel's Shell / NC / Step tabs are the run log. Zero errors across all three tabs is the single strongest piece of report evidence that the run was clean. Use the panel's Export action to save the full log alongside the report. 6. Assemble Combine the captures into the report: a multi-view montage of the finished part, the wide strip charts, and (optionally) the session log. Pair each with a one-line caption stating what it shows (part geometry, load history, clean run). See Also Basic Machining Simulation — build and run the project first Strip Charts — chart types and legends Execution Extended RenderingCanvas Tool Bar — the Tool Path / Path Points toggles Session Message Panel — Shell / NC / Step tabs and Export SessionShell — SessionShell quick-reference"
  }
}